generated.go

// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.

package gen

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"strconv"
	"sync"
	"sync/atomic"
	"time"

	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/introspection"
	"github.com/99designs/gqlgen/plugin/federation/fedruntime"
	gqlparser "github.com/vektah/gqlparser/v2"
	"github.com/vektah/gqlparser/v2/ast"
)

// region    ************************** generated!.gotpl **************************

// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
	return &executableSchema{
		resolvers:  cfg.Resolvers,
		directives: cfg.Directives,
		complexity: cfg.Complexity,
	}
}

type Config struct {
	Resolvers  ResolverRoot
	Directives DirectiveRoot
	Complexity ComplexityRoot
}

type ResolverRoot interface {
	Company() CompanyResolver
	CompanyResultType() CompanyResultTypeResolver
	Mutation() MutationResolver
	PlainEntity() PlainEntityResolver
	PlainEntityResultType() PlainEntityResultTypeResolver
	Query() QueryResolver
	Task() TaskResolver
	TaskCategory() TaskCategoryResolver
	TaskCategoryResultType() TaskCategoryResultTypeResolver
	TaskResultType() TaskResultTypeResolver
	User() UserResolver
	UserResultType() UserResultTypeResolver
}

type DirectiveRoot struct {
}

type ComplexityRoot struct {
	Address struct {
		City   func(childComplexity int) int
		Street func(childComplexity int) int
		Zip    func(childComplexity int) int
	}

	Company struct {
		Country             func(childComplexity int) int
		CountryID           func(childComplexity int) int
		CreatedAt           func(childComplexity int) int
		CreatedBy           func(childComplexity int) int
		Employees           func(childComplexity int) int
		EmployeesConnection func(childComplexity int, offset *int, limit *int, q *string, sort []*UserSortType, filter *UserFilterType) int
		EmployeesIds        func(childComplexity int) int
		ID                  func(childComplexity int) int
		Name                func(childComplexity int) int
		Reviews             func(childComplexity int) int
		UpdatedAt           func(childComplexity int) int
		UpdatedBy           func(childComplexity int) int
		UppercaseName       func(childComplexity int) int
	}

	CompanyResultType struct {
		Count func(childComplexity int) int
		Items func(childComplexity int) int
	}

	Country struct {
		ID func(childComplexity int) int
	}

	Mutation struct {
		CreateCompany           func(childComplexity int, input map[string]interface{}) int
		CreatePlainEntity       func(childComplexity int, input map[string]interface{}) int
		CreateTask              func(childComplexity int, input map[string]interface{}) int
		CreateTaskCategory      func(childComplexity int, input map[string]interface{}) int
		CreateUser              func(childComplexity int, input map[string]interface{}) int
		DeleteAllCompanies      func(childComplexity int) int
		DeleteAllPlainEntities  func(childComplexity int) int
		DeleteAllTaskCategories func(childComplexity int) int
		DeleteAllTasks          func(childComplexity int) int
		DeleteAllUsers          func(childComplexity int) int
		DeleteCompany           func(childComplexity int, id string) int
		DeletePlainEntity       func(childComplexity int, id string) int
		DeleteTask              func(childComplexity int, id string) int
		DeleteTaskCategory      func(childComplexity int, id string) int
		DeleteUser              func(childComplexity int, id string) int
		UpdateCompany           func(childComplexity int, id string, input map[string]interface{}) int
		UpdatePlainEntity       func(childComplexity int, id string, input map[string]interface{}) int
		UpdateTask              func(childComplexity int, id string, input map[string]interface{}) int
		UpdateTaskCategory      func(childComplexity int, id string, input map[string]interface{}) int
		UpdateUser              func(childComplexity int, id string, input map[string]interface{}) int
	}

	PlainEntity struct {
		CreatedAt func(childComplexity int) int
		CreatedBy func(childComplexity int) int
		Date      func(childComplexity int) int
		ID        func(childComplexity int) int
		ShortText func(childComplexity int) int
		Text      func(childComplexity int) int
		UpdatedAt func(childComplexity int) int
		UpdatedBy func(childComplexity int) int
	}

	PlainEntityResultType struct {
		Count func(childComplexity int) int
		Items func(childComplexity int) int
	}

	Query struct {
		Companies          func(childComplexity int, offset *int, limit *int, q *string, sort []*CompanySortType, filter *CompanyFilterType) int
		Company            func(childComplexity int, id *string, q *string, filter *CompanyFilterType) int
		Hello              func(childComplexity int) int
		PlainEntities      func(childComplexity int, offset *int, limit *int, q *string, sort []*PlainEntitySortType, filter *PlainEntityFilterType) int
		PlainEntity        func(childComplexity int, id *string, q *string, filter *PlainEntityFilterType) int
		Task               func(childComplexity int, id *string, q *string, filter *TaskFilterType) int
		TaskCategories     func(childComplexity int, offset *int, limit *int, q *string, sort []*TaskCategorySortType, filter *TaskCategoryFilterType) int
		TaskCategory       func(childComplexity int, id *string, q *string, filter *TaskCategoryFilterType) int
		Tasks              func(childComplexity int, offset *int, limit *int, q *string, sort []*TaskSortType, filter *TaskFilterType) int
		TopCompanies       func(childComplexity int) int
		User               func(childComplexity int, id *string, q *string, filter *UserFilterType) int
		Users              func(childComplexity int, offset *int, limit *int, q *string, sort []*UserSortType, filter *UserFilterType) int
		__resolve__service func(childComplexity int) int
	}

	Review struct {
		Company     func(childComplexity int) int
		ID          func(childComplexity int) int
		ReferenceID func(childComplexity int) int
	}

	Task struct {
		Assignee             func(childComplexity int) int
		AssigneeID           func(childComplexity int) int
		Categories           func(childComplexity int) int
		CategoriesConnection func(childComplexity int, offset *int, limit *int, q *string, sort []*TaskCategorySortType, filter *TaskCategoryFilterType) int
		CategoriesIds        func(childComplexity int) int
		Completed            func(childComplexity int) int
		CreatedAt            func(childComplexity int) int
		CreatedBy            func(childComplexity int) int
		DueDate              func(childComplexity int) int
		ID                   func(childComplexity int) int
		Meta                 func(childComplexity int) int
		Metas                func(childComplexity int) int
		Owner                func(childComplexity int) int
		OwnerID              func(childComplexity int) int
		ParentTask           func(childComplexity int) int
		ParentTaskID         func(childComplexity int) int
		State                func(childComplexity int) int
		Subtasks             func(childComplexity int) int
		SubtasksConnection   func(childComplexity int, offset *int, limit *int, q *string, sort []*TaskSortType, filter *TaskFilterType) int
		SubtasksIds          func(childComplexity int) int
		Title                func(childComplexity int) int
		UpdatedAt            func(childComplexity int) int
		UpdatedBy            func(childComplexity int) int
	}

	TaskCategory struct {
		CreatedAt       func(childComplexity int) int
		CreatedBy       func(childComplexity int) int
		ID              func(childComplexity int) int
		Name            func(childComplexity int) int
		Tasks           func(childComplexity int) int
		TasksConnection func(childComplexity int, offset *int, limit *int, q *string, sort []*TaskSortType, filter *TaskFilterType) int
		TasksIds        func(childComplexity int) int
		UpdatedAt       func(childComplexity int) int
		UpdatedBy       func(childComplexity int) int
	}

	TaskCategoryResultType struct {
		Count func(childComplexity int) int
		Items func(childComplexity int) int
	}

	TaskMeta struct {
		Key   func(childComplexity int) int
		Value func(childComplexity int) int
	}

	TaskResultType struct {
		Count func(childComplexity int) int
		Items func(childComplexity int) int
	}

	User struct {
		Address                func(childComplexity int) int
		AddressRaw             func(childComplexity int) int
		Code                   func(childComplexity int) int
		CreatedAt              func(childComplexity int) int
		CreatedBy              func(childComplexity int) int
		CreatedTasks           func(childComplexity int) int
		CreatedTasksConnection func(childComplexity int, offset *int, limit *int, q *string, sort []*TaskSortType, filter *TaskFilterType) int
		CreatedTasksIds        func(childComplexity int) int
		Email                  func(childComplexity int) int
		Employers              func(childComplexity int) int
		EmployersConnection    func(childComplexity int, offset *int, limit *int, q *string, sort []*CompanySortType, filter *CompanyFilterType) int
		EmployersIds           func(childComplexity int) int
		FirstName              func(childComplexity int) int
		ID                     func(childComplexity int) int
		LastName               func(childComplexity int) int
		Salary                 func(childComplexity int) int
		Tasks                  func(childComplexity int) int
		TasksConnection        func(childComplexity int, offset *int, limit *int, q *string, sort []*TaskSortType, filter *TaskFilterType) int
		TasksIds               func(childComplexity int) int
		UpdatedAt              func(childComplexity int) int
		UpdatedBy              func(childComplexity int) int
	}

	UserResultType struct {
		Count func(childComplexity int) int
		Items func(childComplexity int) int
	}

	Service struct {
		SDL func(childComplexity int) int
	}
}

type CompanyResolver interface {
	Country(ctx context.Context, obj *Company) (*Country, error)
	Employees(ctx context.Context, obj *Company) ([]*User, error)
	Reviews(ctx context.Context, obj *Company) ([]*Review, error)

	EmployeesIds(ctx context.Context, obj *Company) ([]string, error)
	EmployeesConnection(ctx context.Context, obj *Company, offset *int, limit *int, q *string, sort []*UserSortType, filter *UserFilterType) (*UserResultType, error)
	UppercaseName(ctx context.Context, obj *Company) (string, error)
}
type CompanyResultTypeResolver interface {
	Items(ctx context.Context, obj *CompanyResultType) ([]*Company, error)
	Count(ctx context.Context, obj *CompanyResultType) (int, error)
}
type MutationResolver interface {
	CreateTask(ctx context.Context, input map[string]interface{}) (*Task, error)
	UpdateTask(ctx context.Context, id string, input map[string]interface{}) (*Task, error)
	DeleteTask(ctx context.Context, id string) (*Task, error)
	DeleteAllTasks(ctx context.Context) (bool, error)
	CreateTaskCategory(ctx context.Context, input map[string]interface{}) (*TaskCategory, error)
	UpdateTaskCategory(ctx context.Context, id string, input map[string]interface{}) (*TaskCategory, error)
	DeleteTaskCategory(ctx context.Context, id string) (*TaskCategory, error)
	DeleteAllTaskCategories(ctx context.Context) (bool, error)
	CreateCompany(ctx context.Context, input map[string]interface{}) (*Company, error)
	UpdateCompany(ctx context.Context, id string, input map[string]interface{}) (*Company, error)
	DeleteCompany(ctx context.Context, id string) (*Company, error)
	DeleteAllCompanies(ctx context.Context) (bool, error)
	CreateUser(ctx context.Context, input map[string]interface{}) (*User, error)
	UpdateUser(ctx context.Context, id string, input map[string]interface{}) (*User, error)
	DeleteUser(ctx context.Context, id string) (*User, error)
	DeleteAllUsers(ctx context.Context) (bool, error)
	CreatePlainEntity(ctx context.Context, input map[string]interface{}) (*PlainEntity, error)
	UpdatePlainEntity(ctx context.Context, id string, input map[string]interface{}) (*PlainEntity, error)
	DeletePlainEntity(ctx context.Context, id string) (*PlainEntity, error)
	DeleteAllPlainEntities(ctx context.Context) (bool, error)
}
type PlainEntityResolver interface {
	ShortText(ctx context.Context, obj *PlainEntity) (string, error)
}
type PlainEntityResultTypeResolver interface {
	Items(ctx context.Context, obj *PlainEntityResultType) ([]*PlainEntity, error)
	Count(ctx context.Context, obj *PlainEntityResultType) (int, error)
}
type QueryResolver interface {
	Task(ctx context.Context, id *string, q *string, filter *TaskFilterType) (*Task, error)
	Tasks(ctx context.Context, offset *int, limit *int, q *string, sort []*TaskSortType, filter *TaskFilterType) (*TaskResultType, error)
	TaskCategory(ctx context.Context, id *string, q *string, filter *TaskCategoryFilterType) (*TaskCategory, error)
	TaskCategories(ctx context.Context, offset *int, limit *int, q *string, sort []*TaskCategorySortType, filter *TaskCategoryFilterType) (*TaskCategoryResultType, error)
	Company(ctx context.Context, id *string, q *string, filter *CompanyFilterType) (*Company, error)
	Companies(ctx context.Context, offset *int, limit *int, q *string, sort []*CompanySortType, filter *CompanyFilterType) (*CompanyResultType, error)
	User(ctx context.Context, id *string, q *string, filter *UserFilterType) (*User, error)
	Users(ctx context.Context, offset *int, limit *int, q *string, sort []*UserSortType, filter *UserFilterType) (*UserResultType, error)
	PlainEntity(ctx context.Context, id *string, q *string, filter *PlainEntityFilterType) (*PlainEntity, error)
	PlainEntities(ctx context.Context, offset *int, limit *int, q *string, sort []*PlainEntitySortType, filter *PlainEntityFilterType) (*PlainEntityResultType, error)
	Hello(ctx context.Context) (string, error)
	TopCompanies(ctx context.Context) ([]*Company, error)
}
type TaskResolver interface {
	Metas(ctx context.Context, obj *Task) ([]*TaskMeta, error)
	Meta(ctx context.Context, obj *Task) (*TaskMeta, error)
	Assignee(ctx context.Context, obj *Task) (*User, error)
	Owner(ctx context.Context, obj *Task) (*User, error)
	ParentTask(ctx context.Context, obj *Task) (*Task, error)
	Subtasks(ctx context.Context, obj *Task) ([]*Task, error)
	Categories(ctx context.Context, obj *Task) ([]*TaskCategory, error)

	SubtasksIds(ctx context.Context, obj *Task) ([]string, error)
	SubtasksConnection(ctx context.Context, obj *Task, offset *int, limit *int, q *string, sort []*TaskSortType, filter *TaskFilterType) (*TaskResultType, error)
	CategoriesIds(ctx context.Context, obj *Task) ([]string, error)
	CategoriesConnection(ctx context.Context, obj *Task, offset *int, limit *int, q *string, sort []*TaskCategorySortType, filter *TaskCategoryFilterType) (*TaskCategoryResultType, error)
}
type TaskCategoryResolver interface {
	Tasks(ctx context.Context, obj *TaskCategory) ([]*Task, error)

	TasksIds(ctx context.Context, obj *TaskCategory) ([]string, error)
	TasksConnection(ctx context.Context, obj *TaskCategory, offset *int, limit *int, q *string, sort []*TaskSortType, filter *TaskFilterType) (*TaskResultType, error)
}
type TaskCategoryResultTypeResolver interface {
	Items(ctx context.Context, obj *TaskCategoryResultType) ([]*TaskCategory, error)
	Count(ctx context.Context, obj *TaskCategoryResultType) (int, error)
}
type TaskResultTypeResolver interface {
	Items(ctx context.Context, obj *TaskResultType) ([]*Task, error)
	Count(ctx context.Context, obj *TaskResultType) (int, error)
}
type UserResolver interface {
	Address(ctx context.Context, obj *User) (*Address, error)

	Employers(ctx context.Context, obj *User) ([]*Company, error)
	Tasks(ctx context.Context, obj *User) ([]*Task, error)
	CreatedTasks(ctx context.Context, obj *User) ([]*Task, error)

	EmployersIds(ctx context.Context, obj *User) ([]string, error)
	EmployersConnection(ctx context.Context, obj *User, offset *int, limit *int, q *string, sort []*CompanySortType, filter *CompanyFilterType) (*CompanyResultType, error)
	TasksIds(ctx context.Context, obj *User) ([]string, error)
	TasksConnection(ctx context.Context, obj *User, offset *int, limit *int, q *string, sort []*TaskSortType, filter *TaskFilterType) (*TaskResultType, error)
	CreatedTasksIds(ctx context.Context, obj *User) ([]string, error)
	CreatedTasksConnection(ctx context.Context, obj *User, offset *int, limit *int, q *string, sort []*TaskSortType, filter *TaskFilterType) (*TaskResultType, error)
}
type UserResultTypeResolver interface {
	Items(ctx context.Context, obj *UserResultType) ([]*User, error)
	Count(ctx context.Context, obj *UserResultType) (int, error)
}

type executableSchema struct {
	resolvers  ResolverRoot
	directives DirectiveRoot
	complexity ComplexityRoot
}

func (e *executableSchema) Schema() *ast.Schema {
	return parsedSchema
}

func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
	ec := executionContext{nil, e}
	_ = ec
	switch typeName + "." + field {

	case "Address.city":
		if e.complexity.Address.City == nil {
			break
		}

		return e.complexity.Address.City(childComplexity), true

	case "Address.street":
		if e.complexity.Address.Street == nil {
			break
		}

		return e.complexity.Address.Street(childComplexity), true

	case "Address.zip":
		if e.complexity.Address.Zip == nil {
			break
		}

		return e.complexity.Address.Zip(childComplexity), true

	case "Company.country":
		if e.complexity.Company.Country == nil {
			break
		}

		return e.complexity.Company.Country(childComplexity), true

	case "Company.countryId":
		if e.complexity.Company.CountryID == nil {
			break
		}

		return e.complexity.Company.CountryID(childComplexity), true

	case "Company.createdAt":
		if e.complexity.Company.CreatedAt == nil {
			break
		}

		return e.complexity.Company.CreatedAt(childComplexity), true

	case "Company.createdBy":
		if e.complexity.Company.CreatedBy == nil {
			break
		}

		return e.complexity.Company.CreatedBy(childComplexity), true

	case "Company.employees":
		if e.complexity.Company.Employees == nil {
			break
		}

		return e.complexity.Company.Employees(childComplexity), true

	case "Company.employeesConnection":
		if e.complexity.Company.EmployeesConnection == nil {
			break
		}

		args, err := ec.field_Company_employeesConnection_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Company.EmployeesConnection(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*UserSortType), args["filter"].(*UserFilterType)), true

	case "Company.employeesIds":
		if e.complexity.Company.EmployeesIds == nil {
			break
		}

		return e.complexity.Company.EmployeesIds(childComplexity), true

	case "Company.id":
		if e.complexity.Company.ID == nil {
			break
		}

		return e.complexity.Company.ID(childComplexity), true

	case "Company.name":
		if e.complexity.Company.Name == nil {
			break
		}

		return e.complexity.Company.Name(childComplexity), true

	case "Company.reviews":
		if e.complexity.Company.Reviews == nil {
			break
		}

		return e.complexity.Company.Reviews(childComplexity), true

	case "Company.updatedAt":
		if e.complexity.Company.UpdatedAt == nil {
			break
		}

		return e.complexity.Company.UpdatedAt(childComplexity), true

	case "Company.updatedBy":
		if e.complexity.Company.UpdatedBy == nil {
			break
		}

		return e.complexity.Company.UpdatedBy(childComplexity), true

	case "Company.uppercaseName":
		if e.complexity.Company.UppercaseName == nil {
			break
		}

		return e.complexity.Company.UppercaseName(childComplexity), true

	case "CompanyResultType.count":
		if e.complexity.CompanyResultType.Count == nil {
			break
		}

		return e.complexity.CompanyResultType.Count(childComplexity), true

	case "CompanyResultType.items":
		if e.complexity.CompanyResultType.Items == nil {
			break
		}

		return e.complexity.CompanyResultType.Items(childComplexity), true

	case "Country.id":
		if e.complexity.Country.ID == nil {
			break
		}

		return e.complexity.Country.ID(childComplexity), true

	case "Mutation.createCompany":
		if e.complexity.Mutation.CreateCompany == nil {
			break
		}

		args, err := ec.field_Mutation_createCompany_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.CreateCompany(childComplexity, args["input"].(map[string]interface{})), true

	case "Mutation.createPlainEntity":
		if e.complexity.Mutation.CreatePlainEntity == nil {
			break
		}

		args, err := ec.field_Mutation_createPlainEntity_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.CreatePlainEntity(childComplexity, args["input"].(map[string]interface{})), true

	case "Mutation.createTask":
		if e.complexity.Mutation.CreateTask == nil {
			break
		}

		args, err := ec.field_Mutation_createTask_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.CreateTask(childComplexity, args["input"].(map[string]interface{})), true

	case "Mutation.createTaskCategory":
		if e.complexity.Mutation.CreateTaskCategory == nil {
			break
		}

		args, err := ec.field_Mutation_createTaskCategory_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.CreateTaskCategory(childComplexity, args["input"].(map[string]interface{})), true

	case "Mutation.createUser":
		if e.complexity.Mutation.CreateUser == nil {
			break
		}

		args, err := ec.field_Mutation_createUser_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.CreateUser(childComplexity, args["input"].(map[string]interface{})), true

	case "Mutation.deleteAllCompanies":
		if e.complexity.Mutation.DeleteAllCompanies == nil {
			break
		}

		return e.complexity.Mutation.DeleteAllCompanies(childComplexity), true

	case "Mutation.deleteAllPlainEntities":
		if e.complexity.Mutation.DeleteAllPlainEntities == nil {
			break
		}

		return e.complexity.Mutation.DeleteAllPlainEntities(childComplexity), true

	case "Mutation.deleteAllTaskCategories":
		if e.complexity.Mutation.DeleteAllTaskCategories == nil {
			break
		}

		return e.complexity.Mutation.DeleteAllTaskCategories(childComplexity), true

	case "Mutation.deleteAllTasks":
		if e.complexity.Mutation.DeleteAllTasks == nil {
			break
		}

		return e.complexity.Mutation.DeleteAllTasks(childComplexity), true

	case "Mutation.deleteAllUsers":
		if e.complexity.Mutation.DeleteAllUsers == nil {
			break
		}

		return e.complexity.Mutation.DeleteAllUsers(childComplexity), true

	case "Mutation.deleteCompany":
		if e.complexity.Mutation.DeleteCompany == nil {
			break
		}

		args, err := ec.field_Mutation_deleteCompany_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeleteCompany(childComplexity, args["id"].(string)), true

	case "Mutation.deletePlainEntity":
		if e.complexity.Mutation.DeletePlainEntity == nil {
			break
		}

		args, err := ec.field_Mutation_deletePlainEntity_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeletePlainEntity(childComplexity, args["id"].(string)), true

	case "Mutation.deleteTask":
		if e.complexity.Mutation.DeleteTask == nil {
			break
		}

		args, err := ec.field_Mutation_deleteTask_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeleteTask(childComplexity, args["id"].(string)), true

	case "Mutation.deleteTaskCategory":
		if e.complexity.Mutation.DeleteTaskCategory == nil {
			break
		}

		args, err := ec.field_Mutation_deleteTaskCategory_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeleteTaskCategory(childComplexity, args["id"].(string)), true

	case "Mutation.deleteUser":
		if e.complexity.Mutation.DeleteUser == nil {
			break
		}

		args, err := ec.field_Mutation_deleteUser_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.DeleteUser(childComplexity, args["id"].(string)), true

	case "Mutation.updateCompany":
		if e.complexity.Mutation.UpdateCompany == nil {
			break
		}

		args, err := ec.field_Mutation_updateCompany_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdateCompany(childComplexity, args["id"].(string), args["input"].(map[string]interface{})), true

	case "Mutation.updatePlainEntity":
		if e.complexity.Mutation.UpdatePlainEntity == nil {
			break
		}

		args, err := ec.field_Mutation_updatePlainEntity_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdatePlainEntity(childComplexity, args["id"].(string), args["input"].(map[string]interface{})), true

	case "Mutation.updateTask":
		if e.complexity.Mutation.UpdateTask == nil {
			break
		}

		args, err := ec.field_Mutation_updateTask_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdateTask(childComplexity, args["id"].(string), args["input"].(map[string]interface{})), true

	case "Mutation.updateTaskCategory":
		if e.complexity.Mutation.UpdateTaskCategory == nil {
			break
		}

		args, err := ec.field_Mutation_updateTaskCategory_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdateTaskCategory(childComplexity, args["id"].(string), args["input"].(map[string]interface{})), true

	case "Mutation.updateUser":
		if e.complexity.Mutation.UpdateUser == nil {
			break
		}

		args, err := ec.field_Mutation_updateUser_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Mutation.UpdateUser(childComplexity, args["id"].(string), args["input"].(map[string]interface{})), true

	case "PlainEntity.createdAt":
		if e.complexity.PlainEntity.CreatedAt == nil {
			break
		}

		return e.complexity.PlainEntity.CreatedAt(childComplexity), true

	case "PlainEntity.createdBy":
		if e.complexity.PlainEntity.CreatedBy == nil {
			break
		}

		return e.complexity.PlainEntity.CreatedBy(childComplexity), true

	case "PlainEntity.date":
		if e.complexity.PlainEntity.Date == nil {
			break
		}

		return e.complexity.PlainEntity.Date(childComplexity), true

	case "PlainEntity.id":
		if e.complexity.PlainEntity.ID == nil {
			break
		}

		return e.complexity.PlainEntity.ID(childComplexity), true

	case "PlainEntity.shortText":
		if e.complexity.PlainEntity.ShortText == nil {
			break
		}

		return e.complexity.PlainEntity.ShortText(childComplexity), true

	case "PlainEntity.text":
		if e.complexity.PlainEntity.Text == nil {
			break
		}

		return e.complexity.PlainEntity.Text(childComplexity), true

	case "PlainEntity.updatedAt":
		if e.complexity.PlainEntity.UpdatedAt == nil {
			break
		}

		return e.complexity.PlainEntity.UpdatedAt(childComplexity), true

	case "PlainEntity.updatedBy":
		if e.complexity.PlainEntity.UpdatedBy == nil {
			break
		}

		return e.complexity.PlainEntity.UpdatedBy(childComplexity), true

	case "PlainEntityResultType.count":
		if e.complexity.PlainEntityResultType.Count == nil {
			break
		}

		return e.complexity.PlainEntityResultType.Count(childComplexity), true

	case "PlainEntityResultType.items":
		if e.complexity.PlainEntityResultType.Items == nil {
			break
		}

		return e.complexity.PlainEntityResultType.Items(childComplexity), true

	case "Query.companies":
		if e.complexity.Query.Companies == nil {
			break
		}

		args, err := ec.field_Query_companies_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Companies(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*CompanySortType), args["filter"].(*CompanyFilterType)), true

	case "Query.company":
		if e.complexity.Query.Company == nil {
			break
		}

		args, err := ec.field_Query_company_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Company(childComplexity, args["id"].(*string), args["q"].(*string), args["filter"].(*CompanyFilterType)), true

	case "Query.hello":
		if e.complexity.Query.Hello == nil {
			break
		}

		return e.complexity.Query.Hello(childComplexity), true

	case "Query.plainEntities":
		if e.complexity.Query.PlainEntities == nil {
			break
		}

		args, err := ec.field_Query_plainEntities_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.PlainEntities(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*PlainEntitySortType), args["filter"].(*PlainEntityFilterType)), true

	case "Query.plainEntity":
		if e.complexity.Query.PlainEntity == nil {
			break
		}

		args, err := ec.field_Query_plainEntity_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.PlainEntity(childComplexity, args["id"].(*string), args["q"].(*string), args["filter"].(*PlainEntityFilterType)), true

	case "Query.task":
		if e.complexity.Query.Task == nil {
			break
		}

		args, err := ec.field_Query_task_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Task(childComplexity, args["id"].(*string), args["q"].(*string), args["filter"].(*TaskFilterType)), true

	case "Query.taskCategories":
		if e.complexity.Query.TaskCategories == nil {
			break
		}

		args, err := ec.field_Query_taskCategories_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.TaskCategories(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskCategorySortType), args["filter"].(*TaskCategoryFilterType)), true

	case "Query.taskCategory":
		if e.complexity.Query.TaskCategory == nil {
			break
		}

		args, err := ec.field_Query_taskCategory_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.TaskCategory(childComplexity, args["id"].(*string), args["q"].(*string), args["filter"].(*TaskCategoryFilterType)), true

	case "Query.tasks":
		if e.complexity.Query.Tasks == nil {
			break
		}

		args, err := ec.field_Query_tasks_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Tasks(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskSortType), args["filter"].(*TaskFilterType)), true

	case "Query.topCompanies":
		if e.complexity.Query.TopCompanies == nil {
			break
		}

		return e.complexity.Query.TopCompanies(childComplexity), true

	case "Query.user":
		if e.complexity.Query.User == nil {
			break
		}

		args, err := ec.field_Query_user_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.User(childComplexity, args["id"].(*string), args["q"].(*string), args["filter"].(*UserFilterType)), true

	case "Query.users":
		if e.complexity.Query.Users == nil {
			break
		}

		args, err := ec.field_Query_users_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Users(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*UserSortType), args["filter"].(*UserFilterType)), true

	case "Query._service":
		if e.complexity.Query.__resolve__service == nil {
			break
		}

		return e.complexity.Query.__resolve__service(childComplexity), true

	case "Review.company":
		if e.complexity.Review.Company == nil {
			break
		}

		return e.complexity.Review.Company(childComplexity), true

	case "Review.id":
		if e.complexity.Review.ID == nil {
			break
		}

		return e.complexity.Review.ID(childComplexity), true

	case "Review.referenceID":
		if e.complexity.Review.ReferenceID == nil {
			break
		}

		return e.complexity.Review.ReferenceID(childComplexity), true

	case "Task.assignee":
		if e.complexity.Task.Assignee == nil {
			break
		}

		return e.complexity.Task.Assignee(childComplexity), true

	case "Task.assigneeId":
		if e.complexity.Task.AssigneeID == nil {
			break
		}

		return e.complexity.Task.AssigneeID(childComplexity), true

	case "Task.categories":
		if e.complexity.Task.Categories == nil {
			break
		}

		return e.complexity.Task.Categories(childComplexity), true

	case "Task.categoriesConnection":
		if e.complexity.Task.CategoriesConnection == nil {
			break
		}

		args, err := ec.field_Task_categoriesConnection_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Task.CategoriesConnection(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskCategorySortType), args["filter"].(*TaskCategoryFilterType)), true

	case "Task.categoriesIds":
		if e.complexity.Task.CategoriesIds == nil {
			break
		}

		return e.complexity.Task.CategoriesIds(childComplexity), true

	case "Task.completed":
		if e.complexity.Task.Completed == nil {
			break
		}

		return e.complexity.Task.Completed(childComplexity), true

	case "Task.createdAt":
		if e.complexity.Task.CreatedAt == nil {
			break
		}

		return e.complexity.Task.CreatedAt(childComplexity), true

	case "Task.createdBy":
		if e.complexity.Task.CreatedBy == nil {
			break
		}

		return e.complexity.Task.CreatedBy(childComplexity), true

	case "Task.dueDate":
		if e.complexity.Task.DueDate == nil {
			break
		}

		return e.complexity.Task.DueDate(childComplexity), true

	case "Task.id":
		if e.complexity.Task.ID == nil {
			break
		}

		return e.complexity.Task.ID(childComplexity), true

	case "Task.meta":
		if e.complexity.Task.Meta == nil {
			break
		}

		return e.complexity.Task.Meta(childComplexity), true

	case "Task.metas":
		if e.complexity.Task.Metas == nil {
			break
		}

		return e.complexity.Task.Metas(childComplexity), true

	case "Task.owner":
		if e.complexity.Task.Owner == nil {
			break
		}

		return e.complexity.Task.Owner(childComplexity), true

	case "Task.ownerId":
		if e.complexity.Task.OwnerID == nil {
			break
		}

		return e.complexity.Task.OwnerID(childComplexity), true

	case "Task.parentTask":
		if e.complexity.Task.ParentTask == nil {
			break
		}

		return e.complexity.Task.ParentTask(childComplexity), true

	case "Task.parentTaskId":
		if e.complexity.Task.ParentTaskID == nil {
			break
		}

		return e.complexity.Task.ParentTaskID(childComplexity), true

	case "Task.state":
		if e.complexity.Task.State == nil {
			break
		}

		return e.complexity.Task.State(childComplexity), true

	case "Task.subtasks":
		if e.complexity.Task.Subtasks == nil {
			break
		}

		return e.complexity.Task.Subtasks(childComplexity), true

	case "Task.subtasksConnection":
		if e.complexity.Task.SubtasksConnection == nil {
			break
		}

		args, err := ec.field_Task_subtasksConnection_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Task.SubtasksConnection(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskSortType), args["filter"].(*TaskFilterType)), true

	case "Task.subtasksIds":
		if e.complexity.Task.SubtasksIds == nil {
			break
		}

		return e.complexity.Task.SubtasksIds(childComplexity), true

	case "Task.title":
		if e.complexity.Task.Title == nil {
			break
		}

		return e.complexity.Task.Title(childComplexity), true

	case "Task.updatedAt":
		if e.complexity.Task.UpdatedAt == nil {
			break
		}

		return e.complexity.Task.UpdatedAt(childComplexity), true

	case "Task.updatedBy":
		if e.complexity.Task.UpdatedBy == nil {
			break
		}

		return e.complexity.Task.UpdatedBy(childComplexity), true

	case "TaskCategory.createdAt":
		if e.complexity.TaskCategory.CreatedAt == nil {
			break
		}

		return e.complexity.TaskCategory.CreatedAt(childComplexity), true

	case "TaskCategory.createdBy":
		if e.complexity.TaskCategory.CreatedBy == nil {
			break
		}

		return e.complexity.TaskCategory.CreatedBy(childComplexity), true

	case "TaskCategory.id":
		if e.complexity.TaskCategory.ID == nil {
			break
		}

		return e.complexity.TaskCategory.ID(childComplexity), true

	case "TaskCategory.name":
		if e.complexity.TaskCategory.Name == nil {
			break
		}

		return e.complexity.TaskCategory.Name(childComplexity), true

	case "TaskCategory.tasks":
		if e.complexity.TaskCategory.Tasks == nil {
			break
		}

		return e.complexity.TaskCategory.Tasks(childComplexity), true

	case "TaskCategory.tasksConnection":
		if e.complexity.TaskCategory.TasksConnection == nil {
			break
		}

		args, err := ec.field_TaskCategory_tasksConnection_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.TaskCategory.TasksConnection(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskSortType), args["filter"].(*TaskFilterType)), true

	case "TaskCategory.tasksIds":
		if e.complexity.TaskCategory.TasksIds == nil {
			break
		}

		return e.complexity.TaskCategory.TasksIds(childComplexity), true

	case "TaskCategory.updatedAt":
		if e.complexity.TaskCategory.UpdatedAt == nil {
			break
		}

		return e.complexity.TaskCategory.UpdatedAt(childComplexity), true

	case "TaskCategory.updatedBy":
		if e.complexity.TaskCategory.UpdatedBy == nil {
			break
		}

		return e.complexity.TaskCategory.UpdatedBy(childComplexity), true

	case "TaskCategoryResultType.count":
		if e.complexity.TaskCategoryResultType.Count == nil {
			break
		}

		return e.complexity.TaskCategoryResultType.Count(childComplexity), true

	case "TaskCategoryResultType.items":
		if e.complexity.TaskCategoryResultType.Items == nil {
			break
		}

		return e.complexity.TaskCategoryResultType.Items(childComplexity), true

	case "TaskMeta.key":
		if e.complexity.TaskMeta.Key == nil {
			break
		}

		return e.complexity.TaskMeta.Key(childComplexity), true

	case "TaskMeta.value":
		if e.complexity.TaskMeta.Value == nil {
			break
		}

		return e.complexity.TaskMeta.Value(childComplexity), true

	case "TaskResultType.count":
		if e.complexity.TaskResultType.Count == nil {
			break
		}

		return e.complexity.TaskResultType.Count(childComplexity), true

	case "TaskResultType.items":
		if e.complexity.TaskResultType.Items == nil {
			break
		}

		return e.complexity.TaskResultType.Items(childComplexity), true

	case "User.address":
		if e.complexity.User.Address == nil {
			break
		}

		return e.complexity.User.Address(childComplexity), true

	case "User.addressRaw":
		if e.complexity.User.AddressRaw == nil {
			break
		}

		return e.complexity.User.AddressRaw(childComplexity), true

	case "User.code":
		if e.complexity.User.Code == nil {
			break
		}

		return e.complexity.User.Code(childComplexity), true

	case "User.createdAt":
		if e.complexity.User.CreatedAt == nil {
			break
		}

		return e.complexity.User.CreatedAt(childComplexity), true

	case "User.createdBy":
		if e.complexity.User.CreatedBy == nil {
			break
		}

		return e.complexity.User.CreatedBy(childComplexity), true

	case "User.createdTasks":
		if e.complexity.User.CreatedTasks == nil {
			break
		}

		return e.complexity.User.CreatedTasks(childComplexity), true

	case "User.createdTasksConnection":
		if e.complexity.User.CreatedTasksConnection == nil {
			break
		}

		args, err := ec.field_User_createdTasksConnection_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.User.CreatedTasksConnection(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskSortType), args["filter"].(*TaskFilterType)), true

	case "User.createdTasksIds":
		if e.complexity.User.CreatedTasksIds == nil {
			break
		}

		return e.complexity.User.CreatedTasksIds(childComplexity), true

	case "User.email":
		if e.complexity.User.Email == nil {
			break
		}

		return e.complexity.User.Email(childComplexity), true

	case "User.employers":
		if e.complexity.User.Employers == nil {
			break
		}

		return e.complexity.User.Employers(childComplexity), true

	case "User.employersConnection":
		if e.complexity.User.EmployersConnection == nil {
			break
		}

		args, err := ec.field_User_employersConnection_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.User.EmployersConnection(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*CompanySortType), args["filter"].(*CompanyFilterType)), true

	case "User.employersIds":
		if e.complexity.User.EmployersIds == nil {
			break
		}

		return e.complexity.User.EmployersIds(childComplexity), true

	case "User.firstName":
		if e.complexity.User.FirstName == nil {
			break
		}

		return e.complexity.User.FirstName(childComplexity), true

	case "User.id":
		if e.complexity.User.ID == nil {
			break
		}

		return e.complexity.User.ID(childComplexity), true

	case "User.lastName":
		if e.complexity.User.LastName == nil {
			break
		}

		return e.complexity.User.LastName(childComplexity), true

	case "User.salary":
		if e.complexity.User.Salary == nil {
			break
		}

		return e.complexity.User.Salary(childComplexity), true

	case "User.tasks":
		if e.complexity.User.Tasks == nil {
			break
		}

		return e.complexity.User.Tasks(childComplexity), true

	case "User.tasksConnection":
		if e.complexity.User.TasksConnection == nil {
			break
		}

		args, err := ec.field_User_tasksConnection_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.User.TasksConnection(childComplexity, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskSortType), args["filter"].(*TaskFilterType)), true

	case "User.tasksIds":
		if e.complexity.User.TasksIds == nil {
			break
		}

		return e.complexity.User.TasksIds(childComplexity), true

	case "User.updatedAt":
		if e.complexity.User.UpdatedAt == nil {
			break
		}

		return e.complexity.User.UpdatedAt(childComplexity), true

	case "User.updatedBy":
		if e.complexity.User.UpdatedBy == nil {
			break
		}

		return e.complexity.User.UpdatedBy(childComplexity), true

	case "UserResultType.count":
		if e.complexity.UserResultType.Count == nil {
			break
		}

		return e.complexity.UserResultType.Count(childComplexity), true

	case "UserResultType.items":
		if e.complexity.UserResultType.Items == nil {
			break
		}

		return e.complexity.UserResultType.Items(childComplexity), true

	case "_Service.sdl":
		if e.complexity.Service.SDL == nil {
			break
		}

		return e.complexity.Service.SDL(childComplexity), true

	}
	return 0, false
}

func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
	rc := graphql.GetOperationContext(ctx)
	ec := executionContext{rc, e}
	first := true

	switch rc.Operation.Operation {
	case ast.Query:
		return func(ctx context.Context) *graphql.Response {
			if !first {
				return nil
			}
			first = false
			data := ec._Query(ctx, rc.Operation.SelectionSet)
			var buf bytes.Buffer
			data.MarshalGQL(&buf)

			return &graphql.Response{
				Data: buf.Bytes(),
			}
		}
	case ast.Mutation:
		return func(ctx context.Context) *graphql.Response {
			if !first {
				return nil
			}
			first = false
			data := ec._Mutation(ctx, rc.Operation.SelectionSet)
			var buf bytes.Buffer
			data.MarshalGQL(&buf)

			return &graphql.Response{
				Data: buf.Bytes(),
			}
		}

	default:
		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
	}
}

type executionContext struct {
	*graphql.OperationContext
	*executableSchema
}

func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapSchema(parsedSchema), nil
}

func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
}

var sources = []*ast.Source{
	{Name: "schema.graphql", Input: `# This schema is generated, please don't update it manually

scalar Time

schema {
  query: Query
  mutation: Mutation
}

type Query {
  _service: _Service!
  task(id: ID, q: String, filter: TaskFilterType): Task
  tasks(offset: Int, limit: Int = 30, q: String, sort: [TaskSortType!], filter: TaskFilterType): TaskResultType!
  taskCategory(id: ID, q: String, filter: TaskCategoryFilterType): TaskCategory
  taskCategories(offset: Int, limit: Int = 30, q: String, sort: [TaskCategorySortType!], filter: TaskCategoryFilterType): TaskCategoryResultType!
  company(id: ID, q: String, filter: CompanyFilterType): Company
  companies(offset: Int, limit: Int = 30, q: String, sort: [CompanySortType!], filter: CompanyFilterType): CompanyResultType!
  user(id: ID, q: String, filter: UserFilterType): User
  users(offset: Int, limit: Int = 30, q: String, sort: [UserSortType!], filter: UserFilterType): UserResultType!
  plainEntity(id: ID, q: String, filter: PlainEntityFilterType): PlainEntity
  plainEntities(offset: Int, limit: Int = 30, q: String, sort: [PlainEntitySortType!], filter: PlainEntityFilterType): PlainEntityResultType!
}

type Mutation {
  createTask(input: TaskCreateInput!): Task!
  updateTask(id: ID!, input: TaskUpdateInput!): Task!
  deleteTask(id: ID!): Task!
  deleteAllTasks: Boolean!
  createTaskCategory(input: TaskCategoryCreateInput!): TaskCategory!
  updateTaskCategory(id: ID!, input: TaskCategoryUpdateInput!): TaskCategory!
  deleteTaskCategory(id: ID!): TaskCategory!
  deleteAllTaskCategories: Boolean!
  createCompany(input: CompanyCreateInput!): Company!
  updateCompany(id: ID!, input: CompanyUpdateInput!): Company!
  deleteCompany(id: ID!): Company!
  deleteAllCompanies: Boolean!
  createUser(input: UserCreateInput!): User!
  updateUser(id: ID!, input: UserUpdateInput!): User!
  deleteUser(id: ID!): User!
  deleteAllUsers: Boolean!
  createPlainEntity(input: PlainEntityCreateInput!): PlainEntity!
  updatePlainEntity(id: ID!, input: PlainEntityUpdateInput!): PlainEntity!
  deletePlainEntity(id: ID!): PlainEntity!
  deleteAllPlainEntities: Boolean!
}

enum ObjectSortType {
  ASC
  DESC
}

enum TaskState {
  CREATED
  IN_PROGRESS
  RESOLVED
}

type TaskMeta {
  key: String!
  value: String
}

type Task {
  id: ID!
  title: String
  completed: Boolean
  state: TaskState
  dueDate: Time
  metas: [TaskMeta!]
  meta: TaskMeta
  assignee: User
  owner: User!
  parentTask: Task
  subtasks: [Task!]!
  categories: [TaskCategory!]!
  assigneeId: ID
  ownerId: ID
  parentTaskId: ID
  updatedAt: Time
  createdAt: Time!
  updatedBy: ID
  createdBy: ID
  subtasksIds: [ID!]!
  subtasksConnection(offset: Int, limit: Int = 30, q: String, sort: [TaskSortType!], filter: TaskFilterType): TaskResultType!
  categoriesIds: [ID!]!
  categoriesConnection(offset: Int, limit: Int = 30, q: String, sort: [TaskCategorySortType!], filter: TaskCategoryFilterType): TaskCategoryResultType!
}

type TaskCategory {
  id: ID!
  name: String
  tasks: [Task!]!
  updatedAt: Time
  createdAt: Time!
  updatedBy: ID
  createdBy: ID
  tasksIds: [ID!]!
  tasksConnection(offset: Int, limit: Int = 30, q: String, sort: [TaskSortType!], filter: TaskFilterType): TaskResultType!
}

extend type Query {
  hello: String!
  topCompanies: [Company!]!
}

interface NamedEntity {
  name: String
}

type Company implements NamedEntity {
  id: ID!
  name: String
  countryId: ID
  country: Country
  employees: [User!]!
  reviews: [Review!]!
  updatedAt: Time
  createdAt: Time!
  updatedBy: ID
  createdBy: ID
  employeesIds: [ID!]!
  employeesConnection(offset: Int, limit: Int = 30, q: String, sort: [UserSortType!], filter: UserFilterType): UserResultType!
}

extend type Company {
  uppercaseName: String!
}

type Address {
  street: String
  city: String
  zip: String
}

type User {
  id: ID!
  code: Int
  email: String
  firstName: String
  lastName: String
  addressRaw: String
  address: Address
  salary: Int
  employers: [Company!]!
  tasks: [Task!]!
  createdTasks: [Task!]!
  updatedAt: Time
  createdAt: Time!
  updatedBy: ID
  createdBy: ID
  employersIds: [ID!]!
  employersConnection(offset: Int, limit: Int = 30, q: String, sort: [CompanySortType!], filter: CompanyFilterType): CompanyResultType!
  tasksIds: [ID!]!
  tasksConnection(offset: Int, limit: Int = 30, q: String, sort: [TaskSortType!], filter: TaskFilterType): TaskResultType!
  createdTasksIds: [ID!]!
  createdTasksConnection(offset: Int, limit: Int = 30, q: String, sort: [TaskSortType!], filter: TaskFilterType): TaskResultType!
}

type PlainEntity {
  id: ID!
  date: Time
  text: String
  shortText: String!
  updatedAt: Time
  createdAt: Time!
  updatedBy: ID
  createdBy: ID
}

input TaskCreateInput {
  id: ID
  title: String
  completed: Boolean
  state: TaskState
  dueDate: Time
  metas: [TaskMetaInput]
  meta: TaskMetaInput
  assigneeId: ID
  ownerId: ID
  parentTaskId: ID
  subtasksIds: [ID!]
  categoriesIds: [ID!]
}

input TaskUpdateInput {
  title: String
  completed: Boolean
  state: TaskState
  dueDate: Time
  metas: [TaskMetaInput]
  meta: TaskMetaInput
  assigneeId: ID
  ownerId: ID
  parentTaskId: ID
  subtasksIds: [ID!]
  categoriesIds: [ID!]
}

input TaskSortType {
  id: ObjectSortType
  idMin: ObjectSortType
  idMax: ObjectSortType
  title: ObjectSortType
  titleMin: ObjectSortType
  titleMax: ObjectSortType
  completed: ObjectSortType
  completedMin: ObjectSortType
  completedMax: ObjectSortType
  state: ObjectSortType
  stateMin: ObjectSortType
  stateMax: ObjectSortType
  dueDate: ObjectSortType
  dueDateMin: ObjectSortType
  dueDateMax: ObjectSortType
  metas: ObjectSortType
  metasMin: ObjectSortType
  metasMax: ObjectSortType
  meta: ObjectSortType
  metaMin: ObjectSortType
  metaMax: ObjectSortType
  assigneeId: ObjectSortType
  assigneeIdMin: ObjectSortType
  assigneeIdMax: ObjectSortType
  ownerId: ObjectSortType
  ownerIdMin: ObjectSortType
  ownerIdMax: ObjectSortType
  parentTaskId: ObjectSortType
  parentTaskIdMin: ObjectSortType
  parentTaskIdMax: ObjectSortType
  updatedAt: ObjectSortType
  updatedAtMin: ObjectSortType
  updatedAtMax: ObjectSortType
  createdAt: ObjectSortType
  createdAtMin: ObjectSortType
  createdAtMax: ObjectSortType
  updatedBy: ObjectSortType
  updatedByMin: ObjectSortType
  updatedByMax: ObjectSortType
  createdBy: ObjectSortType
  createdByMin: ObjectSortType
  createdByMax: ObjectSortType
  subtasksIds: ObjectSortType
  subtasksIdsMin: ObjectSortType
  subtasksIdsMax: ObjectSortType
  categoriesIds: ObjectSortType
  categoriesIdsMin: ObjectSortType
  categoriesIdsMax: ObjectSortType
  assignee: UserSortType
  owner: UserSortType
  parentTask: TaskSortType
  subtasks: TaskSortType
  categories: TaskCategorySortType
}

input TaskFilterType {
  AND: [TaskFilterType!]
  OR: [TaskFilterType!]
  id: ID
  idMin: ID
  idMax: ID
  id_ne: ID
  idMin_ne: ID
  idMax_ne: ID
  id_gt: ID
  idMin_gt: ID
  idMax_gt: ID
  id_lt: ID
  idMin_lt: ID
  idMax_lt: ID
  id_gte: ID
  idMin_gte: ID
  idMax_gte: ID
  id_lte: ID
  idMin_lte: ID
  idMax_lte: ID
  id_in: [ID!]
  idMin_in: [ID!]
  idMax_in: [ID!]
  id_null: Boolean
  title: String
  titleMin: String
  titleMax: String
  title_ne: String
  titleMin_ne: String
  titleMax_ne: String
  title_gt: String
  titleMin_gt: String
  titleMax_gt: String
  title_lt: String
  titleMin_lt: String
  titleMax_lt: String
  title_gte: String
  titleMin_gte: String
  titleMax_gte: String
  title_lte: String
  titleMin_lte: String
  titleMax_lte: String
  title_in: [String!]
  titleMin_in: [String!]
  titleMax_in: [String!]
  title_like: String
  titleMin_like: String
  titleMax_like: String
  title_prefix: String
  titleMin_prefix: String
  titleMax_prefix: String
  title_suffix: String
  titleMin_suffix: String
  titleMax_suffix: String
  title_null: Boolean
  completed: Boolean
  completedMin: Boolean
  completedMax: Boolean
  completed_ne: Boolean
  completedMin_ne: Boolean
  completedMax_ne: Boolean
  completed_gt: Boolean
  completedMin_gt: Boolean
  completedMax_gt: Boolean
  completed_lt: Boolean
  completedMin_lt: Boolean
  completedMax_lt: Boolean
  completed_gte: Boolean
  completedMin_gte: Boolean
  completedMax_gte: Boolean
  completed_lte: Boolean
  completedMin_lte: Boolean
  completedMax_lte: Boolean
  completed_in: [Boolean!]
  completedMin_in: [Boolean!]
  completedMax_in: [Boolean!]
  completed_null: Boolean
  state: TaskState
  stateMin: TaskState
  stateMax: TaskState
  state_ne: TaskState
  stateMin_ne: TaskState
  stateMax_ne: TaskState
  state_gt: TaskState
  stateMin_gt: TaskState
  stateMax_gt: TaskState
  state_lt: TaskState
  stateMin_lt: TaskState
  stateMax_lt: TaskState
  state_gte: TaskState
  stateMin_gte: TaskState
  stateMax_gte: TaskState
  state_lte: TaskState
  stateMin_lte: TaskState
  stateMax_lte: TaskState
  state_in: [TaskState!]
  stateMin_in: [TaskState!]
  stateMax_in: [TaskState!]
  state_null: Boolean
  dueDate: Time
  dueDateMin: Time
  dueDateMax: Time
  dueDate_ne: Time
  dueDateMin_ne: Time
  dueDateMax_ne: Time
  dueDate_gt: Time
  dueDateMin_gt: Time
  dueDateMax_gt: Time
  dueDate_lt: Time
  dueDateMin_lt: Time
  dueDateMax_lt: Time
  dueDate_gte: Time
  dueDateMin_gte: Time
  dueDateMax_gte: Time
  dueDate_lte: Time
  dueDateMin_lte: Time
  dueDateMax_lte: Time
  dueDate_in: [Time!]
  dueDateMin_in: [Time!]
  dueDateMax_in: [Time!]
  dueDate_null: Boolean
  assigneeId: ID
  assigneeIdMin: ID
  assigneeIdMax: ID
  assigneeId_ne: ID
  assigneeIdMin_ne: ID
  assigneeIdMax_ne: ID
  assigneeId_gt: ID
  assigneeIdMin_gt: ID
  assigneeIdMax_gt: ID
  assigneeId_lt: ID
  assigneeIdMin_lt: ID
  assigneeIdMax_lt: ID
  assigneeId_gte: ID
  assigneeIdMin_gte: ID
  assigneeIdMax_gte: ID
  assigneeId_lte: ID
  assigneeIdMin_lte: ID
  assigneeIdMax_lte: ID
  assigneeId_in: [ID!]
  assigneeIdMin_in: [ID!]
  assigneeIdMax_in: [ID!]
  assigneeId_null: Boolean
  ownerId: ID
  ownerIdMin: ID
  ownerIdMax: ID
  ownerId_ne: ID
  ownerIdMin_ne: ID
  ownerIdMax_ne: ID
  ownerId_gt: ID
  ownerIdMin_gt: ID
  ownerIdMax_gt: ID
  ownerId_lt: ID
  ownerIdMin_lt: ID
  ownerIdMax_lt: ID
  ownerId_gte: ID
  ownerIdMin_gte: ID
  ownerIdMax_gte: ID
  ownerId_lte: ID
  ownerIdMin_lte: ID
  ownerIdMax_lte: ID
  ownerId_in: [ID!]
  ownerIdMin_in: [ID!]
  ownerIdMax_in: [ID!]
  ownerId_null: Boolean
  parentTaskId: ID
  parentTaskIdMin: ID
  parentTaskIdMax: ID
  parentTaskId_ne: ID
  parentTaskIdMin_ne: ID
  parentTaskIdMax_ne: ID
  parentTaskId_gt: ID
  parentTaskIdMin_gt: ID
  parentTaskIdMax_gt: ID
  parentTaskId_lt: ID
  parentTaskIdMin_lt: ID
  parentTaskIdMax_lt: ID
  parentTaskId_gte: ID
  parentTaskIdMin_gte: ID
  parentTaskIdMax_gte: ID
  parentTaskId_lte: ID
  parentTaskIdMin_lte: ID
  parentTaskIdMax_lte: ID
  parentTaskId_in: [ID!]
  parentTaskIdMin_in: [ID!]
  parentTaskIdMax_in: [ID!]
  parentTaskId_null: Boolean
  updatedAt: Time
  updatedAtMin: Time
  updatedAtMax: Time
  updatedAt_ne: Time
  updatedAtMin_ne: Time
  updatedAtMax_ne: Time
  updatedAt_gt: Time
  updatedAtMin_gt: Time
  updatedAtMax_gt: Time
  updatedAt_lt: Time
  updatedAtMin_lt: Time
  updatedAtMax_lt: Time
  updatedAt_gte: Time
  updatedAtMin_gte: Time
  updatedAtMax_gte: Time
  updatedAt_lte: Time
  updatedAtMin_lte: Time
  updatedAtMax_lte: Time
  updatedAt_in: [Time!]
  updatedAtMin_in: [Time!]
  updatedAtMax_in: [Time!]
  updatedAt_null: Boolean
  createdAt: Time
  createdAtMin: Time
  createdAtMax: Time
  createdAt_ne: Time
  createdAtMin_ne: Time
  createdAtMax_ne: Time
  createdAt_gt: Time
  createdAtMin_gt: Time
  createdAtMax_gt: Time
  createdAt_lt: Time
  createdAtMin_lt: Time
  createdAtMax_lt: Time
  createdAt_gte: Time
  createdAtMin_gte: Time
  createdAtMax_gte: Time
  createdAt_lte: Time
  createdAtMin_lte: Time
  createdAtMax_lte: Time
  createdAt_in: [Time!]
  createdAtMin_in: [Time!]
  createdAtMax_in: [Time!]
  createdAt_null: Boolean
  updatedBy: ID
  updatedByMin: ID
  updatedByMax: ID
  updatedBy_ne: ID
  updatedByMin_ne: ID
  updatedByMax_ne: ID
  updatedBy_gt: ID
  updatedByMin_gt: ID
  updatedByMax_gt: ID
  updatedBy_lt: ID
  updatedByMin_lt: ID
  updatedByMax_lt: ID
  updatedBy_gte: ID
  updatedByMin_gte: ID
  updatedByMax_gte: ID
  updatedBy_lte: ID
  updatedByMin_lte: ID
  updatedByMax_lte: ID
  updatedBy_in: [ID!]
  updatedByMin_in: [ID!]
  updatedByMax_in: [ID!]
  updatedBy_null: Boolean
  createdBy: ID
  createdByMin: ID
  createdByMax: ID
  createdBy_ne: ID
  createdByMin_ne: ID
  createdByMax_ne: ID
  createdBy_gt: ID
  createdByMin_gt: ID
  createdByMax_gt: ID
  createdBy_lt: ID
  createdByMin_lt: ID
  createdByMax_lt: ID
  createdBy_gte: ID
  createdByMin_gte: ID
  createdByMax_gte: ID
  createdBy_lte: ID
  createdByMin_lte: ID
  createdByMax_lte: ID
  createdBy_in: [ID!]
  createdByMin_in: [ID!]
  createdByMax_in: [ID!]
  createdBy_null: Boolean
  assignee: UserFilterType
  owner: UserFilterType
  parentTask: TaskFilterType
  subtasks: TaskFilterType
  categories: TaskCategoryFilterType
}

type TaskResultType {
  items: [Task!]!
  count: Int!
}

input TaskCategoryCreateInput {
  id: ID
  name: String
  tasksIds: [ID!]
}

input TaskCategoryUpdateInput {
  name: String
  tasksIds: [ID!]
}

input TaskCategorySortType {
  id: ObjectSortType
  idMin: ObjectSortType
  idMax: ObjectSortType
  name: ObjectSortType
  nameMin: ObjectSortType
  nameMax: ObjectSortType
  updatedAt: ObjectSortType
  updatedAtMin: ObjectSortType
  updatedAtMax: ObjectSortType
  createdAt: ObjectSortType
  createdAtMin: ObjectSortType
  createdAtMax: ObjectSortType
  updatedBy: ObjectSortType
  updatedByMin: ObjectSortType
  updatedByMax: ObjectSortType
  createdBy: ObjectSortType
  createdByMin: ObjectSortType
  createdByMax: ObjectSortType
  tasksIds: ObjectSortType
  tasksIdsMin: ObjectSortType
  tasksIdsMax: ObjectSortType
  tasks: TaskSortType
}

input TaskCategoryFilterType {
  AND: [TaskCategoryFilterType!]
  OR: [TaskCategoryFilterType!]
  id: ID
  idMin: ID
  idMax: ID
  id_ne: ID
  idMin_ne: ID
  idMax_ne: ID
  id_gt: ID
  idMin_gt: ID
  idMax_gt: ID
  id_lt: ID
  idMin_lt: ID
  idMax_lt: ID
  id_gte: ID
  idMin_gte: ID
  idMax_gte: ID
  id_lte: ID
  idMin_lte: ID
  idMax_lte: ID
  id_in: [ID!]
  idMin_in: [ID!]
  idMax_in: [ID!]
  id_null: Boolean
  name: String
  nameMin: String
  nameMax: String
  name_ne: String
  nameMin_ne: String
  nameMax_ne: String
  name_gt: String
  nameMin_gt: String
  nameMax_gt: String
  name_lt: String
  nameMin_lt: String
  nameMax_lt: String
  name_gte: String
  nameMin_gte: String
  nameMax_gte: String
  name_lte: String
  nameMin_lte: String
  nameMax_lte: String
  name_in: [String!]
  nameMin_in: [String!]
  nameMax_in: [String!]
  name_like: String
  nameMin_like: String
  nameMax_like: String
  name_prefix: String
  nameMin_prefix: String
  nameMax_prefix: String
  name_suffix: String
  nameMin_suffix: String
  nameMax_suffix: String
  name_null: Boolean
  updatedAt: Time
  updatedAtMin: Time
  updatedAtMax: Time
  updatedAt_ne: Time
  updatedAtMin_ne: Time
  updatedAtMax_ne: Time
  updatedAt_gt: Time
  updatedAtMin_gt: Time
  updatedAtMax_gt: Time
  updatedAt_lt: Time
  updatedAtMin_lt: Time
  updatedAtMax_lt: Time
  updatedAt_gte: Time
  updatedAtMin_gte: Time
  updatedAtMax_gte: Time
  updatedAt_lte: Time
  updatedAtMin_lte: Time
  updatedAtMax_lte: Time
  updatedAt_in: [Time!]
  updatedAtMin_in: [Time!]
  updatedAtMax_in: [Time!]
  updatedAt_null: Boolean
  createdAt: Time
  createdAtMin: Time
  createdAtMax: Time
  createdAt_ne: Time
  createdAtMin_ne: Time
  createdAtMax_ne: Time
  createdAt_gt: Time
  createdAtMin_gt: Time
  createdAtMax_gt: Time
  createdAt_lt: Time
  createdAtMin_lt: Time
  createdAtMax_lt: Time
  createdAt_gte: Time
  createdAtMin_gte: Time
  createdAtMax_gte: Time
  createdAt_lte: Time
  createdAtMin_lte: Time
  createdAtMax_lte: Time
  createdAt_in: [Time!]
  createdAtMin_in: [Time!]
  createdAtMax_in: [Time!]
  createdAt_null: Boolean
  updatedBy: ID
  updatedByMin: ID
  updatedByMax: ID
  updatedBy_ne: ID
  updatedByMin_ne: ID
  updatedByMax_ne: ID
  updatedBy_gt: ID
  updatedByMin_gt: ID
  updatedByMax_gt: ID
  updatedBy_lt: ID
  updatedByMin_lt: ID
  updatedByMax_lt: ID
  updatedBy_gte: ID
  updatedByMin_gte: ID
  updatedByMax_gte: ID
  updatedBy_lte: ID
  updatedByMin_lte: ID
  updatedByMax_lte: ID
  updatedBy_in: [ID!]
  updatedByMin_in: [ID!]
  updatedByMax_in: [ID!]
  updatedBy_null: Boolean
  createdBy: ID
  createdByMin: ID
  createdByMax: ID
  createdBy_ne: ID
  createdByMin_ne: ID
  createdByMax_ne: ID
  createdBy_gt: ID
  createdByMin_gt: ID
  createdByMax_gt: ID
  createdBy_lt: ID
  createdByMin_lt: ID
  createdByMax_lt: ID
  createdBy_gte: ID
  createdByMin_gte: ID
  createdByMax_gte: ID
  createdBy_lte: ID
  createdByMin_lte: ID
  createdByMax_lte: ID
  createdBy_in: [ID!]
  createdByMin_in: [ID!]
  createdByMax_in: [ID!]
  createdBy_null: Boolean
  tasks: TaskFilterType
}

type TaskCategoryResultType {
  items: [TaskCategory!]!
  count: Int!
}

input CompanyCreateInput {
  id: ID
  name: String
  countryId: ID
  employeesIds: [ID!]
}

input CompanyUpdateInput {
  name: String
  countryId: ID
  employeesIds: [ID!]
}

input CompanySortType {
  id: ObjectSortType
  idMin: ObjectSortType
  idMax: ObjectSortType
  name: ObjectSortType
  nameMin: ObjectSortType
  nameMax: ObjectSortType
  countryId: ObjectSortType
  countryIdMin: ObjectSortType
  countryIdMax: ObjectSortType
  updatedAt: ObjectSortType
  updatedAtMin: ObjectSortType
  updatedAtMax: ObjectSortType
  createdAt: ObjectSortType
  createdAtMin: ObjectSortType
  createdAtMax: ObjectSortType
  updatedBy: ObjectSortType
  updatedByMin: ObjectSortType
  updatedByMax: ObjectSortType
  createdBy: ObjectSortType
  createdByMin: ObjectSortType
  createdByMax: ObjectSortType
  employeesIds: ObjectSortType
  employeesIdsMin: ObjectSortType
  employeesIdsMax: ObjectSortType
  employees: UserSortType
}

input CompanyFilterType {
  AND: [CompanyFilterType!]
  OR: [CompanyFilterType!]
  id: ID
  idMin: ID
  idMax: ID
  id_ne: ID
  idMin_ne: ID
  idMax_ne: ID
  id_gt: ID
  idMin_gt: ID
  idMax_gt: ID
  id_lt: ID
  idMin_lt: ID
  idMax_lt: ID
  id_gte: ID
  idMin_gte: ID
  idMax_gte: ID
  id_lte: ID
  idMin_lte: ID
  idMax_lte: ID
  id_in: [ID!]
  idMin_in: [ID!]
  idMax_in: [ID!]
  id_null: Boolean
  name: String
  nameMin: String
  nameMax: String
  name_ne: String
  nameMin_ne: String
  nameMax_ne: String
  name_gt: String
  nameMin_gt: String
  nameMax_gt: String
  name_lt: String
  nameMin_lt: String
  nameMax_lt: String
  name_gte: String
  nameMin_gte: String
  nameMax_gte: String
  name_lte: String
  nameMin_lte: String
  nameMax_lte: String
  name_in: [String!]
  nameMin_in: [String!]
  nameMax_in: [String!]
  name_like: String
  nameMin_like: String
  nameMax_like: String
  name_prefix: String
  nameMin_prefix: String
  nameMax_prefix: String
  name_suffix: String
  nameMin_suffix: String
  nameMax_suffix: String
  name_null: Boolean
  countryId: ID
  countryIdMin: ID
  countryIdMax: ID
  countryId_ne: ID
  countryIdMin_ne: ID
  countryIdMax_ne: ID
  countryId_gt: ID
  countryIdMin_gt: ID
  countryIdMax_gt: ID
  countryId_lt: ID
  countryIdMin_lt: ID
  countryIdMax_lt: ID
  countryId_gte: ID
  countryIdMin_gte: ID
  countryIdMax_gte: ID
  countryId_lte: ID
  countryIdMin_lte: ID
  countryIdMax_lte: ID
  countryId_in: [ID!]
  countryIdMin_in: [ID!]
  countryIdMax_in: [ID!]
  countryId_null: Boolean
  updatedAt: Time
  updatedAtMin: Time
  updatedAtMax: Time
  updatedAt_ne: Time
  updatedAtMin_ne: Time
  updatedAtMax_ne: Time
  updatedAt_gt: Time
  updatedAtMin_gt: Time
  updatedAtMax_gt: Time
  updatedAt_lt: Time
  updatedAtMin_lt: Time
  updatedAtMax_lt: Time
  updatedAt_gte: Time
  updatedAtMin_gte: Time
  updatedAtMax_gte: Time
  updatedAt_lte: Time
  updatedAtMin_lte: Time
  updatedAtMax_lte: Time
  updatedAt_in: [Time!]
  updatedAtMin_in: [Time!]
  updatedAtMax_in: [Time!]
  updatedAt_null: Boolean
  createdAt: Time
  createdAtMin: Time
  createdAtMax: Time
  createdAt_ne: Time
  createdAtMin_ne: Time
  createdAtMax_ne: Time
  createdAt_gt: Time
  createdAtMin_gt: Time
  createdAtMax_gt: Time
  createdAt_lt: Time
  createdAtMin_lt: Time
  createdAtMax_lt: Time
  createdAt_gte: Time
  createdAtMin_gte: Time
  createdAtMax_gte: Time
  createdAt_lte: Time
  createdAtMin_lte: Time
  createdAtMax_lte: Time
  createdAt_in: [Time!]
  createdAtMin_in: [Time!]
  createdAtMax_in: [Time!]
  createdAt_null: Boolean
  updatedBy: ID
  updatedByMin: ID
  updatedByMax: ID
  updatedBy_ne: ID
  updatedByMin_ne: ID
  updatedByMax_ne: ID
  updatedBy_gt: ID
  updatedByMin_gt: ID
  updatedByMax_gt: ID
  updatedBy_lt: ID
  updatedByMin_lt: ID
  updatedByMax_lt: ID
  updatedBy_gte: ID
  updatedByMin_gte: ID
  updatedByMax_gte: ID
  updatedBy_lte: ID
  updatedByMin_lte: ID
  updatedByMax_lte: ID
  updatedBy_in: [ID!]
  updatedByMin_in: [ID!]
  updatedByMax_in: [ID!]
  updatedBy_null: Boolean
  createdBy: ID
  createdByMin: ID
  createdByMax: ID
  createdBy_ne: ID
  createdByMin_ne: ID
  createdByMax_ne: ID
  createdBy_gt: ID
  createdByMin_gt: ID
  createdByMax_gt: ID
  createdBy_lt: ID
  createdByMin_lt: ID
  createdByMax_lt: ID
  createdBy_gte: ID
  createdByMin_gte: ID
  createdByMax_gte: ID
  createdBy_lte: ID
  createdByMin_lte: ID
  createdByMax_lte: ID
  createdBy_in: [ID!]
  createdByMin_in: [ID!]
  createdByMax_in: [ID!]
  createdBy_null: Boolean
  employees: UserFilterType
}

type CompanyResultType {
  items: [Company!]!
  count: Int!
}

input UserCreateInput {
  id: ID
  code: Int
  email: String
  firstName: String
  lastName: String
  addressRaw: String
  salary: Int
  employersIds: [ID!]
  tasksIds: [ID!]
  createdTasksIds: [ID!]
}

input UserUpdateInput {
  code: Int
  email: String
  firstName: String
  lastName: String
  addressRaw: String
  salary: Int
  employersIds: [ID!]
  tasksIds: [ID!]
  createdTasksIds: [ID!]
}

input UserSortType {
  id: ObjectSortType
  idMin: ObjectSortType
  idMax: ObjectSortType
  code: ObjectSortType
  codeMin: ObjectSortType
  codeMax: ObjectSortType
  codeAvg: ObjectSortType
  email: ObjectSortType
  emailMin: ObjectSortType
  emailMax: ObjectSortType
  firstName: ObjectSortType
  firstNameMin: ObjectSortType
  firstNameMax: ObjectSortType
  lastName: ObjectSortType
  lastNameMin: ObjectSortType
  lastNameMax: ObjectSortType
  addressRaw: ObjectSortType
  addressRawMin: ObjectSortType
  addressRawMax: ObjectSortType
  salary: ObjectSortType
  salaryMin: ObjectSortType
  salaryMax: ObjectSortType
  salaryAvg: ObjectSortType
  updatedAt: ObjectSortType
  updatedAtMin: ObjectSortType
  updatedAtMax: ObjectSortType
  createdAt: ObjectSortType
  createdAtMin: ObjectSortType
  createdAtMax: ObjectSortType
  updatedBy: ObjectSortType
  updatedByMin: ObjectSortType
  updatedByMax: ObjectSortType
  createdBy: ObjectSortType
  createdByMin: ObjectSortType
  createdByMax: ObjectSortType
  employersIds: ObjectSortType
  employersIdsMin: ObjectSortType
  employersIdsMax: ObjectSortType
  tasksIds: ObjectSortType
  tasksIdsMin: ObjectSortType
  tasksIdsMax: ObjectSortType
  createdTasksIds: ObjectSortType
  createdTasksIdsMin: ObjectSortType
  createdTasksIdsMax: ObjectSortType
  employers: CompanySortType
  tasks: TaskSortType
  createdTasks: TaskSortType
}

input UserFilterType {
  AND: [UserFilterType!]
  OR: [UserFilterType!]
  id: ID
  idMin: ID
  idMax: ID
  id_ne: ID
  idMin_ne: ID
  idMax_ne: ID
  id_gt: ID
  idMin_gt: ID
  idMax_gt: ID
  id_lt: ID
  idMin_lt: ID
  idMax_lt: ID
  id_gte: ID
  idMin_gte: ID
  idMax_gte: ID
  id_lte: ID
  idMin_lte: ID
  idMax_lte: ID
  id_in: [ID!]
  idMin_in: [ID!]
  idMax_in: [ID!]
  id_null: Boolean
  code: Int
  codeMin: Int
  codeMax: Int
  codeAvg: Int
  code_ne: Int
  codeMin_ne: Int
  codeMax_ne: Int
  codeAvg_ne: Int
  code_gt: Int
  codeMin_gt: Int
  codeMax_gt: Int
  codeAvg_gt: Int
  code_lt: Int
  codeMin_lt: Int
  codeMax_lt: Int
  codeAvg_lt: Int
  code_gte: Int
  codeMin_gte: Int
  codeMax_gte: Int
  codeAvg_gte: Int
  code_lte: Int
  codeMin_lte: Int
  codeMax_lte: Int
  codeAvg_lte: Int
  code_in: [Int!]
  codeMin_in: [Int!]
  codeMax_in: [Int!]
  codeAvg_in: [Int!]
  code_null: Boolean
  email: String
  emailMin: String
  emailMax: String
  email_ne: String
  emailMin_ne: String
  emailMax_ne: String
  email_gt: String
  emailMin_gt: String
  emailMax_gt: String
  email_lt: String
  emailMin_lt: String
  emailMax_lt: String
  email_gte: String
  emailMin_gte: String
  emailMax_gte: String
  email_lte: String
  emailMin_lte: String
  emailMax_lte: String
  email_in: [String!]
  emailMin_in: [String!]
  emailMax_in: [String!]
  email_like: String
  emailMin_like: String
  emailMax_like: String
  email_prefix: String
  emailMin_prefix: String
  emailMax_prefix: String
  email_suffix: String
  emailMin_suffix: String
  emailMax_suffix: String
  email_null: Boolean
  firstName: String
  firstNameMin: String
  firstNameMax: String
  firstName_ne: String
  firstNameMin_ne: String
  firstNameMax_ne: String
  firstName_gt: String
  firstNameMin_gt: String
  firstNameMax_gt: String
  firstName_lt: String
  firstNameMin_lt: String
  firstNameMax_lt: String
  firstName_gte: String
  firstNameMin_gte: String
  firstNameMax_gte: String
  firstName_lte: String
  firstNameMin_lte: String
  firstNameMax_lte: String
  firstName_in: [String!]
  firstNameMin_in: [String!]
  firstNameMax_in: [String!]
  firstName_like: String
  firstNameMin_like: String
  firstNameMax_like: String
  firstName_prefix: String
  firstNameMin_prefix: String
  firstNameMax_prefix: String
  firstName_suffix: String
  firstNameMin_suffix: String
  firstNameMax_suffix: String
  firstName_null: Boolean
  lastName: String
  lastNameMin: String
  lastNameMax: String
  lastName_ne: String
  lastNameMin_ne: String
  lastNameMax_ne: String
  lastName_gt: String
  lastNameMin_gt: String
  lastNameMax_gt: String
  lastName_lt: String
  lastNameMin_lt: String
  lastNameMax_lt: String
  lastName_gte: String
  lastNameMin_gte: String
  lastNameMax_gte: String
  lastName_lte: String
  lastNameMin_lte: String
  lastNameMax_lte: String
  lastName_in: [String!]
  lastNameMin_in: [String!]
  lastNameMax_in: [String!]
  lastName_like: String
  lastNameMin_like: String
  lastNameMax_like: String
  lastName_prefix: String
  lastNameMin_prefix: String
  lastNameMax_prefix: String
  lastName_suffix: String
  lastNameMin_suffix: String
  lastNameMax_suffix: String
  lastName_null: Boolean
  addressRaw: String
  addressRawMin: String
  addressRawMax: String
  addressRaw_ne: String
  addressRawMin_ne: String
  addressRawMax_ne: String
  addressRaw_gt: String
  addressRawMin_gt: String
  addressRawMax_gt: String
  addressRaw_lt: String
  addressRawMin_lt: String
  addressRawMax_lt: String
  addressRaw_gte: String
  addressRawMin_gte: String
  addressRawMax_gte: String
  addressRaw_lte: String
  addressRawMin_lte: String
  addressRawMax_lte: String
  addressRaw_in: [String!]
  addressRawMin_in: [String!]
  addressRawMax_in: [String!]
  addressRaw_like: String
  addressRawMin_like: String
  addressRawMax_like: String
  addressRaw_prefix: String
  addressRawMin_prefix: String
  addressRawMax_prefix: String
  addressRaw_suffix: String
  addressRawMin_suffix: String
  addressRawMax_suffix: String
  addressRaw_null: Boolean
  salary: Int
  salaryMin: Int
  salaryMax: Int
  salaryAvg: Int
  salary_ne: Int
  salaryMin_ne: Int
  salaryMax_ne: Int
  salaryAvg_ne: Int
  salary_gt: Int
  salaryMin_gt: Int
  salaryMax_gt: Int
  salaryAvg_gt: Int
  salary_lt: Int
  salaryMin_lt: Int
  salaryMax_lt: Int
  salaryAvg_lt: Int
  salary_gte: Int
  salaryMin_gte: Int
  salaryMax_gte: Int
  salaryAvg_gte: Int
  salary_lte: Int
  salaryMin_lte: Int
  salaryMax_lte: Int
  salaryAvg_lte: Int
  salary_in: [Int!]
  salaryMin_in: [Int!]
  salaryMax_in: [Int!]
  salaryAvg_in: [Int!]
  salary_null: Boolean
  updatedAt: Time
  updatedAtMin: Time
  updatedAtMax: Time
  updatedAt_ne: Time
  updatedAtMin_ne: Time
  updatedAtMax_ne: Time
  updatedAt_gt: Time
  updatedAtMin_gt: Time
  updatedAtMax_gt: Time
  updatedAt_lt: Time
  updatedAtMin_lt: Time
  updatedAtMax_lt: Time
  updatedAt_gte: Time
  updatedAtMin_gte: Time
  updatedAtMax_gte: Time
  updatedAt_lte: Time
  updatedAtMin_lte: Time
  updatedAtMax_lte: Time
  updatedAt_in: [Time!]
  updatedAtMin_in: [Time!]
  updatedAtMax_in: [Time!]
  updatedAt_null: Boolean
  createdAt: Time
  createdAtMin: Time
  createdAtMax: Time
  createdAt_ne: Time
  createdAtMin_ne: Time
  createdAtMax_ne: Time
  createdAt_gt: Time
  createdAtMin_gt: Time
  createdAtMax_gt: Time
  createdAt_lt: Time
  createdAtMin_lt: Time
  createdAtMax_lt: Time
  createdAt_gte: Time
  createdAtMin_gte: Time
  createdAtMax_gte: Time
  createdAt_lte: Time
  createdAtMin_lte: Time
  createdAtMax_lte: Time
  createdAt_in: [Time!]
  createdAtMin_in: [Time!]
  createdAtMax_in: [Time!]
  createdAt_null: Boolean
  updatedBy: ID
  updatedByMin: ID
  updatedByMax: ID
  updatedBy_ne: ID
  updatedByMin_ne: ID
  updatedByMax_ne: ID
  updatedBy_gt: ID
  updatedByMin_gt: ID
  updatedByMax_gt: ID
  updatedBy_lt: ID
  updatedByMin_lt: ID
  updatedByMax_lt: ID
  updatedBy_gte: ID
  updatedByMin_gte: ID
  updatedByMax_gte: ID
  updatedBy_lte: ID
  updatedByMin_lte: ID
  updatedByMax_lte: ID
  updatedBy_in: [ID!]
  updatedByMin_in: [ID!]
  updatedByMax_in: [ID!]
  updatedBy_null: Boolean
  createdBy: ID
  createdByMin: ID
  createdByMax: ID
  createdBy_ne: ID
  createdByMin_ne: ID
  createdByMax_ne: ID
  createdBy_gt: ID
  createdByMin_gt: ID
  createdByMax_gt: ID
  createdBy_lt: ID
  createdByMin_lt: ID
  createdByMax_lt: ID
  createdBy_gte: ID
  createdByMin_gte: ID
  createdByMax_gte: ID
  createdBy_lte: ID
  createdByMin_lte: ID
  createdByMax_lte: ID
  createdBy_in: [ID!]
  createdByMin_in: [ID!]
  createdByMax_in: [ID!]
  createdBy_null: Boolean
  employers: CompanyFilterType
  tasks: TaskFilterType
  createdTasks: TaskFilterType
}

type UserResultType {
  items: [User!]!
  count: Int!
}

input PlainEntityCreateInput {
  id: ID
  date: Time
  text: String
}

input PlainEntityUpdateInput {
  date: Time
  text: String
}

input PlainEntitySortType {
  id: ObjectSortType
  idMin: ObjectSortType
  idMax: ObjectSortType
  date: ObjectSortType
  dateMin: ObjectSortType
  dateMax: ObjectSortType
  text: ObjectSortType
  textMin: ObjectSortType
  textMax: ObjectSortType
  updatedAt: ObjectSortType
  updatedAtMin: ObjectSortType
  updatedAtMax: ObjectSortType
  createdAt: ObjectSortType
  createdAtMin: ObjectSortType
  createdAtMax: ObjectSortType
  updatedBy: ObjectSortType
  updatedByMin: ObjectSortType
  updatedByMax: ObjectSortType
  createdBy: ObjectSortType
  createdByMin: ObjectSortType
  createdByMax: ObjectSortType
}

input PlainEntityFilterType {
  AND: [PlainEntityFilterType!]
  OR: [PlainEntityFilterType!]
  id: ID
  idMin: ID
  idMax: ID
  id_ne: ID
  idMin_ne: ID
  idMax_ne: ID
  id_gt: ID
  idMin_gt: ID
  idMax_gt: ID
  id_lt: ID
  idMin_lt: ID
  idMax_lt: ID
  id_gte: ID
  idMin_gte: ID
  idMax_gte: ID
  id_lte: ID
  idMin_lte: ID
  idMax_lte: ID
  id_in: [ID!]
  idMin_in: [ID!]
  idMax_in: [ID!]
  id_null: Boolean
  date: Time
  dateMin: Time
  dateMax: Time
  date_ne: Time
  dateMin_ne: Time
  dateMax_ne: Time
  date_gt: Time
  dateMin_gt: Time
  dateMax_gt: Time
  date_lt: Time
  dateMin_lt: Time
  dateMax_lt: Time
  date_gte: Time
  dateMin_gte: Time
  dateMax_gte: Time
  date_lte: Time
  dateMin_lte: Time
  dateMax_lte: Time
  date_in: [Time!]
  dateMin_in: [Time!]
  dateMax_in: [Time!]
  date_null: Boolean
  text: String
  textMin: String
  textMax: String
  text_ne: String
  textMin_ne: String
  textMax_ne: String
  text_gt: String
  textMin_gt: String
  textMax_gt: String
  text_lt: String
  textMin_lt: String
  textMax_lt: String
  text_gte: String
  textMin_gte: String
  textMax_gte: String
  text_lte: String
  textMin_lte: String
  textMax_lte: String
  text_in: [String!]
  textMin_in: [String!]
  textMax_in: [String!]
  text_like: String
  textMin_like: String
  textMax_like: String
  text_prefix: String
  textMin_prefix: String
  textMax_prefix: String
  text_suffix: String
  textMin_suffix: String
  textMax_suffix: String
  text_null: Boolean
  updatedAt: Time
  updatedAtMin: Time
  updatedAtMax: Time
  updatedAt_ne: Time
  updatedAtMin_ne: Time
  updatedAtMax_ne: Time
  updatedAt_gt: Time
  updatedAtMin_gt: Time
  updatedAtMax_gt: Time
  updatedAt_lt: Time
  updatedAtMin_lt: Time
  updatedAtMax_lt: Time
  updatedAt_gte: Time
  updatedAtMin_gte: Time
  updatedAtMax_gte: Time
  updatedAt_lte: Time
  updatedAtMin_lte: Time
  updatedAtMax_lte: Time
  updatedAt_in: [Time!]
  updatedAtMin_in: [Time!]
  updatedAtMax_in: [Time!]
  updatedAt_null: Boolean
  createdAt: Time
  createdAtMin: Time
  createdAtMax: Time
  createdAt_ne: Time
  createdAtMin_ne: Time
  createdAtMax_ne: Time
  createdAt_gt: Time
  createdAtMin_gt: Time
  createdAtMax_gt: Time
  createdAt_lt: Time
  createdAtMin_lt: Time
  createdAtMax_lt: Time
  createdAt_gte: Time
  createdAtMin_gte: Time
  createdAtMax_gte: Time
  createdAt_lte: Time
  createdAtMin_lte: Time
  createdAtMax_lte: Time
  createdAt_in: [Time!]
  createdAtMin_in: [Time!]
  createdAtMax_in: [Time!]
  createdAt_null: Boolean
  updatedBy: ID
  updatedByMin: ID
  updatedByMax: ID
  updatedBy_ne: ID
  updatedByMin_ne: ID
  updatedByMax_ne: ID
  updatedBy_gt: ID
  updatedByMin_gt: ID
  updatedByMax_gt: ID
  updatedBy_lt: ID
  updatedByMin_lt: ID
  updatedByMax_lt: ID
  updatedBy_gte: ID
  updatedByMin_gte: ID
  updatedByMax_gte: ID
  updatedBy_lte: ID
  updatedByMin_lte: ID
  updatedByMax_lte: ID
  updatedBy_in: [ID!]
  updatedByMin_in: [ID!]
  updatedByMax_in: [ID!]
  updatedBy_null: Boolean
  createdBy: ID
  createdByMin: ID
  createdByMax: ID
  createdBy_ne: ID
  createdByMin_ne: ID
  createdByMax_ne: ID
  createdBy_gt: ID
  createdByMin_gt: ID
  createdByMax_gt: ID
  createdBy_lt: ID
  createdByMin_lt: ID
  createdByMax_lt: ID
  createdBy_gte: ID
  createdByMin_gte: ID
  createdByMax_gte: ID
  createdBy_lte: ID
  createdByMin_lte: ID
  createdByMax_lte: ID
  createdBy_in: [ID!]
  createdByMin_in: [ID!]
  createdByMax_in: [ID!]
  createdBy_null: Boolean
}

type PlainEntityResultType {
  items: [PlainEntity!]!
  count: Int!
}

input TaskMetaInput {
  key: String!
  value: String
}

type _Service {
  sdl: String
}

union _Entity = Company

type Review {
  id: ID!
  referenceID: ID!
  company: Company
}

type Country {
  id: ID!
}
`, BuiltIn: false},
	{Name: "federation/directives.graphql", Input: `
scalar _Any
scalar _FieldSet

directive @external on FIELD_DEFINITION
directive @requires(fields: _FieldSet!) on FIELD_DEFINITION
directive @provides(fields: _FieldSet!) on FIELD_DEFINITION
directive @key(fields: _FieldSet!) on OBJECT | INTERFACE
directive @extends on OBJECT
`, BuiltIn: true},
}
var parsedSchema = gqlparser.MustLoadSchema(sources...)

// endregion ************************** generated!.gotpl **************************

// region    ***************************** args.gotpl *****************************

func (ec *executionContext) field_Company_employeesConnection_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*UserSortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOUserSortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserSortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *UserFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOUserFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_Mutation_createCompany_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 map[string]interface{}
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNCompanyCreateInput2map(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_createPlainEntity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 map[string]interface{}
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNPlainEntityCreateInput2map(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_createTaskCategory_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 map[string]interface{}
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNTaskCategoryCreateInput2map(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_createTask_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 map[string]interface{}
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNTaskCreateInput2map(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_createUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 map[string]interface{}
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalNUserCreateInput2map(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_deleteCompany_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_deletePlainEntity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_deleteTaskCategory_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_deleteTask_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_deleteUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_updateCompany_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	var arg1 map[string]interface{}
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg1, err = ec.unmarshalNCompanyUpdateInput2map(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg1
	return args, nil
}

func (ec *executionContext) field_Mutation_updatePlainEntity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	var arg1 map[string]interface{}
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg1, err = ec.unmarshalNPlainEntityUpdateInput2map(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg1
	return args, nil
}

func (ec *executionContext) field_Mutation_updateTaskCategory_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	var arg1 map[string]interface{}
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg1, err = ec.unmarshalNTaskCategoryUpdateInput2map(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg1
	return args, nil
}

func (ec *executionContext) field_Mutation_updateTask_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	var arg1 map[string]interface{}
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg1, err = ec.unmarshalNTaskUpdateInput2map(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg1
	return args, nil
}

func (ec *executionContext) field_Mutation_updateUser_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalNID2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	var arg1 map[string]interface{}
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg1, err = ec.unmarshalNUserUpdateInput2map(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg1
	return args, nil
}

func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 string
	if tmp, ok := rawArgs["name"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["name"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_companies_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*CompanySortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOCompanySortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanySortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *CompanyFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOCompanyFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_Query_company_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalOID2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	var arg1 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg1
	var arg2 *CompanyFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg2, err = ec.unmarshalOCompanyFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg2
	return args, nil
}

func (ec *executionContext) field_Query_plainEntities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*PlainEntitySortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOPlainEntitySortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntitySortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *PlainEntityFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOPlainEntityFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_Query_plainEntity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalOID2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	var arg1 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg1
	var arg2 *PlainEntityFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg2, err = ec.unmarshalOPlainEntityFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg2
	return args, nil
}

func (ec *executionContext) field_Query_taskCategories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*TaskCategorySortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOTaskCategorySortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategorySortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *TaskCategoryFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOTaskCategoryFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_Query_taskCategory_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalOID2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	var arg1 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg1
	var arg2 *TaskCategoryFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg2, err = ec.unmarshalOTaskCategoryFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg2
	return args, nil
}

func (ec *executionContext) field_Query_task_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalOID2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	var arg1 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg1
	var arg2 *TaskFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg2, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg2
	return args, nil
}

func (ec *executionContext) field_Query_tasks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*TaskSortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOTaskSortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *TaskFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_Query_user_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *string
	if tmp, ok := rawArgs["id"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
		arg0, err = ec.unmarshalOID2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["id"] = arg0
	var arg1 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg1
	var arg2 *UserFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg2, err = ec.unmarshalOUserFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg2
	return args, nil
}

func (ec *executionContext) field_Query_users_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*UserSortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOUserSortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserSortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *UserFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOUserFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_TaskCategory_tasksConnection_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*TaskSortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOTaskSortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *TaskFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_Task_categoriesConnection_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*TaskCategorySortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOTaskCategorySortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategorySortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *TaskCategoryFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOTaskCategoryFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_Task_subtasksConnection_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*TaskSortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOTaskSortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *TaskFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_User_createdTasksConnection_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*TaskSortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOTaskSortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *TaskFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_User_employersConnection_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*CompanySortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOCompanySortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanySortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *CompanyFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOCompanyFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field_User_tasksConnection_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *int
	if tmp, ok := rawArgs["offset"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("offset"))
		arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["offset"] = arg0
	var arg1 *int
	if tmp, ok := rawArgs["limit"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
		arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["limit"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["q"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("q"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["q"] = arg2
	var arg3 []*TaskSortType
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg3, err = ec.unmarshalOTaskSortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortTypeᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg3
	var arg4 *TaskFilterType
	if tmp, ok := rawArgs["filter"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
		arg4, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["filter"] = arg4
	return args, nil
}

func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 bool
	if tmp, ok := rawArgs["includeDeprecated"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 bool
	if tmp, ok := rawArgs["includeDeprecated"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["includeDeprecated"] = arg0
	return args, nil
}

// endregion ***************************** args.gotpl *****************************

// region    ************************** directives.gotpl **************************

// endregion ************************** directives.gotpl **************************

// region    **************************** field.gotpl *****************************

func (ec *executionContext) _Address_street(ctx context.Context, field graphql.CollectedField, obj *Address) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Address",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Street, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Address_city(ctx context.Context, field graphql.CollectedField, obj *Address) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Address",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.City, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Address_zip(ctx context.Context, field graphql.CollectedField, obj *Address) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Address",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Zip, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_id(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_name(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_countryId(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CountryID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_country(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Company().Country(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Country)
	fc.Result = res
	return ec.marshalOCountry2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCountry(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_employees(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Company().Employees(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*User)
	fc.Result = res
	return ec.marshalNUser2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_reviews(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Company().Reviews(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*Review)
	fc.Result = res
	return ec.marshalNReview2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐReviewᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_updatedAt(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UpdatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*time.Time)
	fc.Result = res
	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_createdAt(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_updatedBy(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UpdatedBy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_createdBy(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedBy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_employeesIds(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Company().EmployeesIds(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalNID2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_employeesConnection(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Company_employeesConnection_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Company().EmployeesConnection(rctx, obj, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*UserSortType), args["filter"].(*UserFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*UserResultType)
	fc.Result = res
	return ec.marshalNUserResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _Company_uppercaseName(ctx context.Context, field graphql.CollectedField, obj *Company) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Company",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Company().UppercaseName(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _CompanyResultType_items(ctx context.Context, field graphql.CollectedField, obj *CompanyResultType) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "CompanyResultType",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.CompanyResultType().Items(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*Company)
	fc.Result = res
	return ec.marshalNCompany2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _CompanyResultType_count(ctx context.Context, field graphql.CollectedField, obj *CompanyResultType) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "CompanyResultType",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.CompanyResultType().Count(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Country_id(ctx context.Context, field graphql.CollectedField, obj *Country) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Country",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_createTask(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_createTask_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().CreateTask(rctx, args["input"].(map[string]interface{}))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Task)
	fc.Result = res
	return ec.marshalNTask2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTask(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_updateTask(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_updateTask_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().UpdateTask(rctx, args["id"].(string), args["input"].(map[string]interface{}))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Task)
	fc.Result = res
	return ec.marshalNTask2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTask(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_deleteTask(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_deleteTask_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().DeleteTask(rctx, args["id"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Task)
	fc.Result = res
	return ec.marshalNTask2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTask(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_deleteAllTasks(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().DeleteAllTasks(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_createTaskCategory(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_createTaskCategory_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().CreateTaskCategory(rctx, args["input"].(map[string]interface{}))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TaskCategory)
	fc.Result = res
	return ec.marshalNTaskCategory2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategory(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_updateTaskCategory(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_updateTaskCategory_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().UpdateTaskCategory(rctx, args["id"].(string), args["input"].(map[string]interface{}))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TaskCategory)
	fc.Result = res
	return ec.marshalNTaskCategory2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategory(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_deleteTaskCategory(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_deleteTaskCategory_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().DeleteTaskCategory(rctx, args["id"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TaskCategory)
	fc.Result = res
	return ec.marshalNTaskCategory2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategory(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_deleteAllTaskCategories(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().DeleteAllTaskCategories(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_createCompany(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_createCompany_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().CreateCompany(rctx, args["input"].(map[string]interface{}))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Company)
	fc.Result = res
	return ec.marshalNCompany2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompany(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_updateCompany(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_updateCompany_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().UpdateCompany(rctx, args["id"].(string), args["input"].(map[string]interface{}))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Company)
	fc.Result = res
	return ec.marshalNCompany2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompany(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_deleteCompany(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_deleteCompany_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().DeleteCompany(rctx, args["id"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*Company)
	fc.Result = res
	return ec.marshalNCompany2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompany(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_deleteAllCompanies(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().DeleteAllCompanies(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_createUser(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_createUser_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().CreateUser(rctx, args["input"].(map[string]interface{}))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*User)
	fc.Result = res
	return ec.marshalNUser2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_updateUser(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_updateUser_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().UpdateUser(rctx, args["id"].(string), args["input"].(map[string]interface{}))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*User)
	fc.Result = res
	return ec.marshalNUser2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_deleteUser(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_deleteUser_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().DeleteUser(rctx, args["id"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*User)
	fc.Result = res
	return ec.marshalNUser2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_deleteAllUsers(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().DeleteAllUsers(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_createPlainEntity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_createPlainEntity_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().CreatePlainEntity(rctx, args["input"].(map[string]interface{}))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*PlainEntity)
	fc.Result = res
	return ec.marshalNPlainEntity2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntity(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_updatePlainEntity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_updatePlainEntity_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().UpdatePlainEntity(rctx, args["id"].(string), args["input"].(map[string]interface{}))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*PlainEntity)
	fc.Result = res
	return ec.marshalNPlainEntity2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntity(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_deletePlainEntity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Mutation_deletePlainEntity_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().DeletePlainEntity(rctx, args["id"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*PlainEntity)
	fc.Result = res
	return ec.marshalNPlainEntity2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntity(ctx, field.Selections, res)
}

func (ec *executionContext) _Mutation_deleteAllPlainEntities(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Mutation().DeleteAllPlainEntities(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) _PlainEntity_id(ctx context.Context, field graphql.CollectedField, obj *PlainEntity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "PlainEntity",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _PlainEntity_date(ctx context.Context, field graphql.CollectedField, obj *PlainEntity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "PlainEntity",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Date, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*time.Time)
	fc.Result = res
	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _PlainEntity_text(ctx context.Context, field graphql.CollectedField, obj *PlainEntity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "PlainEntity",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Text, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _PlainEntity_shortText(ctx context.Context, field graphql.CollectedField, obj *PlainEntity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "PlainEntity",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.PlainEntity().ShortText(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _PlainEntity_updatedAt(ctx context.Context, field graphql.CollectedField, obj *PlainEntity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "PlainEntity",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UpdatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*time.Time)
	fc.Result = res
	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _PlainEntity_createdAt(ctx context.Context, field graphql.CollectedField, obj *PlainEntity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "PlainEntity",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _PlainEntity_updatedBy(ctx context.Context, field graphql.CollectedField, obj *PlainEntity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "PlainEntity",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UpdatedBy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _PlainEntity_createdBy(ctx context.Context, field graphql.CollectedField, obj *PlainEntity) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "PlainEntity",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedBy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _PlainEntityResultType_items(ctx context.Context, field graphql.CollectedField, obj *PlainEntityResultType) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "PlainEntityResultType",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.PlainEntityResultType().Items(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*PlainEntity)
	fc.Result = res
	return ec.marshalNPlainEntity2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _PlainEntityResultType_count(ctx context.Context, field graphql.CollectedField, obj *PlainEntityResultType) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "PlainEntityResultType",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.PlainEntityResultType().Count(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _Query__service(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.__resolve__service(ctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(fedruntime.Service)
	fc.Result = res
	return ec.marshalN_Service2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋfedruntimeᚐService(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_task(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_task_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Task(rctx, args["id"].(*string), args["q"].(*string), args["filter"].(*TaskFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Task)
	fc.Result = res
	return ec.marshalOTask2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTask(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_tasks(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_tasks_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Tasks(rctx, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskSortType), args["filter"].(*TaskFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TaskResultType)
	fc.Result = res
	return ec.marshalNTaskResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_taskCategory(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_taskCategory_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().TaskCategory(rctx, args["id"].(*string), args["q"].(*string), args["filter"].(*TaskCategoryFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*TaskCategory)
	fc.Result = res
	return ec.marshalOTaskCategory2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategory(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_taskCategories(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_taskCategories_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().TaskCategories(rctx, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskCategorySortType), args["filter"].(*TaskCategoryFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TaskCategoryResultType)
	fc.Result = res
	return ec.marshalNTaskCategoryResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_company(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_company_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Company(rctx, args["id"].(*string), args["q"].(*string), args["filter"].(*CompanyFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Company)
	fc.Result = res
	return ec.marshalOCompany2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompany(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_companies(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_companies_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Companies(rctx, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*CompanySortType), args["filter"].(*CompanyFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*CompanyResultType)
	fc.Result = res
	return ec.marshalNCompanyResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_user(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_user_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().User(rctx, args["id"].(*string), args["q"].(*string), args["filter"].(*UserFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*User)
	fc.Result = res
	return ec.marshalOUser2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_users(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_users_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Users(rctx, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*UserSortType), args["filter"].(*UserFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*UserResultType)
	fc.Result = res
	return ec.marshalNUserResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_plainEntity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_plainEntity_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().PlainEntity(rctx, args["id"].(*string), args["q"].(*string), args["filter"].(*PlainEntityFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*PlainEntity)
	fc.Result = res
	return ec.marshalOPlainEntity2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntity(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_plainEntities(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query_plainEntities_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().PlainEntities(rctx, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*PlainEntitySortType), args["filter"].(*PlainEntityFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*PlainEntityResultType)
	fc.Result = res
	return ec.marshalNPlainEntityResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_hello(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().Hello(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Query_topCompanies(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().TopCompanies(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*Company)
	fc.Result = res
	return ec.marshalNCompany2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Query___type_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectType(args["name"].(string))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectSchema()
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Schema)
	fc.Result = res
	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
}

func (ec *executionContext) _Review_id(ctx context.Context, field graphql.CollectedField, obj *Review) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Review",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Review_referenceID(ctx context.Context, field graphql.CollectedField, obj *Review) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Review",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ReferenceID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Review_company(ctx context.Context, field graphql.CollectedField, obj *Review) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Review",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Company, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Company)
	fc.Result = res
	return ec.marshalOCompany2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompany(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_id(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_title(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Title, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_completed(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Completed, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*bool)
	fc.Result = res
	return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_state(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.State, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*TaskState)
	fc.Result = res
	return ec.marshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_dueDate(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DueDate, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*time.Time)
	fc.Result = res
	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_metas(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().Metas(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*TaskMeta)
	fc.Result = res
	return ec.marshalOTaskMeta2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskMetaᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_meta(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().Meta(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*TaskMeta)
	fc.Result = res
	return ec.marshalOTaskMeta2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskMeta(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_assignee(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().Assignee(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*User)
	fc.Result = res
	return ec.marshalOUser2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_owner(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().Owner(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*User)
	fc.Result = res
	return ec.marshalNUser2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_parentTask(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().ParentTask(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Task)
	fc.Result = res
	return ec.marshalOTask2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTask(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_subtasks(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().Subtasks(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*Task)
	fc.Result = res
	return ec.marshalNTask2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_categories(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().Categories(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*TaskCategory)
	fc.Result = res
	return ec.marshalNTaskCategory2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_assigneeId(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.AssigneeID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_ownerId(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.OwnerID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_parentTaskId(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ParentTaskID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_updatedAt(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UpdatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*time.Time)
	fc.Result = res
	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_createdAt(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_updatedBy(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UpdatedBy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_createdBy(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedBy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_subtasksIds(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().SubtasksIds(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalNID2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_subtasksConnection(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Task_subtasksConnection_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().SubtasksConnection(rctx, obj, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskSortType), args["filter"].(*TaskFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TaskResultType)
	fc.Result = res
	return ec.marshalNTaskResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_categoriesIds(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().CategoriesIds(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalNID2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _Task_categoriesConnection(ctx context.Context, field graphql.CollectedField, obj *Task) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "Task",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_Task_categoriesConnection_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Task().CategoriesConnection(rctx, obj, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskCategorySortType), args["filter"].(*TaskCategoryFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TaskCategoryResultType)
	fc.Result = res
	return ec.marshalNTaskCategoryResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategory_id(ctx context.Context, field graphql.CollectedField, obj *TaskCategory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategory",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategory_name(ctx context.Context, field graphql.CollectedField, obj *TaskCategory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategory",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategory_tasks(ctx context.Context, field graphql.CollectedField, obj *TaskCategory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategory",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TaskCategory().Tasks(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*Task)
	fc.Result = res
	return ec.marshalNTask2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategory_updatedAt(ctx context.Context, field graphql.CollectedField, obj *TaskCategory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategory",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UpdatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*time.Time)
	fc.Result = res
	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategory_createdAt(ctx context.Context, field graphql.CollectedField, obj *TaskCategory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategory",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategory_updatedBy(ctx context.Context, field graphql.CollectedField, obj *TaskCategory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategory",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UpdatedBy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategory_createdBy(ctx context.Context, field graphql.CollectedField, obj *TaskCategory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategory",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedBy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategory_tasksIds(ctx context.Context, field graphql.CollectedField, obj *TaskCategory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategory",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TaskCategory().TasksIds(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalNID2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategory_tasksConnection(ctx context.Context, field graphql.CollectedField, obj *TaskCategory) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategory",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_TaskCategory_tasksConnection_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TaskCategory().TasksConnection(rctx, obj, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskSortType), args["filter"].(*TaskFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TaskResultType)
	fc.Result = res
	return ec.marshalNTaskResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategoryResultType_items(ctx context.Context, field graphql.CollectedField, obj *TaskCategoryResultType) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategoryResultType",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TaskCategoryResultType().Items(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*TaskCategory)
	fc.Result = res
	return ec.marshalNTaskCategory2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskCategoryResultType_count(ctx context.Context, field graphql.CollectedField, obj *TaskCategoryResultType) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskCategoryResultType",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TaskCategoryResultType().Count(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskMeta_key(ctx context.Context, field graphql.CollectedField, obj *TaskMeta) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskMeta",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Key, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskMeta_value(ctx context.Context, field graphql.CollectedField, obj *TaskMeta) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskMeta",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Value, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskResultType_items(ctx context.Context, field graphql.CollectedField, obj *TaskResultType) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskResultType",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TaskResultType().Items(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*Task)
	fc.Result = res
	return ec.marshalNTask2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _TaskResultType_count(ctx context.Context, field graphql.CollectedField, obj *TaskResultType) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "TaskResultType",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.TaskResultType().Count(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNID2string(ctx, field.Selections, res)
}

func (ec *executionContext) _User_code(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Code, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*int)
	fc.Result = res
	return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
}

func (ec *executionContext) _User_email(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Email, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _User_firstName(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.FirstName, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _User_lastName(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.LastName, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _User_addressRaw(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.AddressRaw, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _User_address(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().Address(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Address)
	fc.Result = res
	return ec.marshalOAddress2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐAddress(ctx, field.Selections, res)
}

func (ec *executionContext) _User_salary(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Salary, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*int)
	fc.Result = res
	return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
}

func (ec *executionContext) _User_employers(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().Employers(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*Company)
	fc.Result = res
	return ec.marshalNCompany2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _User_tasks(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().Tasks(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*Task)
	fc.Result = res
	return ec.marshalNTask2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _User_createdTasks(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().CreatedTasks(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*Task)
	fc.Result = res
	return ec.marshalNTask2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _User_updatedAt(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UpdatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*time.Time)
	fc.Result = res
	return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _User_createdAt(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedAt, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(time.Time)
	fc.Result = res
	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}

func (ec *executionContext) _User_updatedBy(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UpdatedBy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _User_createdBy(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CreatedBy, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOID2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) _User_employersIds(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().EmployersIds(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalNID2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _User_employersConnection(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_User_employersConnection_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().EmployersConnection(rctx, obj, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*CompanySortType), args["filter"].(*CompanyFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*CompanyResultType)
	fc.Result = res
	return ec.marshalNCompanyResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _User_tasksIds(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().TasksIds(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalNID2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _User_tasksConnection(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_User_tasksConnection_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().TasksConnection(rctx, obj, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskSortType), args["filter"].(*TaskFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TaskResultType)
	fc.Result = res
	return ec.marshalNTaskResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _User_createdTasksIds(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().CreatedTasksIds(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalNID2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _User_createdTasksConnection(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field_User_createdTasksConnection_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.User().CreatedTasksConnection(rctx, obj, args["offset"].(*int), args["limit"].(*int), args["q"].(*string), args["sort"].([]*TaskSortType), args["filter"].(*TaskFilterType))
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*TaskResultType)
	fc.Result = res
	return ec.marshalNTaskResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskResultType(ctx, field.Selections, res)
}

func (ec *executionContext) _UserResultType_items(ctx context.Context, field graphql.CollectedField, obj *UserResultType) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "UserResultType",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.UserResultType().Items(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*User)
	fc.Result = res
	return ec.marshalNUser2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) _UserResultType_count(ctx context.Context, field graphql.CollectedField, obj *UserResultType) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "UserResultType",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: true,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.UserResultType().Count(rctx, obj)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(int)
	fc.Result = res
	return ec.marshalNInt2int(ctx, field.Selections, res)
}

func (ec *executionContext) __Service_sdl(ctx context.Context, field graphql.CollectedField, obj *fedruntime.Service) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "_Service",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SDL, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Locations, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]string)
	fc.Result = res
	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Args, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.InputValue)
	fc.Result = res
	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsDeprecated(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeprecationReason(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Args, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.InputValue)
	fc.Result = res
	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Type, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsDeprecated(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(bool)
	fc.Result = res
	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}

func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeprecationReason(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalNString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Type, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		Args:       nil,
		IsMethod:   false,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DefaultValue, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Types(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.QueryType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MutationType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SubscriptionType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Directives(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]introspection.Directive)
	fc.Result = res
	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Kind(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Name(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Description(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(string)
	fc.Result = res
	return ec.marshalOString2string(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field___Type_fields_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Fields(args["includeDeprecated"].(bool)), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.Field)
	fc.Result = res
	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Interfaces(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PossibleTypes(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	rawArgs := field.ArgumentMap(ec.Variables)
	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	fc.Args = args
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.EnumValue)
	fc.Result = res
	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.InputFields(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]introspection.InputValue)
	fc.Result = res
	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	fc := &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		Args:       nil,
		IsMethod:   true,
		IsResolver: false,
	}

	ctx = graphql.WithFieldContext(ctx, fc)
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.OfType(), nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*introspection.Type)
	fc.Result = res
	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}

// endregion **************************** field.gotpl *****************************

// region    **************************** input.gotpl *****************************

func (ec *executionContext) unmarshalInputCompanyFilterType(ctx context.Context, obj interface{}) (CompanyFilterType, error) {
	var it CompanyFilterType
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "AND":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("AND"))
			it.And, err = ec.unmarshalOCompanyFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyFilterTypeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "OR":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("OR"))
			it.Or, err = ec.unmarshalOCompanyFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyFilterTypeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin"))
			it.IDMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax"))
			it.IDMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_ne"))
			it.IDNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_ne"))
			it.IDMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_ne"))
			it.IDMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_gt"))
			it.IDGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_gt"))
			it.IDMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_gt"))
			it.IDMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_lt"))
			it.IDLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_lt"))
			it.IDMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_lt"))
			it.IDMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_gte"))
			it.IDGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_gte"))
			it.IDMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_gte"))
			it.IDMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_lte"))
			it.IDLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_lte"))
			it.IDMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_lte"))
			it.IDMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_in"))
			it.IDIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_in"))
			it.IDMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_in"))
			it.IDMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_null"))
			it.IDNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			it.Name, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin"))
			it.NameMin, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax"))
			it.NameMax, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_ne"))
			it.NameNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_ne"))
			it.NameMinNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_ne"))
			it.NameMaxNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_gt"))
			it.NameGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_gt"))
			it.NameMinGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_gt"))
			it.NameMaxGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_lt"))
			it.NameLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_lt"))
			it.NameMinLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_lt"))
			it.NameMaxLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_gte"))
			it.NameGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_gte"))
			it.NameMinGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_gte"))
			it.NameMaxGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_lte"))
			it.NameLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_lte"))
			it.NameMinLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_lte"))
			it.NameMaxLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_in"))
			it.NameIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_in"))
			it.NameMinIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_in"))
			it.NameMaxIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_like"))
			it.NameLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_like"))
			it.NameMinLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_like"))
			it.NameMaxLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_prefix"))
			it.NamePrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_prefix"))
			it.NameMinPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_prefix"))
			it.NameMaxPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_suffix"))
			it.NameSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_suffix"))
			it.NameMinSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_suffix"))
			it.NameMaxSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_null"))
			it.NameNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryId":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryId"))
			it.CountryID, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMin"))
			it.CountryIDMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMax"))
			it.CountryIDMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryId_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryId_ne"))
			it.CountryIDNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMin_ne"))
			it.CountryIDMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMax_ne"))
			it.CountryIDMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryId_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryId_gt"))
			it.CountryIDGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMin_gt"))
			it.CountryIDMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMax_gt"))
			it.CountryIDMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryId_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryId_lt"))
			it.CountryIDLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMin_lt"))
			it.CountryIDMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMax_lt"))
			it.CountryIDMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryId_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryId_gte"))
			it.CountryIDGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMin_gte"))
			it.CountryIDMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMax_gte"))
			it.CountryIDMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryId_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryId_lte"))
			it.CountryIDLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMin_lte"))
			it.CountryIDMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMax_lte"))
			it.CountryIDMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryId_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryId_in"))
			it.CountryIDIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMin_in"))
			it.CountryIDMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMax_in"))
			it.CountryIDMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryId_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryId_null"))
			it.CountryIDNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt"))
			it.UpdatedAt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin"))
			it.UpdatedAtMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax"))
			it.UpdatedAtMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_ne"))
			it.UpdatedAtNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_ne"))
			it.UpdatedAtMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_ne"))
			it.UpdatedAtMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_gt"))
			it.UpdatedAtGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_gt"))
			it.UpdatedAtMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_gt"))
			it.UpdatedAtMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_lt"))
			it.UpdatedAtLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_lt"))
			it.UpdatedAtMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_lt"))
			it.UpdatedAtMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_gte"))
			it.UpdatedAtGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_gte"))
			it.UpdatedAtMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_gte"))
			it.UpdatedAtMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_lte"))
			it.UpdatedAtLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_lte"))
			it.UpdatedAtMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_lte"))
			it.UpdatedAtMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_in"))
			it.UpdatedAtIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_in"))
			it.UpdatedAtMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_in"))
			it.UpdatedAtMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_null"))
			it.UpdatedAtNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin"))
			it.CreatedAtMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax"))
			it.CreatedAtMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_ne"))
			it.CreatedAtNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_ne"))
			it.CreatedAtMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_ne"))
			it.CreatedAtMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_gt"))
			it.CreatedAtGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_gt"))
			it.CreatedAtMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_gt"))
			it.CreatedAtMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_lt"))
			it.CreatedAtLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_lt"))
			it.CreatedAtMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_lt"))
			it.CreatedAtMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_gte"))
			it.CreatedAtGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_gte"))
			it.CreatedAtMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_gte"))
			it.CreatedAtMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_lte"))
			it.CreatedAtLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_lte"))
			it.CreatedAtMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_lte"))
			it.CreatedAtMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_in"))
			it.CreatedAtIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_in"))
			it.CreatedAtMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_in"))
			it.CreatedAtMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_null"))
			it.CreatedAtNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy"))
			it.UpdatedBy, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin"))
			it.UpdatedByMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax"))
			it.UpdatedByMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_ne"))
			it.UpdatedByNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_ne"))
			it.UpdatedByMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_ne"))
			it.UpdatedByMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_gt"))
			it.UpdatedByGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_gt"))
			it.UpdatedByMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_gt"))
			it.UpdatedByMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_lt"))
			it.UpdatedByLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_lt"))
			it.UpdatedByMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_lt"))
			it.UpdatedByMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_gte"))
			it.UpdatedByGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_gte"))
			it.UpdatedByMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_gte"))
			it.UpdatedByMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_lte"))
			it.UpdatedByLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_lte"))
			it.UpdatedByMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_lte"))
			it.UpdatedByMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_in"))
			it.UpdatedByIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_in"))
			it.UpdatedByMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_in"))
			it.UpdatedByMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_null"))
			it.UpdatedByNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy"))
			it.CreatedBy, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin"))
			it.CreatedByMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax"))
			it.CreatedByMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_ne"))
			it.CreatedByNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_ne"))
			it.CreatedByMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_ne"))
			it.CreatedByMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_gt"))
			it.CreatedByGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_gt"))
			it.CreatedByMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_gt"))
			it.CreatedByMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_lt"))
			it.CreatedByLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_lt"))
			it.CreatedByMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_lt"))
			it.CreatedByMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_gte"))
			it.CreatedByGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_gte"))
			it.CreatedByMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_gte"))
			it.CreatedByMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_lte"))
			it.CreatedByLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_lte"))
			it.CreatedByMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_lte"))
			it.CreatedByMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_in"))
			it.CreatedByIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_in"))
			it.CreatedByMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_in"))
			it.CreatedByMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_null"))
			it.CreatedByNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "employees":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("employees"))
			it.Employees, err = ec.unmarshalOUserFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterType(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputCompanySortType(ctx context.Context, obj interface{}) (CompanySortType, error) {
	var it CompanySortType
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin"))
			it.IDMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax"))
			it.IDMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			it.Name, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin"))
			it.NameMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax"))
			it.NameMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryId":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryId"))
			it.CountryID, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMin"))
			it.CountryIDMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "countryIdMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("countryIdMax"))
			it.CountryIDMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt"))
			it.UpdatedAt, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin"))
			it.UpdatedAtMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax"))
			it.UpdatedAtMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin"))
			it.CreatedAtMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax"))
			it.CreatedAtMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy"))
			it.UpdatedBy, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin"))
			it.UpdatedByMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax"))
			it.UpdatedByMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy"))
			it.CreatedBy, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin"))
			it.CreatedByMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax"))
			it.CreatedByMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "employeesIds":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("employeesIds"))
			it.EmployeesIds, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "employeesIdsMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("employeesIdsMin"))
			it.EmployeesIdsMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "employeesIdsMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("employeesIdsMax"))
			it.EmployeesIdsMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "employees":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("employees"))
			it.Employees, err = ec.unmarshalOUserSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserSortType(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputPlainEntityFilterType(ctx context.Context, obj interface{}) (PlainEntityFilterType, error) {
	var it PlainEntityFilterType
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "AND":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("AND"))
			it.And, err = ec.unmarshalOPlainEntityFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityFilterTypeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "OR":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("OR"))
			it.Or, err = ec.unmarshalOPlainEntityFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityFilterTypeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin"))
			it.IDMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax"))
			it.IDMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_ne"))
			it.IDNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_ne"))
			it.IDMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_ne"))
			it.IDMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_gt"))
			it.IDGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_gt"))
			it.IDMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_gt"))
			it.IDMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_lt"))
			it.IDLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_lt"))
			it.IDMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_lt"))
			it.IDMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_gte"))
			it.IDGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_gte"))
			it.IDMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_gte"))
			it.IDMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_lte"))
			it.IDLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_lte"))
			it.IDMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_lte"))
			it.IDMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_in"))
			it.IDIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_in"))
			it.IDMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_in"))
			it.IDMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_null"))
			it.IDNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "date":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("date"))
			it.Date, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMin"))
			it.DateMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMax"))
			it.DateMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "date_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("date_ne"))
			it.DateNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMin_ne"))
			it.DateMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMax_ne"))
			it.DateMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "date_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("date_gt"))
			it.DateGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMin_gt"))
			it.DateMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMax_gt"))
			it.DateMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "date_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("date_lt"))
			it.DateLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMin_lt"))
			it.DateMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMax_lt"))
			it.DateMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "date_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("date_gte"))
			it.DateGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMin_gte"))
			it.DateMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMax_gte"))
			it.DateMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "date_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("date_lte"))
			it.DateLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMin_lte"))
			it.DateMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMax_lte"))
			it.DateMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "date_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("date_in"))
			it.DateIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMin_in"))
			it.DateMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMax_in"))
			it.DateMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "date_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("date_null"))
			it.DateNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "text":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text"))
			it.Text, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin"))
			it.TextMin, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax"))
			it.TextMax, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "text_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text_ne"))
			it.TextNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin_ne"))
			it.TextMinNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax_ne"))
			it.TextMaxNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "text_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text_gt"))
			it.TextGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin_gt"))
			it.TextMinGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax_gt"))
			it.TextMaxGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "text_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text_lt"))
			it.TextLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin_lt"))
			it.TextMinLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax_lt"))
			it.TextMaxLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "text_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text_gte"))
			it.TextGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin_gte"))
			it.TextMinGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax_gte"))
			it.TextMaxGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "text_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text_lte"))
			it.TextLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin_lte"))
			it.TextMinLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax_lte"))
			it.TextMaxLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "text_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text_in"))
			it.TextIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin_in"))
			it.TextMinIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax_in"))
			it.TextMaxIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "text_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text_like"))
			it.TextLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin_like"))
			it.TextMinLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax_like"))
			it.TextMaxLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "text_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text_prefix"))
			it.TextPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin_prefix"))
			it.TextMinPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax_prefix"))
			it.TextMaxPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "text_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text_suffix"))
			it.TextSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin_suffix"))
			it.TextMinSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax_suffix"))
			it.TextMaxSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "text_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text_null"))
			it.TextNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt"))
			it.UpdatedAt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin"))
			it.UpdatedAtMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax"))
			it.UpdatedAtMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_ne"))
			it.UpdatedAtNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_ne"))
			it.UpdatedAtMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_ne"))
			it.UpdatedAtMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_gt"))
			it.UpdatedAtGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_gt"))
			it.UpdatedAtMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_gt"))
			it.UpdatedAtMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_lt"))
			it.UpdatedAtLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_lt"))
			it.UpdatedAtMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_lt"))
			it.UpdatedAtMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_gte"))
			it.UpdatedAtGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_gte"))
			it.UpdatedAtMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_gte"))
			it.UpdatedAtMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_lte"))
			it.UpdatedAtLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_lte"))
			it.UpdatedAtMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_lte"))
			it.UpdatedAtMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_in"))
			it.UpdatedAtIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_in"))
			it.UpdatedAtMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_in"))
			it.UpdatedAtMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_null"))
			it.UpdatedAtNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin"))
			it.CreatedAtMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax"))
			it.CreatedAtMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_ne"))
			it.CreatedAtNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_ne"))
			it.CreatedAtMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_ne"))
			it.CreatedAtMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_gt"))
			it.CreatedAtGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_gt"))
			it.CreatedAtMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_gt"))
			it.CreatedAtMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_lt"))
			it.CreatedAtLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_lt"))
			it.CreatedAtMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_lt"))
			it.CreatedAtMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_gte"))
			it.CreatedAtGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_gte"))
			it.CreatedAtMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_gte"))
			it.CreatedAtMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_lte"))
			it.CreatedAtLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_lte"))
			it.CreatedAtMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_lte"))
			it.CreatedAtMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_in"))
			it.CreatedAtIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_in"))
			it.CreatedAtMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_in"))
			it.CreatedAtMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_null"))
			it.CreatedAtNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy"))
			it.UpdatedBy, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin"))
			it.UpdatedByMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax"))
			it.UpdatedByMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_ne"))
			it.UpdatedByNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_ne"))
			it.UpdatedByMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_ne"))
			it.UpdatedByMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_gt"))
			it.UpdatedByGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_gt"))
			it.UpdatedByMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_gt"))
			it.UpdatedByMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_lt"))
			it.UpdatedByLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_lt"))
			it.UpdatedByMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_lt"))
			it.UpdatedByMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_gte"))
			it.UpdatedByGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_gte"))
			it.UpdatedByMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_gte"))
			it.UpdatedByMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_lte"))
			it.UpdatedByLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_lte"))
			it.UpdatedByMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_lte"))
			it.UpdatedByMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_in"))
			it.UpdatedByIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_in"))
			it.UpdatedByMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_in"))
			it.UpdatedByMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_null"))
			it.UpdatedByNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy"))
			it.CreatedBy, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin"))
			it.CreatedByMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax"))
			it.CreatedByMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_ne"))
			it.CreatedByNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_ne"))
			it.CreatedByMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_ne"))
			it.CreatedByMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_gt"))
			it.CreatedByGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_gt"))
			it.CreatedByMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_gt"))
			it.CreatedByMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_lt"))
			it.CreatedByLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_lt"))
			it.CreatedByMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_lt"))
			it.CreatedByMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_gte"))
			it.CreatedByGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_gte"))
			it.CreatedByMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_gte"))
			it.CreatedByMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_lte"))
			it.CreatedByLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_lte"))
			it.CreatedByMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_lte"))
			it.CreatedByMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_in"))
			it.CreatedByIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_in"))
			it.CreatedByMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_in"))
			it.CreatedByMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_null"))
			it.CreatedByNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputPlainEntitySortType(ctx context.Context, obj interface{}) (PlainEntitySortType, error) {
	var it PlainEntitySortType
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin"))
			it.IDMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax"))
			it.IDMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "date":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("date"))
			it.Date, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMin"))
			it.DateMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "dateMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dateMax"))
			it.DateMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "text":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text"))
			it.Text, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMin"))
			it.TextMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "textMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textMax"))
			it.TextMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt"))
			it.UpdatedAt, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin"))
			it.UpdatedAtMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax"))
			it.UpdatedAtMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin"))
			it.CreatedAtMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax"))
			it.CreatedAtMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy"))
			it.UpdatedBy, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin"))
			it.UpdatedByMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax"))
			it.UpdatedByMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy"))
			it.CreatedBy, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin"))
			it.CreatedByMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax"))
			it.CreatedByMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTaskCategoryFilterType(ctx context.Context, obj interface{}) (TaskCategoryFilterType, error) {
	var it TaskCategoryFilterType
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "AND":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("AND"))
			it.And, err = ec.unmarshalOTaskCategoryFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryFilterTypeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "OR":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("OR"))
			it.Or, err = ec.unmarshalOTaskCategoryFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryFilterTypeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin"))
			it.IDMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax"))
			it.IDMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_ne"))
			it.IDNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_ne"))
			it.IDMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_ne"))
			it.IDMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_gt"))
			it.IDGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_gt"))
			it.IDMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_gt"))
			it.IDMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_lt"))
			it.IDLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_lt"))
			it.IDMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_lt"))
			it.IDMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_gte"))
			it.IDGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_gte"))
			it.IDMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_gte"))
			it.IDMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_lte"))
			it.IDLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_lte"))
			it.IDMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_lte"))
			it.IDMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_in"))
			it.IDIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_in"))
			it.IDMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_in"))
			it.IDMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_null"))
			it.IDNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			it.Name, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin"))
			it.NameMin, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax"))
			it.NameMax, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_ne"))
			it.NameNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_ne"))
			it.NameMinNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_ne"))
			it.NameMaxNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_gt"))
			it.NameGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_gt"))
			it.NameMinGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_gt"))
			it.NameMaxGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_lt"))
			it.NameLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_lt"))
			it.NameMinLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_lt"))
			it.NameMaxLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_gte"))
			it.NameGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_gte"))
			it.NameMinGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_gte"))
			it.NameMaxGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_lte"))
			it.NameLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_lte"))
			it.NameMinLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_lte"))
			it.NameMaxLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_in"))
			it.NameIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_in"))
			it.NameMinIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_in"))
			it.NameMaxIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_like"))
			it.NameLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_like"))
			it.NameMinLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_like"))
			it.NameMaxLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_prefix"))
			it.NamePrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_prefix"))
			it.NameMinPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_prefix"))
			it.NameMaxPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_suffix"))
			it.NameSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin_suffix"))
			it.NameMinSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax_suffix"))
			it.NameMaxSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "name_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name_null"))
			it.NameNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt"))
			it.UpdatedAt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin"))
			it.UpdatedAtMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax"))
			it.UpdatedAtMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_ne"))
			it.UpdatedAtNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_ne"))
			it.UpdatedAtMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_ne"))
			it.UpdatedAtMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_gt"))
			it.UpdatedAtGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_gt"))
			it.UpdatedAtMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_gt"))
			it.UpdatedAtMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_lt"))
			it.UpdatedAtLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_lt"))
			it.UpdatedAtMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_lt"))
			it.UpdatedAtMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_gte"))
			it.UpdatedAtGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_gte"))
			it.UpdatedAtMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_gte"))
			it.UpdatedAtMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_lte"))
			it.UpdatedAtLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_lte"))
			it.UpdatedAtMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_lte"))
			it.UpdatedAtMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_in"))
			it.UpdatedAtIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_in"))
			it.UpdatedAtMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_in"))
			it.UpdatedAtMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_null"))
			it.UpdatedAtNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin"))
			it.CreatedAtMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax"))
			it.CreatedAtMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_ne"))
			it.CreatedAtNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_ne"))
			it.CreatedAtMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_ne"))
			it.CreatedAtMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_gt"))
			it.CreatedAtGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_gt"))
			it.CreatedAtMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_gt"))
			it.CreatedAtMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_lt"))
			it.CreatedAtLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_lt"))
			it.CreatedAtMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_lt"))
			it.CreatedAtMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_gte"))
			it.CreatedAtGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_gte"))
			it.CreatedAtMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_gte"))
			it.CreatedAtMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_lte"))
			it.CreatedAtLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_lte"))
			it.CreatedAtMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_lte"))
			it.CreatedAtMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_in"))
			it.CreatedAtIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_in"))
			it.CreatedAtMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_in"))
			it.CreatedAtMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_null"))
			it.CreatedAtNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy"))
			it.UpdatedBy, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin"))
			it.UpdatedByMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax"))
			it.UpdatedByMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_ne"))
			it.UpdatedByNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_ne"))
			it.UpdatedByMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_ne"))
			it.UpdatedByMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_gt"))
			it.UpdatedByGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_gt"))
			it.UpdatedByMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_gt"))
			it.UpdatedByMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_lt"))
			it.UpdatedByLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_lt"))
			it.UpdatedByMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_lt"))
			it.UpdatedByMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_gte"))
			it.UpdatedByGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_gte"))
			it.UpdatedByMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_gte"))
			it.UpdatedByMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_lte"))
			it.UpdatedByLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_lte"))
			it.UpdatedByMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_lte"))
			it.UpdatedByMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_in"))
			it.UpdatedByIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_in"))
			it.UpdatedByMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_in"))
			it.UpdatedByMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_null"))
			it.UpdatedByNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy"))
			it.CreatedBy, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin"))
			it.CreatedByMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax"))
			it.CreatedByMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_ne"))
			it.CreatedByNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_ne"))
			it.CreatedByMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_ne"))
			it.CreatedByMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_gt"))
			it.CreatedByGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_gt"))
			it.CreatedByMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_gt"))
			it.CreatedByMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_lt"))
			it.CreatedByLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_lt"))
			it.CreatedByMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_lt"))
			it.CreatedByMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_gte"))
			it.CreatedByGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_gte"))
			it.CreatedByMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_gte"))
			it.CreatedByMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_lte"))
			it.CreatedByLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_lte"))
			it.CreatedByMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_lte"))
			it.CreatedByMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_in"))
			it.CreatedByIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_in"))
			it.CreatedByMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_in"))
			it.CreatedByMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_null"))
			it.CreatedByNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "tasks":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tasks"))
			it.Tasks, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTaskCategorySortType(ctx context.Context, obj interface{}) (TaskCategorySortType, error) {
	var it TaskCategorySortType
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin"))
			it.IDMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax"))
			it.IDMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "name":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			it.Name, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMin"))
			it.NameMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "nameMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameMax"))
			it.NameMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt"))
			it.UpdatedAt, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin"))
			it.UpdatedAtMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax"))
			it.UpdatedAtMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin"))
			it.CreatedAtMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax"))
			it.CreatedAtMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy"))
			it.UpdatedBy, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin"))
			it.UpdatedByMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax"))
			it.UpdatedByMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy"))
			it.CreatedBy, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin"))
			it.CreatedByMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax"))
			it.CreatedByMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "tasksIds":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tasksIds"))
			it.TasksIds, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "tasksIdsMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tasksIdsMin"))
			it.TasksIdsMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "tasksIdsMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tasksIdsMax"))
			it.TasksIdsMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "tasks":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tasks"))
			it.Tasks, err = ec.unmarshalOTaskSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortType(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTaskFilterType(ctx context.Context, obj interface{}) (TaskFilterType, error) {
	var it TaskFilterType
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "AND":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("AND"))
			it.And, err = ec.unmarshalOTaskFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterTypeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "OR":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("OR"))
			it.Or, err = ec.unmarshalOTaskFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterTypeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin"))
			it.IDMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax"))
			it.IDMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_ne"))
			it.IDNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_ne"))
			it.IDMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_ne"))
			it.IDMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_gt"))
			it.IDGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_gt"))
			it.IDMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_gt"))
			it.IDMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_lt"))
			it.IDLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_lt"))
			it.IDMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_lt"))
			it.IDMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_gte"))
			it.IDGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_gte"))
			it.IDMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_gte"))
			it.IDMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_lte"))
			it.IDLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_lte"))
			it.IDMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_lte"))
			it.IDMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_in"))
			it.IDIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_in"))
			it.IDMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_in"))
			it.IDMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_null"))
			it.IDNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "title":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
			it.Title, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin"))
			it.TitleMin, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax"))
			it.TitleMax, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "title_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title_ne"))
			it.TitleNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin_ne"))
			it.TitleMinNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax_ne"))
			it.TitleMaxNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "title_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title_gt"))
			it.TitleGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin_gt"))
			it.TitleMinGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax_gt"))
			it.TitleMaxGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "title_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title_lt"))
			it.TitleLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin_lt"))
			it.TitleMinLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax_lt"))
			it.TitleMaxLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "title_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title_gte"))
			it.TitleGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin_gte"))
			it.TitleMinGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax_gte"))
			it.TitleMaxGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "title_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title_lte"))
			it.TitleLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin_lte"))
			it.TitleMinLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax_lte"))
			it.TitleMaxLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "title_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title_in"))
			it.TitleIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin_in"))
			it.TitleMinIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax_in"))
			it.TitleMaxIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "title_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title_like"))
			it.TitleLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin_like"))
			it.TitleMinLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax_like"))
			it.TitleMaxLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "title_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title_prefix"))
			it.TitlePrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin_prefix"))
			it.TitleMinPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax_prefix"))
			it.TitleMaxPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "title_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title_suffix"))
			it.TitleSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin_suffix"))
			it.TitleMinSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax_suffix"))
			it.TitleMaxSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "title_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title_null"))
			it.TitleNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completed":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completed"))
			it.Completed, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMin"))
			it.CompletedMin, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMax"))
			it.CompletedMax, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completed_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completed_ne"))
			it.CompletedNe, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMin_ne"))
			it.CompletedMinNe, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMax_ne"))
			it.CompletedMaxNe, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completed_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completed_gt"))
			it.CompletedGt, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMin_gt"))
			it.CompletedMinGt, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMax_gt"))
			it.CompletedMaxGt, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completed_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completed_lt"))
			it.CompletedLt, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMin_lt"))
			it.CompletedMinLt, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMax_lt"))
			it.CompletedMaxLt, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completed_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completed_gte"))
			it.CompletedGte, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMin_gte"))
			it.CompletedMinGte, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMax_gte"))
			it.CompletedMaxGte, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completed_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completed_lte"))
			it.CompletedLte, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMin_lte"))
			it.CompletedMinLte, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMax_lte"))
			it.CompletedMaxLte, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "completed_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completed_in"))
			it.CompletedIn, err = ec.unmarshalOBoolean2ᚕboolᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMin_in"))
			it.CompletedMinIn, err = ec.unmarshalOBoolean2ᚕboolᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMax_in"))
			it.CompletedMaxIn, err = ec.unmarshalOBoolean2ᚕboolᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "completed_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completed_null"))
			it.CompletedNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "state":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state"))
			it.State, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMin"))
			it.StateMin, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMax"))
			it.StateMax, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "state_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state_ne"))
			it.StateNe, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMin_ne"))
			it.StateMinNe, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMax_ne"))
			it.StateMaxNe, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "state_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state_gt"))
			it.StateGt, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMin_gt"))
			it.StateMinGt, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMax_gt"))
			it.StateMaxGt, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "state_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state_lt"))
			it.StateLt, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMin_lt"))
			it.StateMinLt, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMax_lt"))
			it.StateMaxLt, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "state_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state_gte"))
			it.StateGte, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMin_gte"))
			it.StateMinGte, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMax_gte"))
			it.StateMaxGte, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "state_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state_lte"))
			it.StateLte, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMin_lte"))
			it.StateMinLte, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMax_lte"))
			it.StateMaxLte, err = ec.unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, v)
			if err != nil {
				return it, err
			}
		case "state_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state_in"))
			it.StateIn, err = ec.unmarshalOTaskState2ᚕgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskStateᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMin_in"))
			it.StateMinIn, err = ec.unmarshalOTaskState2ᚕgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskStateᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMax_in"))
			it.StateMaxIn, err = ec.unmarshalOTaskState2ᚕgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskStateᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "state_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state_null"))
			it.StateNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDate":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDate"))
			it.DueDate, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMin"))
			it.DueDateMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMax"))
			it.DueDateMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDate_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDate_ne"))
			it.DueDateNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMin_ne"))
			it.DueDateMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMax_ne"))
			it.DueDateMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDate_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDate_gt"))
			it.DueDateGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMin_gt"))
			it.DueDateMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMax_gt"))
			it.DueDateMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDate_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDate_lt"))
			it.DueDateLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMin_lt"))
			it.DueDateMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMax_lt"))
			it.DueDateMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDate_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDate_gte"))
			it.DueDateGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMin_gte"))
			it.DueDateMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMax_gte"))
			it.DueDateMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDate_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDate_lte"))
			it.DueDateLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMin_lte"))
			it.DueDateMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMax_lte"))
			it.DueDateMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDate_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDate_in"))
			it.DueDateIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMin_in"))
			it.DueDateMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMax_in"))
			it.DueDateMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDate_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDate_null"))
			it.DueDateNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeId":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeId"))
			it.AssigneeID, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMin"))
			it.AssigneeIDMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMax"))
			it.AssigneeIDMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeId_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeId_ne"))
			it.AssigneeIDNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMin_ne"))
			it.AssigneeIDMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMax_ne"))
			it.AssigneeIDMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeId_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeId_gt"))
			it.AssigneeIDGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMin_gt"))
			it.AssigneeIDMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMax_gt"))
			it.AssigneeIDMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeId_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeId_lt"))
			it.AssigneeIDLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMin_lt"))
			it.AssigneeIDMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMax_lt"))
			it.AssigneeIDMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeId_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeId_gte"))
			it.AssigneeIDGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMin_gte"))
			it.AssigneeIDMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMax_gte"))
			it.AssigneeIDMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeId_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeId_lte"))
			it.AssigneeIDLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMin_lte"))
			it.AssigneeIDMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMax_lte"))
			it.AssigneeIDMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeId_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeId_in"))
			it.AssigneeIDIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMin_in"))
			it.AssigneeIDMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMax_in"))
			it.AssigneeIDMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeId_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeId_null"))
			it.AssigneeIDNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerId":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerId"))
			it.OwnerID, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMin"))
			it.OwnerIDMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMax"))
			it.OwnerIDMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerId_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerId_ne"))
			it.OwnerIDNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMin_ne"))
			it.OwnerIDMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMax_ne"))
			it.OwnerIDMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerId_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerId_gt"))
			it.OwnerIDGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMin_gt"))
			it.OwnerIDMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMax_gt"))
			it.OwnerIDMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerId_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerId_lt"))
			it.OwnerIDLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMin_lt"))
			it.OwnerIDMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMax_lt"))
			it.OwnerIDMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerId_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerId_gte"))
			it.OwnerIDGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMin_gte"))
			it.OwnerIDMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMax_gte"))
			it.OwnerIDMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerId_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerId_lte"))
			it.OwnerIDLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMin_lte"))
			it.OwnerIDMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMax_lte"))
			it.OwnerIDMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerId_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerId_in"))
			it.OwnerIDIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMin_in"))
			it.OwnerIDMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMax_in"))
			it.OwnerIDMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerId_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerId_null"))
			it.OwnerIDNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskId":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskId"))
			it.ParentTaskID, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMin"))
			it.ParentTaskIDMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMax"))
			it.ParentTaskIDMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskId_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskId_ne"))
			it.ParentTaskIDNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMin_ne"))
			it.ParentTaskIDMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMax_ne"))
			it.ParentTaskIDMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskId_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskId_gt"))
			it.ParentTaskIDGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMin_gt"))
			it.ParentTaskIDMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMax_gt"))
			it.ParentTaskIDMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskId_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskId_lt"))
			it.ParentTaskIDLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMin_lt"))
			it.ParentTaskIDMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMax_lt"))
			it.ParentTaskIDMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskId_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskId_gte"))
			it.ParentTaskIDGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMin_gte"))
			it.ParentTaskIDMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMax_gte"))
			it.ParentTaskIDMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskId_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskId_lte"))
			it.ParentTaskIDLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMin_lte"))
			it.ParentTaskIDMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMax_lte"))
			it.ParentTaskIDMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskId_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskId_in"))
			it.ParentTaskIDIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMin_in"))
			it.ParentTaskIDMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMax_in"))
			it.ParentTaskIDMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskId_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskId_null"))
			it.ParentTaskIDNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt"))
			it.UpdatedAt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin"))
			it.UpdatedAtMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax"))
			it.UpdatedAtMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_ne"))
			it.UpdatedAtNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_ne"))
			it.UpdatedAtMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_ne"))
			it.UpdatedAtMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_gt"))
			it.UpdatedAtGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_gt"))
			it.UpdatedAtMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_gt"))
			it.UpdatedAtMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_lt"))
			it.UpdatedAtLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_lt"))
			it.UpdatedAtMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_lt"))
			it.UpdatedAtMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_gte"))
			it.UpdatedAtGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_gte"))
			it.UpdatedAtMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_gte"))
			it.UpdatedAtMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_lte"))
			it.UpdatedAtLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_lte"))
			it.UpdatedAtMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_lte"))
			it.UpdatedAtMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_in"))
			it.UpdatedAtIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_in"))
			it.UpdatedAtMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_in"))
			it.UpdatedAtMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_null"))
			it.UpdatedAtNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin"))
			it.CreatedAtMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax"))
			it.CreatedAtMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_ne"))
			it.CreatedAtNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_ne"))
			it.CreatedAtMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_ne"))
			it.CreatedAtMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_gt"))
			it.CreatedAtGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_gt"))
			it.CreatedAtMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_gt"))
			it.CreatedAtMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_lt"))
			it.CreatedAtLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_lt"))
			it.CreatedAtMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_lt"))
			it.CreatedAtMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_gte"))
			it.CreatedAtGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_gte"))
			it.CreatedAtMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_gte"))
			it.CreatedAtMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_lte"))
			it.CreatedAtLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_lte"))
			it.CreatedAtMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_lte"))
			it.CreatedAtMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_in"))
			it.CreatedAtIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_in"))
			it.CreatedAtMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_in"))
			it.CreatedAtMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_null"))
			it.CreatedAtNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy"))
			it.UpdatedBy, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin"))
			it.UpdatedByMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax"))
			it.UpdatedByMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_ne"))
			it.UpdatedByNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_ne"))
			it.UpdatedByMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_ne"))
			it.UpdatedByMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_gt"))
			it.UpdatedByGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_gt"))
			it.UpdatedByMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_gt"))
			it.UpdatedByMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_lt"))
			it.UpdatedByLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_lt"))
			it.UpdatedByMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_lt"))
			it.UpdatedByMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_gte"))
			it.UpdatedByGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_gte"))
			it.UpdatedByMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_gte"))
			it.UpdatedByMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_lte"))
			it.UpdatedByLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_lte"))
			it.UpdatedByMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_lte"))
			it.UpdatedByMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_in"))
			it.UpdatedByIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_in"))
			it.UpdatedByMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_in"))
			it.UpdatedByMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_null"))
			it.UpdatedByNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy"))
			it.CreatedBy, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin"))
			it.CreatedByMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax"))
			it.CreatedByMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_ne"))
			it.CreatedByNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_ne"))
			it.CreatedByMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_ne"))
			it.CreatedByMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_gt"))
			it.CreatedByGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_gt"))
			it.CreatedByMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_gt"))
			it.CreatedByMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_lt"))
			it.CreatedByLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_lt"))
			it.CreatedByMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_lt"))
			it.CreatedByMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_gte"))
			it.CreatedByGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_gte"))
			it.CreatedByMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_gte"))
			it.CreatedByMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_lte"))
			it.CreatedByLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_lte"))
			it.CreatedByMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_lte"))
			it.CreatedByMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_in"))
			it.CreatedByIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_in"))
			it.CreatedByMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_in"))
			it.CreatedByMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_null"))
			it.CreatedByNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "assignee":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assignee"))
			it.Assignee, err = ec.unmarshalOUserFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterType(ctx, v)
			if err != nil {
				return it, err
			}
		case "owner":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner"))
			it.Owner, err = ec.unmarshalOUserFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterType(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTask":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTask"))
			it.ParentTask, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, v)
			if err != nil {
				return it, err
			}
		case "subtasks":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("subtasks"))
			it.Subtasks, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, v)
			if err != nil {
				return it, err
			}
		case "categories":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categories"))
			it.Categories, err = ec.unmarshalOTaskCategoryFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryFilterType(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTaskMetaInput(ctx context.Context, obj interface{}) (TaskMetaInput, error) {
	var it TaskMetaInput
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "key":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("key"))
			it.Key, err = ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
		case "value":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value"))
			it.Value, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputTaskSortType(ctx context.Context, obj interface{}) (TaskSortType, error) {
	var it TaskSortType
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin"))
			it.IDMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax"))
			it.IDMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "title":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
			it.Title, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMin"))
			it.TitleMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "titleMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("titleMax"))
			it.TitleMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "completed":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completed"))
			it.Completed, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMin"))
			it.CompletedMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "completedMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("completedMax"))
			it.CompletedMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "state":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state"))
			it.State, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMin"))
			it.StateMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "stateMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stateMax"))
			it.StateMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDate":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDate"))
			it.DueDate, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMin"))
			it.DueDateMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "dueDateMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("dueDateMax"))
			it.DueDateMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "metas":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("metas"))
			it.Metas, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "metasMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("metasMin"))
			it.MetasMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "metasMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("metasMax"))
			it.MetasMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "meta":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("meta"))
			it.Meta, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "metaMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("metaMin"))
			it.MetaMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "metaMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("metaMax"))
			it.MetaMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeId":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeId"))
			it.AssigneeID, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMin"))
			it.AssigneeIDMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "assigneeIdMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assigneeIdMax"))
			it.AssigneeIDMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerId":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerId"))
			it.OwnerID, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMin"))
			it.OwnerIDMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "ownerIdMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIdMax"))
			it.OwnerIDMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskId":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskId"))
			it.ParentTaskID, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMin"))
			it.ParentTaskIDMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTaskIdMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTaskIdMax"))
			it.ParentTaskIDMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt"))
			it.UpdatedAt, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin"))
			it.UpdatedAtMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax"))
			it.UpdatedAtMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin"))
			it.CreatedAtMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax"))
			it.CreatedAtMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy"))
			it.UpdatedBy, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin"))
			it.UpdatedByMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax"))
			it.UpdatedByMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy"))
			it.CreatedBy, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin"))
			it.CreatedByMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax"))
			it.CreatedByMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "subtasksIds":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("subtasksIds"))
			it.SubtasksIds, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "subtasksIdsMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("subtasksIdsMin"))
			it.SubtasksIdsMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "subtasksIdsMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("subtasksIdsMax"))
			it.SubtasksIdsMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "categoriesIds":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoriesIds"))
			it.CategoriesIds, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "categoriesIdsMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoriesIdsMin"))
			it.CategoriesIdsMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "categoriesIdsMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoriesIdsMax"))
			it.CategoriesIdsMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "assignee":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("assignee"))
			it.Assignee, err = ec.unmarshalOUserSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "owner":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner"))
			it.Owner, err = ec.unmarshalOUserSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "parentTask":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("parentTask"))
			it.ParentTask, err = ec.unmarshalOTaskSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "subtasks":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("subtasks"))
			it.Subtasks, err = ec.unmarshalOTaskSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "categories":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categories"))
			it.Categories, err = ec.unmarshalOTaskCategorySortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategorySortType(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputUserFilterType(ctx context.Context, obj interface{}) (UserFilterType, error) {
	var it UserFilterType
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "AND":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("AND"))
			it.And, err = ec.unmarshalOUserFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterTypeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "OR":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("OR"))
			it.Or, err = ec.unmarshalOUserFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterTypeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin"))
			it.IDMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax"))
			it.IDMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_ne"))
			it.IDNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_ne"))
			it.IDMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_ne"))
			it.IDMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_gt"))
			it.IDGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_gt"))
			it.IDMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_gt"))
			it.IDMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_lt"))
			it.IDLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_lt"))
			it.IDMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_lt"))
			it.IDMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_gte"))
			it.IDGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_gte"))
			it.IDMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_gte"))
			it.IDMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_lte"))
			it.IDLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_lte"))
			it.IDMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_lte"))
			it.IDMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_in"))
			it.IDIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin_in"))
			it.IDMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax_in"))
			it.IDMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "id_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id_null"))
			it.IDNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "code":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code"))
			it.Code, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMin"))
			it.CodeMin, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMax"))
			it.CodeMax, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeAvg":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeAvg"))
			it.CodeAvg, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "code_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code_ne"))
			it.CodeNe, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMin_ne"))
			it.CodeMinNe, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMax_ne"))
			it.CodeMaxNe, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeAvg_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeAvg_ne"))
			it.CodeAvgNe, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "code_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code_gt"))
			it.CodeGt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMin_gt"))
			it.CodeMinGt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMax_gt"))
			it.CodeMaxGt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeAvg_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeAvg_gt"))
			it.CodeAvgGt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "code_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code_lt"))
			it.CodeLt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMin_lt"))
			it.CodeMinLt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMax_lt"))
			it.CodeMaxLt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeAvg_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeAvg_lt"))
			it.CodeAvgLt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "code_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code_gte"))
			it.CodeGte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMin_gte"))
			it.CodeMinGte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMax_gte"))
			it.CodeMaxGte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeAvg_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeAvg_gte"))
			it.CodeAvgGte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "code_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code_lte"))
			it.CodeLte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMin_lte"))
			it.CodeMinLte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMax_lte"))
			it.CodeMaxLte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeAvg_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeAvg_lte"))
			it.CodeAvgLte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "code_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code_in"))
			it.CodeIn, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMin_in"))
			it.CodeMinIn, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMax_in"))
			it.CodeMaxIn, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeAvg_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeAvg_in"))
			it.CodeAvgIn, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "code_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code_null"))
			it.CodeNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "email":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email"))
			it.Email, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin"))
			it.EmailMin, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax"))
			it.EmailMax, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "email_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email_ne"))
			it.EmailNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin_ne"))
			it.EmailMinNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax_ne"))
			it.EmailMaxNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "email_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email_gt"))
			it.EmailGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin_gt"))
			it.EmailMinGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax_gt"))
			it.EmailMaxGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "email_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email_lt"))
			it.EmailLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin_lt"))
			it.EmailMinLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax_lt"))
			it.EmailMaxLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "email_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email_gte"))
			it.EmailGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin_gte"))
			it.EmailMinGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax_gte"))
			it.EmailMaxGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "email_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email_lte"))
			it.EmailLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin_lte"))
			it.EmailMinLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax_lte"))
			it.EmailMaxLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "email_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email_in"))
			it.EmailIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin_in"))
			it.EmailMinIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax_in"))
			it.EmailMaxIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "email_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email_like"))
			it.EmailLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin_like"))
			it.EmailMinLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax_like"))
			it.EmailMaxLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "email_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email_prefix"))
			it.EmailPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin_prefix"))
			it.EmailMinPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax_prefix"))
			it.EmailMaxPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "email_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email_suffix"))
			it.EmailSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin_suffix"))
			it.EmailMinSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax_suffix"))
			it.EmailMaxSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "email_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email_null"))
			it.EmailNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName"))
			it.FirstName, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin"))
			it.FirstNameMin, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax"))
			it.FirstNameMax, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName_ne"))
			it.FirstNameNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin_ne"))
			it.FirstNameMinNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax_ne"))
			it.FirstNameMaxNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName_gt"))
			it.FirstNameGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin_gt"))
			it.FirstNameMinGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax_gt"))
			it.FirstNameMaxGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName_lt"))
			it.FirstNameLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin_lt"))
			it.FirstNameMinLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax_lt"))
			it.FirstNameMaxLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName_gte"))
			it.FirstNameGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin_gte"))
			it.FirstNameMinGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax_gte"))
			it.FirstNameMaxGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName_lte"))
			it.FirstNameLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin_lte"))
			it.FirstNameMinLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax_lte"))
			it.FirstNameMaxLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName_in"))
			it.FirstNameIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin_in"))
			it.FirstNameMinIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax_in"))
			it.FirstNameMaxIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName_like"))
			it.FirstNameLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin_like"))
			it.FirstNameMinLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax_like"))
			it.FirstNameMaxLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName_prefix"))
			it.FirstNamePrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin_prefix"))
			it.FirstNameMinPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax_prefix"))
			it.FirstNameMaxPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName_suffix"))
			it.FirstNameSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin_suffix"))
			it.FirstNameMinSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax_suffix"))
			it.FirstNameMaxSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName_null"))
			it.FirstNameNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName"))
			it.LastName, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin"))
			it.LastNameMin, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax"))
			it.LastNameMax, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName_ne"))
			it.LastNameNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin_ne"))
			it.LastNameMinNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax_ne"))
			it.LastNameMaxNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName_gt"))
			it.LastNameGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin_gt"))
			it.LastNameMinGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax_gt"))
			it.LastNameMaxGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName_lt"))
			it.LastNameLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin_lt"))
			it.LastNameMinLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax_lt"))
			it.LastNameMaxLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName_gte"))
			it.LastNameGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin_gte"))
			it.LastNameMinGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax_gte"))
			it.LastNameMaxGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName_lte"))
			it.LastNameLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin_lte"))
			it.LastNameMinLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax_lte"))
			it.LastNameMaxLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName_in"))
			it.LastNameIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin_in"))
			it.LastNameMinIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax_in"))
			it.LastNameMaxIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName_like"))
			it.LastNameLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin_like"))
			it.LastNameMinLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax_like"))
			it.LastNameMaxLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName_prefix"))
			it.LastNamePrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin_prefix"))
			it.LastNameMinPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax_prefix"))
			it.LastNameMaxPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName_suffix"))
			it.LastNameSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin_suffix"))
			it.LastNameMinSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax_suffix"))
			it.LastNameMaxSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName_null"))
			it.LastNameNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw"))
			it.AddressRaw, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin"))
			it.AddressRawMin, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax"))
			it.AddressRawMax, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw_ne"))
			it.AddressRawNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin_ne"))
			it.AddressRawMinNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax_ne"))
			it.AddressRawMaxNe, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw_gt"))
			it.AddressRawGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin_gt"))
			it.AddressRawMinGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax_gt"))
			it.AddressRawMaxGt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw_lt"))
			it.AddressRawLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin_lt"))
			it.AddressRawMinLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax_lt"))
			it.AddressRawMaxLt, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw_gte"))
			it.AddressRawGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin_gte"))
			it.AddressRawMinGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax_gte"))
			it.AddressRawMaxGte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw_lte"))
			it.AddressRawLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin_lte"))
			it.AddressRawMinLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax_lte"))
			it.AddressRawMaxLte, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw_in"))
			it.AddressRawIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin_in"))
			it.AddressRawMinIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax_in"))
			it.AddressRawMaxIn, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw_like"))
			it.AddressRawLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin_like"))
			it.AddressRawMinLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax_like":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax_like"))
			it.AddressRawMaxLike, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw_prefix"))
			it.AddressRawPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin_prefix"))
			it.AddressRawMinPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax_prefix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax_prefix"))
			it.AddressRawMaxPrefix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw_suffix"))
			it.AddressRawSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin_suffix"))
			it.AddressRawMinSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax_suffix":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax_suffix"))
			it.AddressRawMaxSuffix, err = ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw_null"))
			it.AddressRawNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "salary":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salary"))
			it.Salary, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMin"))
			it.SalaryMin, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMax"))
			it.SalaryMax, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryAvg":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryAvg"))
			it.SalaryAvg, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salary_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salary_ne"))
			it.SalaryNe, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMin_ne"))
			it.SalaryMinNe, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMax_ne"))
			it.SalaryMaxNe, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryAvg_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryAvg_ne"))
			it.SalaryAvgNe, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salary_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salary_gt"))
			it.SalaryGt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMin_gt"))
			it.SalaryMinGt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMax_gt"))
			it.SalaryMaxGt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryAvg_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryAvg_gt"))
			it.SalaryAvgGt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salary_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salary_lt"))
			it.SalaryLt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMin_lt"))
			it.SalaryMinLt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMax_lt"))
			it.SalaryMaxLt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryAvg_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryAvg_lt"))
			it.SalaryAvgLt, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salary_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salary_gte"))
			it.SalaryGte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMin_gte"))
			it.SalaryMinGte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMax_gte"))
			it.SalaryMaxGte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryAvg_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryAvg_gte"))
			it.SalaryAvgGte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salary_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salary_lte"))
			it.SalaryLte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMin_lte"))
			it.SalaryMinLte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMax_lte"))
			it.SalaryMaxLte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryAvg_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryAvg_lte"))
			it.SalaryAvgLte, err = ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
		case "salary_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salary_in"))
			it.SalaryIn, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMin_in"))
			it.SalaryMinIn, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMax_in"))
			it.SalaryMaxIn, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryAvg_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryAvg_in"))
			it.SalaryAvgIn, err = ec.unmarshalOInt2ᚕintᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "salary_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salary_null"))
			it.SalaryNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt"))
			it.UpdatedAt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin"))
			it.UpdatedAtMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax"))
			it.UpdatedAtMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_ne"))
			it.UpdatedAtNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_ne"))
			it.UpdatedAtMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_ne"))
			it.UpdatedAtMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_gt"))
			it.UpdatedAtGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_gt"))
			it.UpdatedAtMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_gt"))
			it.UpdatedAtMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_lt"))
			it.UpdatedAtLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_lt"))
			it.UpdatedAtMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_lt"))
			it.UpdatedAtMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_gte"))
			it.UpdatedAtGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_gte"))
			it.UpdatedAtMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_gte"))
			it.UpdatedAtMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_lte"))
			it.UpdatedAtLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_lte"))
			it.UpdatedAtMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_lte"))
			it.UpdatedAtMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_in"))
			it.UpdatedAtIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin_in"))
			it.UpdatedAtMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax_in"))
			it.UpdatedAtMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt_null"))
			it.UpdatedAtNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin"))
			it.CreatedAtMin, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax"))
			it.CreatedAtMax, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_ne"))
			it.CreatedAtNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_ne"))
			it.CreatedAtMinNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_ne"))
			it.CreatedAtMaxNe, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_gt"))
			it.CreatedAtGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_gt"))
			it.CreatedAtMinGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_gt"))
			it.CreatedAtMaxGt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_lt"))
			it.CreatedAtLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_lt"))
			it.CreatedAtMinLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_lt"))
			it.CreatedAtMaxLt, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_gte"))
			it.CreatedAtGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_gte"))
			it.CreatedAtMinGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_gte"))
			it.CreatedAtMaxGte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_lte"))
			it.CreatedAtLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_lte"))
			it.CreatedAtMinLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_lte"))
			it.CreatedAtMaxLte, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_in"))
			it.CreatedAtIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin_in"))
			it.CreatedAtMinIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax_in"))
			it.CreatedAtMaxIn, err = ec.unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt_null"))
			it.CreatedAtNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy"))
			it.UpdatedBy, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin"))
			it.UpdatedByMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax"))
			it.UpdatedByMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_ne"))
			it.UpdatedByNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_ne"))
			it.UpdatedByMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_ne"))
			it.UpdatedByMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_gt"))
			it.UpdatedByGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_gt"))
			it.UpdatedByMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_gt"))
			it.UpdatedByMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_lt"))
			it.UpdatedByLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_lt"))
			it.UpdatedByMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_lt"))
			it.UpdatedByMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_gte"))
			it.UpdatedByGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_gte"))
			it.UpdatedByMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_gte"))
			it.UpdatedByMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_lte"))
			it.UpdatedByLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_lte"))
			it.UpdatedByMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_lte"))
			it.UpdatedByMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_in"))
			it.UpdatedByIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin_in"))
			it.UpdatedByMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax_in"))
			it.UpdatedByMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy_null"))
			it.UpdatedByNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy"))
			it.CreatedBy, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin"))
			it.CreatedByMin, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax"))
			it.CreatedByMax, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_ne"))
			it.CreatedByNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_ne"))
			it.CreatedByMinNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_ne":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_ne"))
			it.CreatedByMaxNe, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_gt"))
			it.CreatedByGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_gt"))
			it.CreatedByMinGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_gt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_gt"))
			it.CreatedByMaxGt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_lt"))
			it.CreatedByLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_lt"))
			it.CreatedByMinLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_lt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_lt"))
			it.CreatedByMaxLt, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_gte"))
			it.CreatedByGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_gte"))
			it.CreatedByMinGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_gte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_gte"))
			it.CreatedByMaxGte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_lte"))
			it.CreatedByLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_lte"))
			it.CreatedByMinLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_lte":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_lte"))
			it.CreatedByMaxLte, err = ec.unmarshalOID2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_in"))
			it.CreatedByIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin_in"))
			it.CreatedByMinIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax_in":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax_in"))
			it.CreatedByMaxIn, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy_null":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy_null"))
			it.CreatedByNull, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
			if err != nil {
				return it, err
			}
		case "employers":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("employers"))
			it.Employers, err = ec.unmarshalOCompanyFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyFilterType(ctx, v)
			if err != nil {
				return it, err
			}
		case "tasks":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tasks"))
			it.Tasks, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdTasks":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdTasks"))
			it.CreatedTasks, err = ec.unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputUserSortType(ctx context.Context, obj interface{}) (UserSortType, error) {
	var it UserSortType
	var asMap = obj.(map[string]interface{})

	for k, v := range asMap {
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			it.ID, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMin"))
			it.IDMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "idMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idMax"))
			it.IDMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "code":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("code"))
			it.Code, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMin"))
			it.CodeMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeMax"))
			it.CodeMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "codeAvg":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("codeAvg"))
			it.CodeAvg, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "email":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("email"))
			it.Email, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMin"))
			it.EmailMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "emailMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emailMax"))
			it.EmailMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstName":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstName"))
			it.FirstName, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMin"))
			it.FirstNameMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "firstNameMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstNameMax"))
			it.FirstNameMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastName":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastName"))
			it.LastName, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMin"))
			it.LastNameMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "lastNameMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastNameMax"))
			it.LastNameMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRaw":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRaw"))
			it.AddressRaw, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMin"))
			it.AddressRawMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "addressRawMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addressRawMax"))
			it.AddressRawMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "salary":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salary"))
			it.Salary, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMin"))
			it.SalaryMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryMax"))
			it.SalaryMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "salaryAvg":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("salaryAvg"))
			it.SalaryAvg, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt"))
			it.UpdatedAt, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMin"))
			it.UpdatedAtMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtMax"))
			it.UpdatedAtMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAt":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt"))
			it.CreatedAt, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMin"))
			it.CreatedAtMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdAtMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtMax"))
			it.CreatedAtMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy"))
			it.UpdatedBy, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMin"))
			it.UpdatedByMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "updatedByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByMax"))
			it.UpdatedByMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdBy":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy"))
			it.CreatedBy, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMin"))
			it.CreatedByMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdByMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByMax"))
			it.CreatedByMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "employersIds":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("employersIds"))
			it.EmployersIds, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "employersIdsMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("employersIdsMin"))
			it.EmployersIdsMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "employersIdsMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("employersIdsMax"))
			it.EmployersIdsMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "tasksIds":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tasksIds"))
			it.TasksIds, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "tasksIdsMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tasksIdsMin"))
			it.TasksIdsMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "tasksIdsMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tasksIdsMax"))
			it.TasksIdsMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdTasksIds":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdTasksIds"))
			it.CreatedTasksIds, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdTasksIdsMin":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdTasksIdsMin"))
			it.CreatedTasksIdsMin, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdTasksIdsMax":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdTasksIdsMax"))
			it.CreatedTasksIdsMax, err = ec.unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "employers":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("employers"))
			it.Employers, err = ec.unmarshalOCompanySortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanySortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "tasks":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tasks"))
			it.Tasks, err = ec.unmarshalOTaskSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortType(ctx, v)
			if err != nil {
				return it, err
			}
		case "createdTasks":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdTasks"))
			it.CreatedTasks, err = ec.unmarshalOTaskSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortType(ctx, v)
			if err != nil {
				return it, err
			}
		}
	}

	return it, nil
}

// endregion **************************** input.gotpl *****************************

// region    ************************** interface.gotpl ***************************

func (ec *executionContext) _NamedEntity(ctx context.Context, sel ast.SelectionSet, obj NamedEntity) graphql.Marshaler {
	switch obj := (obj).(type) {
	case nil:
		return graphql.Null
	case *Company:
		if obj == nil {
			return graphql.Null
		}
		return ec._Company(ctx, sel, obj)
	default:
		panic(fmt.Errorf("unexpected type %T", obj))
	}
}

func (ec *executionContext) __Entity(ctx context.Context, sel ast.SelectionSet, obj fedruntime.Entity) graphql.Marshaler {
	switch obj := (obj).(type) {
	case nil:
		return graphql.Null
	case *Company:
		if obj == nil {
			return graphql.Null
		}
		return ec._Company(ctx, sel, obj)
	default:
		panic(fmt.Errorf("unexpected type %T", obj))
	}
}

// endregion ************************** interface.gotpl ***************************

// region    **************************** object.gotpl ****************************

var addressImplementors = []string{"Address"}

func (ec *executionContext) _Address(ctx context.Context, sel ast.SelectionSet, obj *Address) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, addressImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Address")
		case "street":
			out.Values[i] = ec._Address_street(ctx, field, obj)
		case "city":
			out.Values[i] = ec._Address_city(ctx, field, obj)
		case "zip":
			out.Values[i] = ec._Address_zip(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var companyImplementors = []string{"Company", "NamedEntity", "_Entity"}

func (ec *executionContext) _Company(ctx context.Context, sel ast.SelectionSet, obj *Company) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, companyImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Company")
		case "id":
			out.Values[i] = ec._Company_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "name":
			out.Values[i] = ec._Company_name(ctx, field, obj)
		case "countryId":
			out.Values[i] = ec._Company_countryId(ctx, field, obj)
		case "country":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Company_country(ctx, field, obj)
				return res
			})
		case "employees":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Company_employees(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "reviews":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Company_reviews(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "updatedAt":
			out.Values[i] = ec._Company_updatedAt(ctx, field, obj)
		case "createdAt":
			out.Values[i] = ec._Company_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "updatedBy":
			out.Values[i] = ec._Company_updatedBy(ctx, field, obj)
		case "createdBy":
			out.Values[i] = ec._Company_createdBy(ctx, field, obj)
		case "employeesIds":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Company_employeesIds(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "employeesConnection":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Company_employeesConnection(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "uppercaseName":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Company_uppercaseName(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var companyResultTypeImplementors = []string{"CompanyResultType"}

func (ec *executionContext) _CompanyResultType(ctx context.Context, sel ast.SelectionSet, obj *CompanyResultType) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, companyResultTypeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CompanyResultType")
		case "items":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._CompanyResultType_items(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "count":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._CompanyResultType_count(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var countryImplementors = []string{"Country"}

func (ec *executionContext) _Country(ctx context.Context, sel ast.SelectionSet, obj *Country) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, countryImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Country")
		case "id":
			out.Values[i] = ec._Country_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var mutationImplementors = []string{"Mutation"}

func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)

	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
		Object: "Mutation",
	})

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Mutation")
		case "createTask":
			out.Values[i] = ec._Mutation_createTask(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "updateTask":
			out.Values[i] = ec._Mutation_updateTask(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deleteTask":
			out.Values[i] = ec._Mutation_deleteTask(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deleteAllTasks":
			out.Values[i] = ec._Mutation_deleteAllTasks(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "createTaskCategory":
			out.Values[i] = ec._Mutation_createTaskCategory(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "updateTaskCategory":
			out.Values[i] = ec._Mutation_updateTaskCategory(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deleteTaskCategory":
			out.Values[i] = ec._Mutation_deleteTaskCategory(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deleteAllTaskCategories":
			out.Values[i] = ec._Mutation_deleteAllTaskCategories(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "createCompany":
			out.Values[i] = ec._Mutation_createCompany(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "updateCompany":
			out.Values[i] = ec._Mutation_updateCompany(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deleteCompany":
			out.Values[i] = ec._Mutation_deleteCompany(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deleteAllCompanies":
			out.Values[i] = ec._Mutation_deleteAllCompanies(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "createUser":
			out.Values[i] = ec._Mutation_createUser(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "updateUser":
			out.Values[i] = ec._Mutation_updateUser(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deleteUser":
			out.Values[i] = ec._Mutation_deleteUser(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deleteAllUsers":
			out.Values[i] = ec._Mutation_deleteAllUsers(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "createPlainEntity":
			out.Values[i] = ec._Mutation_createPlainEntity(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "updatePlainEntity":
			out.Values[i] = ec._Mutation_updatePlainEntity(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deletePlainEntity":
			out.Values[i] = ec._Mutation_deletePlainEntity(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deleteAllPlainEntities":
			out.Values[i] = ec._Mutation_deleteAllPlainEntities(ctx, field)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var plainEntityImplementors = []string{"PlainEntity"}

func (ec *executionContext) _PlainEntity(ctx context.Context, sel ast.SelectionSet, obj *PlainEntity) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, plainEntityImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PlainEntity")
		case "id":
			out.Values[i] = ec._PlainEntity_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "date":
			out.Values[i] = ec._PlainEntity_date(ctx, field, obj)
		case "text":
			out.Values[i] = ec._PlainEntity_text(ctx, field, obj)
		case "shortText":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._PlainEntity_shortText(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "updatedAt":
			out.Values[i] = ec._PlainEntity_updatedAt(ctx, field, obj)
		case "createdAt":
			out.Values[i] = ec._PlainEntity_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "updatedBy":
			out.Values[i] = ec._PlainEntity_updatedBy(ctx, field, obj)
		case "createdBy":
			out.Values[i] = ec._PlainEntity_createdBy(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var plainEntityResultTypeImplementors = []string{"PlainEntityResultType"}

func (ec *executionContext) _PlainEntityResultType(ctx context.Context, sel ast.SelectionSet, obj *PlainEntityResultType) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, plainEntityResultTypeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PlainEntityResultType")
		case "items":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._PlainEntityResultType_items(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "count":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._PlainEntityResultType_count(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var queryImplementors = []string{"Query"}

func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)

	ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
		Object: "Query",
	})

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Query")
		case "_service":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query__service(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "task":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_task(ctx, field)
				return res
			})
		case "tasks":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_tasks(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "taskCategory":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_taskCategory(ctx, field)
				return res
			})
		case "taskCategories":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_taskCategories(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "company":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_company(ctx, field)
				return res
			})
		case "companies":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_companies(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "user":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_user(ctx, field)
				return res
			})
		case "users":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_users(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "plainEntity":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_plainEntity(ctx, field)
				return res
			})
		case "plainEntities":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_plainEntities(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "hello":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_hello(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "topCompanies":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_topCompanies(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "__type":
			out.Values[i] = ec._Query___type(ctx, field)
		case "__schema":
			out.Values[i] = ec._Query___schema(ctx, field)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var reviewImplementors = []string{"Review"}

func (ec *executionContext) _Review(ctx context.Context, sel ast.SelectionSet, obj *Review) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, reviewImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Review")
		case "id":
			out.Values[i] = ec._Review_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "referenceID":
			out.Values[i] = ec._Review_referenceID(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "company":
			out.Values[i] = ec._Review_company(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var taskImplementors = []string{"Task"}

func (ec *executionContext) _Task(ctx context.Context, sel ast.SelectionSet, obj *Task) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, taskImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Task")
		case "id":
			out.Values[i] = ec._Task_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "title":
			out.Values[i] = ec._Task_title(ctx, field, obj)
		case "completed":
			out.Values[i] = ec._Task_completed(ctx, field, obj)
		case "state":
			out.Values[i] = ec._Task_state(ctx, field, obj)
		case "dueDate":
			out.Values[i] = ec._Task_dueDate(ctx, field, obj)
		case "metas":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_metas(ctx, field, obj)
				return res
			})
		case "meta":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_meta(ctx, field, obj)
				return res
			})
		case "assignee":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_assignee(ctx, field, obj)
				return res
			})
		case "owner":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_owner(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "parentTask":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_parentTask(ctx, field, obj)
				return res
			})
		case "subtasks":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_subtasks(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "categories":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_categories(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "assigneeId":
			out.Values[i] = ec._Task_assigneeId(ctx, field, obj)
		case "ownerId":
			out.Values[i] = ec._Task_ownerId(ctx, field, obj)
		case "parentTaskId":
			out.Values[i] = ec._Task_parentTaskId(ctx, field, obj)
		case "updatedAt":
			out.Values[i] = ec._Task_updatedAt(ctx, field, obj)
		case "createdAt":
			out.Values[i] = ec._Task_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "updatedBy":
			out.Values[i] = ec._Task_updatedBy(ctx, field, obj)
		case "createdBy":
			out.Values[i] = ec._Task_createdBy(ctx, field, obj)
		case "subtasksIds":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_subtasksIds(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "subtasksConnection":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_subtasksConnection(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "categoriesIds":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_categoriesIds(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "categoriesConnection":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Task_categoriesConnection(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var taskCategoryImplementors = []string{"TaskCategory"}

func (ec *executionContext) _TaskCategory(ctx context.Context, sel ast.SelectionSet, obj *TaskCategory) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, taskCategoryImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("TaskCategory")
		case "id":
			out.Values[i] = ec._TaskCategory_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "name":
			out.Values[i] = ec._TaskCategory_name(ctx, field, obj)
		case "tasks":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TaskCategory_tasks(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "updatedAt":
			out.Values[i] = ec._TaskCategory_updatedAt(ctx, field, obj)
		case "createdAt":
			out.Values[i] = ec._TaskCategory_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "updatedBy":
			out.Values[i] = ec._TaskCategory_updatedBy(ctx, field, obj)
		case "createdBy":
			out.Values[i] = ec._TaskCategory_createdBy(ctx, field, obj)
		case "tasksIds":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TaskCategory_tasksIds(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "tasksConnection":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TaskCategory_tasksConnection(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var taskCategoryResultTypeImplementors = []string{"TaskCategoryResultType"}

func (ec *executionContext) _TaskCategoryResultType(ctx context.Context, sel ast.SelectionSet, obj *TaskCategoryResultType) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, taskCategoryResultTypeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("TaskCategoryResultType")
		case "items":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TaskCategoryResultType_items(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "count":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TaskCategoryResultType_count(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var taskMetaImplementors = []string{"TaskMeta"}

func (ec *executionContext) _TaskMeta(ctx context.Context, sel ast.SelectionSet, obj *TaskMeta) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, taskMetaImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("TaskMeta")
		case "key":
			out.Values[i] = ec._TaskMeta_key(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "value":
			out.Values[i] = ec._TaskMeta_value(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var taskResultTypeImplementors = []string{"TaskResultType"}

func (ec *executionContext) _TaskResultType(ctx context.Context, sel ast.SelectionSet, obj *TaskResultType) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, taskResultTypeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("TaskResultType")
		case "items":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TaskResultType_items(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "count":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._TaskResultType_count(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var userImplementors = []string{"User"}

func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *User) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("User")
		case "id":
			out.Values[i] = ec._User_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "code":
			out.Values[i] = ec._User_code(ctx, field, obj)
		case "email":
			out.Values[i] = ec._User_email(ctx, field, obj)
		case "firstName":
			out.Values[i] = ec._User_firstName(ctx, field, obj)
		case "lastName":
			out.Values[i] = ec._User_lastName(ctx, field, obj)
		case "addressRaw":
			out.Values[i] = ec._User_addressRaw(ctx, field, obj)
		case "address":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._User_address(ctx, field, obj)
				return res
			})
		case "salary":
			out.Values[i] = ec._User_salary(ctx, field, obj)
		case "employers":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._User_employers(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "tasks":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._User_tasks(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "createdTasks":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._User_createdTasks(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "updatedAt":
			out.Values[i] = ec._User_updatedAt(ctx, field, obj)
		case "createdAt":
			out.Values[i] = ec._User_createdAt(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				atomic.AddUint32(&invalids, 1)
			}
		case "updatedBy":
			out.Values[i] = ec._User_updatedBy(ctx, field, obj)
		case "createdBy":
			out.Values[i] = ec._User_createdBy(ctx, field, obj)
		case "employersIds":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._User_employersIds(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "employersConnection":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._User_employersConnection(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "tasksIds":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._User_tasksIds(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "tasksConnection":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._User_tasksConnection(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "createdTasksIds":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._User_createdTasksIds(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "createdTasksConnection":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._User_createdTasksConnection(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var userResultTypeImplementors = []string{"UserResultType"}

func (ec *executionContext) _UserResultType(ctx context.Context, sel ast.SelectionSet, obj *UserResultType) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, userResultTypeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UserResultType")
		case "items":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._UserResultType_items(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		case "count":
			field := field
			out.Concurrently(i, func() (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._UserResultType_count(ctx, field, obj)
				if res == graphql.Null {
					atomic.AddUint32(&invalids, 1)
				}
				return res
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var _ServiceImplementors = []string{"_Service"}

func (ec *executionContext) __Service(ctx context.Context, sel ast.SelectionSet, obj *fedruntime.Service) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, _ServiceImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("_Service")
		case "sdl":
			out.Values[i] = ec.__Service_sdl(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __DirectiveImplementors = []string{"__Directive"}

func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Directive")
		case "name":
			out.Values[i] = ec.___Directive_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___Directive_description(ctx, field, obj)
		case "locations":
			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "args":
			out.Values[i] = ec.___Directive_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __EnumValueImplementors = []string{"__EnumValue"}

func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__EnumValue")
		case "name":
			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
		case "isDeprecated":
			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __FieldImplementors = []string{"__Field"}

func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Field")
		case "name":
			out.Values[i] = ec.___Field_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___Field_description(ctx, field, obj)
		case "args":
			out.Values[i] = ec.___Field_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "type":
			out.Values[i] = ec.___Field_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "isDeprecated":
			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __InputValueImplementors = []string{"__InputValue"}

func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__InputValue")
		case "name":
			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "description":
			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
		case "type":
			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "defaultValue":
			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __SchemaImplementors = []string{"__Schema"}

func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Schema")
		case "types":
			out.Values[i] = ec.___Schema_types(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "queryType":
			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "mutationType":
			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
		case "subscriptionType":
			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
		case "directives":
			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

var __TypeImplementors = []string{"__Type"}

func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)

	out := graphql.NewFieldSet(fields)
	var invalids uint32
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Type")
		case "kind":
			out.Values[i] = ec.___Type_kind(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				invalids++
			}
		case "name":
			out.Values[i] = ec.___Type_name(ctx, field, obj)
		case "description":
			out.Values[i] = ec.___Type_description(ctx, field, obj)
		case "fields":
			out.Values[i] = ec.___Type_fields(ctx, field, obj)
		case "interfaces":
			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
		case "possibleTypes":
			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
		case "enumValues":
			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
		case "inputFields":
			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
		case "ofType":
			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch()
	if invalids > 0 {
		return graphql.Null
	}
	return out
}

// endregion **************************** object.gotpl ****************************

// region    ***************************** type.gotpl *****************************

func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
	res, err := graphql.UnmarshalBoolean(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
	res := graphql.MarshalBoolean(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalNCompany2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompany(ctx context.Context, sel ast.SelectionSet, v Company) graphql.Marshaler {
	return ec._Company(ctx, sel, &v)
}

func (ec *executionContext) marshalNCompany2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyᚄ(ctx context.Context, sel ast.SelectionSet, v []*Company) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNCompany2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompany(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNCompany2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompany(ctx context.Context, sel ast.SelectionSet, v *Company) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Company(ctx, sel, v)
}

func (ec *executionContext) unmarshalNCompanyCreateInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
	return v.(map[string]interface{}), nil
}

func (ec *executionContext) unmarshalNCompanyFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyFilterType(ctx context.Context, v interface{}) (*CompanyFilterType, error) {
	res, err := ec.unmarshalInputCompanyFilterType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNCompanyResultType2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyResultType(ctx context.Context, sel ast.SelectionSet, v CompanyResultType) graphql.Marshaler {
	return ec._CompanyResultType(ctx, sel, &v)
}

func (ec *executionContext) marshalNCompanyResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyResultType(ctx context.Context, sel ast.SelectionSet, v *CompanyResultType) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._CompanyResultType(ctx, sel, v)
}

func (ec *executionContext) unmarshalNCompanySortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanySortType(ctx context.Context, v interface{}) (*CompanySortType, error) {
	res, err := ec.unmarshalInputCompanySortType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNCompanyUpdateInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
	return v.(map[string]interface{}), nil
}

func (ec *executionContext) unmarshalNID2string(ctx context.Context, v interface{}) (string, error) {
	res, err := graphql.UnmarshalID(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalID(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNID2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNID2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalNID2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNID2string(ctx, sel, v[i])
	}

	return ret
}

func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
	res, err := graphql.UnmarshalInt(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
	res := graphql.MarshalInt(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalNPlainEntity2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntity(ctx context.Context, sel ast.SelectionSet, v PlainEntity) graphql.Marshaler {
	return ec._PlainEntity(ctx, sel, &v)
}

func (ec *executionContext) marshalNPlainEntity2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityᚄ(ctx context.Context, sel ast.SelectionSet, v []*PlainEntity) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNPlainEntity2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntity(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNPlainEntity2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntity(ctx context.Context, sel ast.SelectionSet, v *PlainEntity) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._PlainEntity(ctx, sel, v)
}

func (ec *executionContext) unmarshalNPlainEntityCreateInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
	return v.(map[string]interface{}), nil
}

func (ec *executionContext) unmarshalNPlainEntityFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityFilterType(ctx context.Context, v interface{}) (*PlainEntityFilterType, error) {
	res, err := ec.unmarshalInputPlainEntityFilterType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNPlainEntityResultType2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityResultType(ctx context.Context, sel ast.SelectionSet, v PlainEntityResultType) graphql.Marshaler {
	return ec._PlainEntityResultType(ctx, sel, &v)
}

func (ec *executionContext) marshalNPlainEntityResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityResultType(ctx context.Context, sel ast.SelectionSet, v *PlainEntityResultType) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._PlainEntityResultType(ctx, sel, v)
}

func (ec *executionContext) unmarshalNPlainEntitySortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntitySortType(ctx context.Context, v interface{}) (*PlainEntitySortType, error) {
	res, err := ec.unmarshalInputPlainEntitySortType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNPlainEntityUpdateInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
	return v.(map[string]interface{}), nil
}

func (ec *executionContext) marshalNReview2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐReviewᚄ(ctx context.Context, sel ast.SelectionSet, v []*Review) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNReview2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐReview(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNReview2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐReview(ctx context.Context, sel ast.SelectionSet, v *Review) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Review(ctx, sel, v)
}

func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalNTask2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTask(ctx context.Context, sel ast.SelectionSet, v Task) graphql.Marshaler {
	return ec._Task(ctx, sel, &v)
}

func (ec *executionContext) marshalNTask2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskᚄ(ctx context.Context, sel ast.SelectionSet, v []*Task) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNTask2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTask(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNTask2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTask(ctx context.Context, sel ast.SelectionSet, v *Task) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._Task(ctx, sel, v)
}

func (ec *executionContext) marshalNTaskCategory2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategory(ctx context.Context, sel ast.SelectionSet, v TaskCategory) graphql.Marshaler {
	return ec._TaskCategory(ctx, sel, &v)
}

func (ec *executionContext) marshalNTaskCategory2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryᚄ(ctx context.Context, sel ast.SelectionSet, v []*TaskCategory) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNTaskCategory2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategory(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNTaskCategory2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategory(ctx context.Context, sel ast.SelectionSet, v *TaskCategory) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._TaskCategory(ctx, sel, v)
}

func (ec *executionContext) unmarshalNTaskCategoryCreateInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
	return v.(map[string]interface{}), nil
}

func (ec *executionContext) unmarshalNTaskCategoryFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryFilterType(ctx context.Context, v interface{}) (*TaskCategoryFilterType, error) {
	res, err := ec.unmarshalInputTaskCategoryFilterType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNTaskCategoryResultType2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryResultType(ctx context.Context, sel ast.SelectionSet, v TaskCategoryResultType) graphql.Marshaler {
	return ec._TaskCategoryResultType(ctx, sel, &v)
}

func (ec *executionContext) marshalNTaskCategoryResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryResultType(ctx context.Context, sel ast.SelectionSet, v *TaskCategoryResultType) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._TaskCategoryResultType(ctx, sel, v)
}

func (ec *executionContext) unmarshalNTaskCategorySortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategorySortType(ctx context.Context, v interface{}) (*TaskCategorySortType, error) {
	res, err := ec.unmarshalInputTaskCategorySortType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNTaskCategoryUpdateInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
	return v.(map[string]interface{}), nil
}

func (ec *executionContext) unmarshalNTaskCreateInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
	return v.(map[string]interface{}), nil
}

func (ec *executionContext) unmarshalNTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx context.Context, v interface{}) (*TaskFilterType, error) {
	res, err := ec.unmarshalInputTaskFilterType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNTaskMeta2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskMeta(ctx context.Context, sel ast.SelectionSet, v *TaskMeta) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._TaskMeta(ctx, sel, v)
}

func (ec *executionContext) marshalNTaskResultType2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskResultType(ctx context.Context, sel ast.SelectionSet, v TaskResultType) graphql.Marshaler {
	return ec._TaskResultType(ctx, sel, &v)
}

func (ec *executionContext) marshalNTaskResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskResultType(ctx context.Context, sel ast.SelectionSet, v *TaskResultType) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._TaskResultType(ctx, sel, v)
}

func (ec *executionContext) unmarshalNTaskSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortType(ctx context.Context, v interface{}) (*TaskSortType, error) {
	res, err := ec.unmarshalInputTaskSortType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNTaskState2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx context.Context, v interface{}) (TaskState, error) {
	var res TaskState
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNTaskState2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx context.Context, sel ast.SelectionSet, v TaskState) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNTaskUpdateInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
	return v.(map[string]interface{}), nil
}

func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
	res, err := graphql.UnmarshalTime(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
	res := graphql.MarshalTime(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
	res, err := graphql.UnmarshalTime(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := graphql.MarshalTime(*v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalNUser2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUser(ctx context.Context, sel ast.SelectionSet, v User) graphql.Marshaler {
	return ec._User(ctx, sel, &v)
}

func (ec *executionContext) marshalNUser2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserᚄ(ctx context.Context, sel ast.SelectionSet, v []*User) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNUser2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUser(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._User(ctx, sel, v)
}

func (ec *executionContext) unmarshalNUserCreateInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
	return v.(map[string]interface{}), nil
}

func (ec *executionContext) unmarshalNUserFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterType(ctx context.Context, v interface{}) (*UserFilterType, error) {
	res, err := ec.unmarshalInputUserFilterType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNUserResultType2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserResultType(ctx context.Context, sel ast.SelectionSet, v UserResultType) graphql.Marshaler {
	return ec._UserResultType(ctx, sel, &v)
}

func (ec *executionContext) marshalNUserResultType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserResultType(ctx context.Context, sel ast.SelectionSet, v *UserResultType) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec._UserResultType(ctx, sel, v)
}

func (ec *executionContext) unmarshalNUserSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserSortType(ctx context.Context, v interface{}) (*UserSortType, error) {
	res, err := ec.unmarshalInputUserSortType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNUserUpdateInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
	return v.(map[string]interface{}), nil
}

func (ec *executionContext) unmarshalN_FieldSet2string(ctx context.Context, v interface{}) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalN_FieldSet2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalN_Service2githubᚗcomᚋ99designsᚋgqlgenᚋpluginᚋfederationᚋfedruntimeᚐService(ctx context.Context, sel ast.SelectionSet, v fedruntime.Service) graphql.Marshaler {
	return ec.__Service(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
	return ec.___Directive(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
	return ec.___EnumValue(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
	return ec.___Field(ctx, sel, &v)
}

func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
	return ec.___InputValue(ctx, sel, &v)
}

func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
	return ec.___Type(ctx, sel, &v)
}

func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	return ec.___Type(ctx, sel, v)
}

func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	res := graphql.MarshalString(v)
	if res == graphql.Null {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "must not be null")
		}
	}
	return res
}

func (ec *executionContext) marshalOAddress2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐAddress(ctx context.Context, sel ast.SelectionSet, v *Address) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Address(ctx, sel, v)
}

func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
	res, err := graphql.UnmarshalBoolean(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
	return graphql.MarshalBoolean(v)
}

func (ec *executionContext) unmarshalOBoolean2ᚕboolᚄ(ctx context.Context, v interface{}) ([]bool, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]bool, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNBoolean2bool(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOBoolean2ᚕboolᚄ(ctx context.Context, sel ast.SelectionSet, v []bool) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNBoolean2bool(ctx, sel, v[i])
	}

	return ret
}

func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalBoolean(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return graphql.MarshalBoolean(*v)
}

func (ec *executionContext) marshalOCompany2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompany(ctx context.Context, sel ast.SelectionSet, v *Company) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Company(ctx, sel, v)
}

func (ec *executionContext) unmarshalOCompanyFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyFilterTypeᚄ(ctx context.Context, v interface{}) ([]*CompanyFilterType, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*CompanyFilterType, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNCompanyFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyFilterType(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOCompanyFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanyFilterType(ctx context.Context, v interface{}) (*CompanyFilterType, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputCompanyFilterType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOCompanySortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanySortTypeᚄ(ctx context.Context, v interface{}) ([]*CompanySortType, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*CompanySortType, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNCompanySortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanySortType(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOCompanySortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCompanySortType(ctx context.Context, v interface{}) (*CompanySortType, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputCompanySortType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOCountry2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐCountry(ctx context.Context, sel ast.SelectionSet, v *Country) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Country(ctx, sel, v)
}

func (ec *executionContext) unmarshalOID2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNID2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOID2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNID2string(ctx, sel, v[i])
	}

	return ret
}

func (ec *executionContext) unmarshalOID2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalID(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOID2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return graphql.MarshalID(*v)
}

func (ec *executionContext) unmarshalOInt2ᚕintᚄ(ctx context.Context, v interface{}) ([]int, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]int, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNInt2int(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOInt2ᚕintᚄ(ctx context.Context, sel ast.SelectionSet, v []int) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNInt2int(ctx, sel, v[i])
	}

	return ret
}

func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalInt(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return graphql.MarshalInt(*v)
}

func (ec *executionContext) unmarshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx context.Context, v interface{}) (*ObjectSortType, error) {
	if v == nil {
		return nil, nil
	}
	var res = new(ObjectSortType)
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOObjectSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐObjectSortType(ctx context.Context, sel ast.SelectionSet, v *ObjectSortType) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return v
}

func (ec *executionContext) marshalOPlainEntity2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntity(ctx context.Context, sel ast.SelectionSet, v *PlainEntity) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._PlainEntity(ctx, sel, v)
}

func (ec *executionContext) unmarshalOPlainEntityFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityFilterTypeᚄ(ctx context.Context, v interface{}) ([]*PlainEntityFilterType, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*PlainEntityFilterType, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNPlainEntityFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityFilterType(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOPlainEntityFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntityFilterType(ctx context.Context, v interface{}) (*PlainEntityFilterType, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputPlainEntityFilterType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOPlainEntitySortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntitySortTypeᚄ(ctx context.Context, v interface{}) ([]*PlainEntitySortType, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*PlainEntitySortType, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNPlainEntitySortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐPlainEntitySortType(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
	res, err := graphql.UnmarshalString(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
	return graphql.MarshalString(v)
}

func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]string, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
	}

	return ret
}

func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalString(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return graphql.MarshalString(*v)
}

func (ec *executionContext) marshalOTask2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTask(ctx context.Context, sel ast.SelectionSet, v *Task) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Task(ctx, sel, v)
}

func (ec *executionContext) marshalOTaskCategory2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategory(ctx context.Context, sel ast.SelectionSet, v *TaskCategory) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._TaskCategory(ctx, sel, v)
}

func (ec *executionContext) unmarshalOTaskCategoryFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryFilterTypeᚄ(ctx context.Context, v interface{}) ([]*TaskCategoryFilterType, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*TaskCategoryFilterType, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNTaskCategoryFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryFilterType(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOTaskCategoryFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategoryFilterType(ctx context.Context, v interface{}) (*TaskCategoryFilterType, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTaskCategoryFilterType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOTaskCategorySortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategorySortTypeᚄ(ctx context.Context, v interface{}) ([]*TaskCategorySortType, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*TaskCategorySortType, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNTaskCategorySortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategorySortType(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOTaskCategorySortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskCategorySortType(ctx context.Context, v interface{}) (*TaskCategorySortType, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTaskCategorySortType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOTaskFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterTypeᚄ(ctx context.Context, v interface{}) ([]*TaskFilterType, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*TaskFilterType, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOTaskFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskFilterType(ctx context.Context, v interface{}) (*TaskFilterType, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTaskFilterType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOTaskMeta2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskMetaᚄ(ctx context.Context, sel ast.SelectionSet, v []*TaskMeta) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNTaskMeta2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskMeta(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalOTaskMeta2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskMeta(ctx context.Context, sel ast.SelectionSet, v *TaskMeta) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._TaskMeta(ctx, sel, v)
}

func (ec *executionContext) unmarshalOTaskMetaInput2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskMetaInput(ctx context.Context, v interface{}) ([]*TaskMetaInput, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*TaskMetaInput, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalOTaskMetaInput2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskMetaInput(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOTaskMetaInput2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskMetaInput(ctx context.Context, v interface{}) (*TaskMetaInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTaskMetaInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOTaskSortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortTypeᚄ(ctx context.Context, v interface{}) ([]*TaskSortType, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*TaskSortType, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNTaskSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortType(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOTaskSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskSortType(ctx context.Context, v interface{}) (*TaskSortType, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputTaskSortType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOTaskState2ᚕgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskStateᚄ(ctx context.Context, v interface{}) ([]TaskState, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]TaskState, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNTaskState2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOTaskState2ᚕgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskStateᚄ(ctx context.Context, sel ast.SelectionSet, v []TaskState) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalNTaskState2githubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) unmarshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx context.Context, v interface{}) (*TaskState, error) {
	if v == nil {
		return nil, nil
	}
	var res = new(TaskState)
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOTaskState2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐTaskState(ctx context.Context, sel ast.SelectionSet, v *TaskState) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return v
}

func (ec *executionContext) unmarshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx context.Context, v interface{}) ([]*time.Time, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*time.Time, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNTime2ᚖtimeᚐTime(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOTime2ᚕᚖtimeᚐTimeᚄ(ctx context.Context, sel ast.SelectionSet, v []*time.Time) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	for i := range v {
		ret[i] = ec.marshalNTime2ᚖtimeᚐTime(ctx, sel, v[i])
	}

	return ret
}

func (ec *executionContext) unmarshalOTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
	if v == nil {
		return nil, nil
	}
	res, err := graphql.UnmarshalTime(v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return graphql.MarshalTime(*v)
}

func (ec *executionContext) marshalOUser2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._User(ctx, sel, v)
}

func (ec *executionContext) unmarshalOUserFilterType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterTypeᚄ(ctx context.Context, v interface{}) ([]*UserFilterType, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*UserFilterType, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNUserFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterType(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOUserFilterType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserFilterType(ctx context.Context, v interface{}) (*UserFilterType, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputUserFilterType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalOUserSortType2ᚕᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserSortTypeᚄ(ctx context.Context, v interface{}) ([]*UserSortType, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		if tmp1, ok := v.([]interface{}); ok {
			vSlice = tmp1
		} else {
			vSlice = []interface{}{v}
		}
	}
	var err error
	res := make([]*UserSortType, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNUserSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserSortType(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOUserSortType2ᚖgithubᚗcomᚋloopcontextᚋgoᚑgraphqlᚑormᚋtestᚋgenᚐUserSortType(ctx context.Context, v interface{}) (*UserSortType, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputUserSortType(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.___Schema(ctx, sel, v)
}

func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	ret := make(graphql.Array, len(v))
	var wg sync.WaitGroup
	isLen1 := len(v) == 1
	if !isLen1 {
		wg.Add(len(v))
	}
	for i := range v {
		i := i
		fc := &graphql.FieldContext{
			Index:  &i,
			Result: &v[i],
		}
		ctx := graphql.WithFieldContext(ctx, fc)
		f := func(i int) {
			defer func() {
				if r := recover(); r != nil {
					ec.Error(ctx, ec.Recover(ctx, r))
					ret = nil
				}
			}()
			if !isLen1 {
				defer wg.Done()
			}
			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()
	return ret
}

func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec.___Type(ctx, sel, v)
}

// endregion ***************************** type.gotpl *****************************