generated_gqlgen.go

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

package generated

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

	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/introspection"
	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 {
	Mutation() MutationResolver
	Query() QueryResolver
}

type DirectiveRoot struct {
	Action                  func(ctx context.Context, obj interface{}, next graphql.Resolver, resource string, action XgenResourceActionType, route *string, schemaFieldName *string) (res interface{}, err error)
	ActionField             func(ctx context.Context, obj interface{}, next graphql.Resolver, label *string, description *string, mapTo []string) (res interface{}, err error)
	ExcludeArgumentFromType func(ctx context.Context, obj interface{}, next graphql.Resolver, exclude *bool) (res interface{}, err error)
	Field                   func(ctx context.Context, obj interface{}, next graphql.Resolver, label *string, description *string, db *XgenResourceFieldDbConfigInput) (res interface{}, err error)
	ListAction              func(ctx context.Context, obj interface{}, next graphql.Resolver, resource string, action XgenResourceListActionType, route *string, pagination *bool, sort *XgenSortResourceConfigInput, schemaFieldName *string) (res interface{}, err error)
	Resource                func(ctx context.Context, obj interface{}, next graphql.Resolver, name string, route *string, primary *bool, db *XgenResourceDbConfigInput) (res interface{}, err error)
	ToObjectType            func(ctx context.Context, obj interface{}, next graphql.Resolver, typeArg string) (res interface{}, err error)
}

type ComplexityRoot struct {
	Action struct {
		Action          func(childComplexity int) int
		Resource        func(childComplexity int) int
		Route           func(childComplexity int) int
		SchemaFieldName func(childComplexity int) int
	}

	ActionAnnotationSingle struct {
		Name  func(childComplexity int) int
		Value func(childComplexity int) int
	}

	ActionField struct {
		Description func(childComplexity int) int
		Label       func(childComplexity int) int
		MapTo       func(childComplexity int) int
	}

	Car struct {
		Done func(childComplexity int) int
		ID   func(childComplexity int) int
		Make func(childComplexity int) int
		User func(childComplexity int) int
	}

	CarBrowseInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	CarInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	CarXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	DeleteUsersXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	Field struct {
		Description func(childComplexity int) int
		Label       func(childComplexity int) int
	}

	ListAction struct {
		Action          func(childComplexity int) int
		Pagination      func(childComplexity int) int
		Resource        func(childComplexity int) int
		Route           func(childComplexity int) int
		SchemaFieldName func(childComplexity int) int
		Sort            func(childComplexity int) int
	}

	ListActionAnnotationSingle struct {
		Name  func(childComplexity int) int
		Value func(childComplexity int) int
	}

	ListUserXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	Mutation struct {
		CarCreate         func(childComplexity int, input *CarInput) int
		CarUpdate         func(childComplexity int, input *CarInput) int
		PhoneNumberCreate func(childComplexity int, input *PhoneNumberInput) int
		PhoneNumberUpdate func(childComplexity int, input *PhoneNumberInput) int
		UserBatchDelete   func(childComplexity int, input *DeleteUsers) int
		UserCreate        func(childComplexity int, input *UserInput) int
		UserUpdate        func(childComplexity int, input *UserInput) int
	}

	Phone struct {
		ID     func(childComplexity int) int
		Number func(childComplexity int) int
		User   func(childComplexity int) int
	}

	PhoneNumberBrowseInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	PhoneNumberInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	PhoneXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	Query struct {
		CarBrowse         func(childComplexity int, where *CarBrowseInput) int
		PhoneNumberBrowse func(childComplexity int, where *PhoneNumberBrowseInput) int
		UserBrowse        func(childComplexity int, where *ListUser, pagination *XgenPaginationInput, sort *UserSortInput) int
		XgenIntrospection func(childComplexity int) int
	}

	Resource struct {
		Name    func(childComplexity int) int
		Primary func(childComplexity int) int
		Route   func(childComplexity int) int
	}

	ResourceAnnotationSingle struct {
		Name  func(childComplexity int) int
		Value func(childComplexity int) int
	}

	User struct {
		Cars         func(childComplexity int) int
		ID           func(childComplexity int) int
		Name         func(childComplexity int) int
		PhoneNumbers func(childComplexity int) int
	}

	UserInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	UserXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenAnnotationMap struct {
		Action     func(childComplexity int) int
		ListAction func(childComplexity int) int
		Resource   func(childComplexity int) int
	}

	XgenCursorPaginationInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenFieldDef struct {
		ActionField func(childComplexity int) int
		Field       func(childComplexity int) int
	}

	XgenIntrospection struct {
		Annotation func(childComplexity int) int
		Object     func(childComplexity int) int
		Resource   func(childComplexity int) int
	}

	XgenObjectDefinition struct {
		Action     func(childComplexity int) int
		ListAction func(childComplexity int) int
		Resource   func(childComplexity int) int
	}

	XgenObjectField struct {
		Definition func(childComplexity int) int
		Name       func(childComplexity int) int
	}

	XgenObjectMap struct {
		Car                            func(childComplexity int) int
		CarBrowseInput                 func(childComplexity int) int
		CarInput                       func(childComplexity int) int
		DeleteUsers                    func(childComplexity int) int
		ListUser                       func(childComplexity int) int
		Phone                          func(childComplexity int) int
		PhoneNumberBrowseInput         func(childComplexity int) int
		PhoneNumberInput               func(childComplexity int) int
		User                           func(childComplexity int) int
		UserInput                      func(childComplexity int) int
		XgenCursorPaginationInput      func(childComplexity int) int
		XgenPaginationInput            func(childComplexity int) int
		XgenResourceActionType         func(childComplexity int) int
		XgenResourceDbConfigInput      func(childComplexity int) int
		XgenResourceFieldDbConfigInput func(childComplexity int) int
		XgenResourceListActionType     func(childComplexity int) int
		XgenSort                       func(childComplexity int) int
		XgenSortDirection              func(childComplexity int) int
		XgenSortInput                  func(childComplexity int) int
		XgenSortResourceConfig         func(childComplexity int) int
		XgenSortResourceConfigInput    func(childComplexity int) int
	}

	XgenPaginationInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenResourceAction struct {
		Action          func(childComplexity int) int
		Resource        func(childComplexity int) int
		Route           func(childComplexity int) int
		SchemaFieldName func(childComplexity int) int
	}

	XgenResourceActionTypeXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenResourceDbConfigInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenResourceDefinition struct {
		Actions    func(childComplexity int) int
		ObjectName func(childComplexity int) int
		Properties func(childComplexity int) int
	}

	XgenResourceFieldDbConfigInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenResourceListActionTypeXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenResourceMap struct {
		Car         func(childComplexity int) int
		PhoneNumber func(childComplexity int) int
		User        func(childComplexity int) int
	}

	XgenResourceProperty struct {
		Name    func(childComplexity int) int
		Primary func(childComplexity int) int
		Route   func(childComplexity int) int
	}

	XgenSort struct {
		By        func(childComplexity int) int
		Direction func(childComplexity int) int
	}

	XgenSortDirectionXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenSortInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenSortResourceConfig struct {
		Default  func(childComplexity int) int
		Disabled func(childComplexity int) int
	}

	XgenSortResourceConfigInputXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenSortResourceConfigXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}

	XgenSortXgenDef struct {
		Field  func(childComplexity int) int
		Object func(childComplexity int) int
	}
}

type MutationResolver interface {
	UserBatchDelete(ctx context.Context, input *DeleteUsers) ([]*User, error)
	UserCreate(ctx context.Context, input *UserInput) (*User, error)
	UserUpdate(ctx context.Context, input *UserInput) (*User, error)
	CarCreate(ctx context.Context, input *CarInput) (*Car, error)
	CarUpdate(ctx context.Context, input *CarInput) (*Car, error)
	PhoneNumberCreate(ctx context.Context, input *PhoneNumberInput) (*Phone, error)
	PhoneNumberUpdate(ctx context.Context, input *PhoneNumberInput) (*Phone, error)
}
type QueryResolver interface {
	XgenIntrospection(ctx context.Context) (*XgenIntrospection, error)
	CarBrowse(ctx context.Context, where *CarBrowseInput) ([]*Car, error)
	UserBrowse(ctx context.Context, where *ListUser, pagination *XgenPaginationInput, sort *UserSortInput) ([]*User, error)
	PhoneNumberBrowse(ctx context.Context, where *PhoneNumberBrowseInput) ([]*Phone, 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, 0, 0, nil}
	_ = ec
	switch typeName + "." + field {

	case "Action.Action":
		if e.complexity.Action.Action == nil {
			break
		}

		return e.complexity.Action.Action(childComplexity), true

	case "Action.Resource":
		if e.complexity.Action.Resource == nil {
			break
		}

		return e.complexity.Action.Resource(childComplexity), true

	case "Action.Route":
		if e.complexity.Action.Route == nil {
			break
		}

		return e.complexity.Action.Route(childComplexity), true

	case "Action.SchemaFieldName":
		if e.complexity.Action.SchemaFieldName == nil {
			break
		}

		return e.complexity.Action.SchemaFieldName(childComplexity), true

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

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

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

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

	case "ActionField.Description":
		if e.complexity.ActionField.Description == nil {
			break
		}

		return e.complexity.ActionField.Description(childComplexity), true

	case "ActionField.Label":
		if e.complexity.ActionField.Label == nil {
			break
		}

		return e.complexity.ActionField.Label(childComplexity), true

	case "ActionField.MapTo":
		if e.complexity.ActionField.MapTo == nil {
			break
		}

		return e.complexity.ActionField.MapTo(childComplexity), true

	case "Car.done":
		if e.complexity.Car.Done == nil {
			break
		}

		return e.complexity.Car.Done(childComplexity), true

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

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

	case "Car.make":
		if e.complexity.Car.Make == nil {
			break
		}

		return e.complexity.Car.Make(childComplexity), true

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

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

	case "CarBrowseInputXgenDef.field":
		if e.complexity.CarBrowseInputXgenDef.Field == nil {
			break
		}

		return e.complexity.CarBrowseInputXgenDef.Field(childComplexity), true

	case "CarBrowseInputXgenDef.object":
		if e.complexity.CarBrowseInputXgenDef.Object == nil {
			break
		}

		return e.complexity.CarBrowseInputXgenDef.Object(childComplexity), true

	case "CarInputXgenDef.field":
		if e.complexity.CarInputXgenDef.Field == nil {
			break
		}

		return e.complexity.CarInputXgenDef.Field(childComplexity), true

	case "CarInputXgenDef.object":
		if e.complexity.CarInputXgenDef.Object == nil {
			break
		}

		return e.complexity.CarInputXgenDef.Object(childComplexity), true

	case "CarXgenDef.field":
		if e.complexity.CarXgenDef.Field == nil {
			break
		}

		return e.complexity.CarXgenDef.Field(childComplexity), true

	case "CarXgenDef.object":
		if e.complexity.CarXgenDef.Object == nil {
			break
		}

		return e.complexity.CarXgenDef.Object(childComplexity), true

	case "DeleteUsersXgenDef.field":
		if e.complexity.DeleteUsersXgenDef.Field == nil {
			break
		}

		return e.complexity.DeleteUsersXgenDef.Field(childComplexity), true

	case "DeleteUsersXgenDef.object":
		if e.complexity.DeleteUsersXgenDef.Object == nil {
			break
		}

		return e.complexity.DeleteUsersXgenDef.Object(childComplexity), true

	case "Field.Description":
		if e.complexity.Field.Description == nil {
			break
		}

		return e.complexity.Field.Description(childComplexity), true

	case "Field.Label":
		if e.complexity.Field.Label == nil {
			break
		}

		return e.complexity.Field.Label(childComplexity), true

	case "ListAction.Action":
		if e.complexity.ListAction.Action == nil {
			break
		}

		return e.complexity.ListAction.Action(childComplexity), true

	case "ListAction.Pagination":
		if e.complexity.ListAction.Pagination == nil {
			break
		}

		return e.complexity.ListAction.Pagination(childComplexity), true

	case "ListAction.Resource":
		if e.complexity.ListAction.Resource == nil {
			break
		}

		return e.complexity.ListAction.Resource(childComplexity), true

	case "ListAction.Route":
		if e.complexity.ListAction.Route == nil {
			break
		}

		return e.complexity.ListAction.Route(childComplexity), true

	case "ListAction.SchemaFieldName":
		if e.complexity.ListAction.SchemaFieldName == nil {
			break
		}

		return e.complexity.ListAction.SchemaFieldName(childComplexity), true

	case "ListAction.Sort":
		if e.complexity.ListAction.Sort == nil {
			break
		}

		return e.complexity.ListAction.Sort(childComplexity), true

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

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

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

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

	case "ListUserXgenDef.field":
		if e.complexity.ListUserXgenDef.Field == nil {
			break
		}

		return e.complexity.ListUserXgenDef.Field(childComplexity), true

	case "ListUserXgenDef.object":
		if e.complexity.ListUserXgenDef.Object == nil {
			break
		}

		return e.complexity.ListUserXgenDef.Object(childComplexity), true

	case "Mutation.car_create":
		if e.complexity.Mutation.CarCreate == nil {
			break
		}

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

		return e.complexity.Mutation.CarCreate(childComplexity, args["input"].(*CarInput)), true

	case "Mutation.car_update":
		if e.complexity.Mutation.CarUpdate == nil {
			break
		}

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

		return e.complexity.Mutation.CarUpdate(childComplexity, args["input"].(*CarInput)), true

	case "Mutation.phone_number_create":
		if e.complexity.Mutation.PhoneNumberCreate == nil {
			break
		}

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

		return e.complexity.Mutation.PhoneNumberCreate(childComplexity, args["input"].(*PhoneNumberInput)), true

	case "Mutation.phone_number_update":
		if e.complexity.Mutation.PhoneNumberUpdate == nil {
			break
		}

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

		return e.complexity.Mutation.PhoneNumberUpdate(childComplexity, args["input"].(*PhoneNumberInput)), true

	case "Mutation.user_batch_delete":
		if e.complexity.Mutation.UserBatchDelete == nil {
			break
		}

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

		return e.complexity.Mutation.UserBatchDelete(childComplexity, args["input"].(*DeleteUsers)), true

	case "Mutation.user_create":
		if e.complexity.Mutation.UserCreate == nil {
			break
		}

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

		return e.complexity.Mutation.UserCreate(childComplexity, args["input"].(*UserInput)), true

	case "Mutation.user_update":
		if e.complexity.Mutation.UserUpdate == nil {
			break
		}

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

		return e.complexity.Mutation.UserUpdate(childComplexity, args["input"].(*UserInput)), true

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

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

	case "Phone.number":
		if e.complexity.Phone.Number == nil {
			break
		}

		return e.complexity.Phone.Number(childComplexity), true

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

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

	case "PhoneNumberBrowseInputXgenDef.field":
		if e.complexity.PhoneNumberBrowseInputXgenDef.Field == nil {
			break
		}

		return e.complexity.PhoneNumberBrowseInputXgenDef.Field(childComplexity), true

	case "PhoneNumberBrowseInputXgenDef.object":
		if e.complexity.PhoneNumberBrowseInputXgenDef.Object == nil {
			break
		}

		return e.complexity.PhoneNumberBrowseInputXgenDef.Object(childComplexity), true

	case "PhoneNumberInputXgenDef.field":
		if e.complexity.PhoneNumberInputXgenDef.Field == nil {
			break
		}

		return e.complexity.PhoneNumberInputXgenDef.Field(childComplexity), true

	case "PhoneNumberInputXgenDef.object":
		if e.complexity.PhoneNumberInputXgenDef.Object == nil {
			break
		}

		return e.complexity.PhoneNumberInputXgenDef.Object(childComplexity), true

	case "PhoneXgenDef.field":
		if e.complexity.PhoneXgenDef.Field == nil {
			break
		}

		return e.complexity.PhoneXgenDef.Field(childComplexity), true

	case "PhoneXgenDef.object":
		if e.complexity.PhoneXgenDef.Object == nil {
			break
		}

		return e.complexity.PhoneXgenDef.Object(childComplexity), true

	case "Query.car_browse":
		if e.complexity.Query.CarBrowse == nil {
			break
		}

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

		return e.complexity.Query.CarBrowse(childComplexity, args["where"].(*CarBrowseInput)), true

	case "Query.phone_number_browse":
		if e.complexity.Query.PhoneNumberBrowse == nil {
			break
		}

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

		return e.complexity.Query.PhoneNumberBrowse(childComplexity, args["where"].(*PhoneNumberBrowseInput)), true

	case "Query.user_browse":
		if e.complexity.Query.UserBrowse == nil {
			break
		}

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

		return e.complexity.Query.UserBrowse(childComplexity, args["where"].(*ListUser), args["pagination"].(*XgenPaginationInput), args["sort"].(*UserSortInput)), true

	case "Query._xgen_introspection":
		if e.complexity.Query.XgenIntrospection == nil {
			break
		}

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

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

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

	case "Resource.Primary":
		if e.complexity.Resource.Primary == nil {
			break
		}

		return e.complexity.Resource.Primary(childComplexity), true

	case "Resource.Route":
		if e.complexity.Resource.Route == nil {
			break
		}

		return e.complexity.Resource.Route(childComplexity), true

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

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

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

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

	case "User.cars":
		if e.complexity.User.Cars == nil {
			break
		}

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

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

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

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

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

	case "User.phoneNumbers":
		if e.complexity.User.PhoneNumbers == nil {
			break
		}

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

	case "UserInputXgenDef.field":
		if e.complexity.UserInputXgenDef.Field == nil {
			break
		}

		return e.complexity.UserInputXgenDef.Field(childComplexity), true

	case "UserInputXgenDef.object":
		if e.complexity.UserInputXgenDef.Object == nil {
			break
		}

		return e.complexity.UserInputXgenDef.Object(childComplexity), true

	case "UserXgenDef.field":
		if e.complexity.UserXgenDef.Field == nil {
			break
		}

		return e.complexity.UserXgenDef.Field(childComplexity), true

	case "UserXgenDef.object":
		if e.complexity.UserXgenDef.Object == nil {
			break
		}

		return e.complexity.UserXgenDef.Object(childComplexity), true

	case "XgenAnnotationMap.Action":
		if e.complexity.XgenAnnotationMap.Action == nil {
			break
		}

		return e.complexity.XgenAnnotationMap.Action(childComplexity), true

	case "XgenAnnotationMap.ListAction":
		if e.complexity.XgenAnnotationMap.ListAction == nil {
			break
		}

		return e.complexity.XgenAnnotationMap.ListAction(childComplexity), true

	case "XgenAnnotationMap.Resource":
		if e.complexity.XgenAnnotationMap.Resource == nil {
			break
		}

		return e.complexity.XgenAnnotationMap.Resource(childComplexity), true

	case "XgenCursorPaginationInputXgenDef.field":
		if e.complexity.XgenCursorPaginationInputXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenCursorPaginationInputXgenDef.Field(childComplexity), true

	case "XgenCursorPaginationInputXgenDef.object":
		if e.complexity.XgenCursorPaginationInputXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenCursorPaginationInputXgenDef.Object(childComplexity), true

	case "XgenFieldDef.ActionField":
		if e.complexity.XgenFieldDef.ActionField == nil {
			break
		}

		return e.complexity.XgenFieldDef.ActionField(childComplexity), true

	case "XgenFieldDef.Field":
		if e.complexity.XgenFieldDef.Field == nil {
			break
		}

		return e.complexity.XgenFieldDef.Field(childComplexity), true

	case "XgenIntrospection.annotation":
		if e.complexity.XgenIntrospection.Annotation == nil {
			break
		}

		return e.complexity.XgenIntrospection.Annotation(childComplexity), true

	case "XgenIntrospection.object":
		if e.complexity.XgenIntrospection.Object == nil {
			break
		}

		return e.complexity.XgenIntrospection.Object(childComplexity), true

	case "XgenIntrospection.resource":
		if e.complexity.XgenIntrospection.Resource == nil {
			break
		}

		return e.complexity.XgenIntrospection.Resource(childComplexity), true

	case "XgenObjectDefinition.Action":
		if e.complexity.XgenObjectDefinition.Action == nil {
			break
		}

		return e.complexity.XgenObjectDefinition.Action(childComplexity), true

	case "XgenObjectDefinition.ListAction":
		if e.complexity.XgenObjectDefinition.ListAction == nil {
			break
		}

		return e.complexity.XgenObjectDefinition.ListAction(childComplexity), true

	case "XgenObjectDefinition.Resource":
		if e.complexity.XgenObjectDefinition.Resource == nil {
			break
		}

		return e.complexity.XgenObjectDefinition.Resource(childComplexity), true

	case "XgenObjectField.definition":
		if e.complexity.XgenObjectField.Definition == nil {
			break
		}

		return e.complexity.XgenObjectField.Definition(childComplexity), true

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

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

	case "XgenObjectMap.Car":
		if e.complexity.XgenObjectMap.Car == nil {
			break
		}

		return e.complexity.XgenObjectMap.Car(childComplexity), true

	case "XgenObjectMap.CarBrowseInput":
		if e.complexity.XgenObjectMap.CarBrowseInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.CarBrowseInput(childComplexity), true

	case "XgenObjectMap.CarInput":
		if e.complexity.XgenObjectMap.CarInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.CarInput(childComplexity), true

	case "XgenObjectMap.DeleteUsers":
		if e.complexity.XgenObjectMap.DeleteUsers == nil {
			break
		}

		return e.complexity.XgenObjectMap.DeleteUsers(childComplexity), true

	case "XgenObjectMap.ListUser":
		if e.complexity.XgenObjectMap.ListUser == nil {
			break
		}

		return e.complexity.XgenObjectMap.ListUser(childComplexity), true

	case "XgenObjectMap.Phone":
		if e.complexity.XgenObjectMap.Phone == nil {
			break
		}

		return e.complexity.XgenObjectMap.Phone(childComplexity), true

	case "XgenObjectMap.PhoneNumberBrowseInput":
		if e.complexity.XgenObjectMap.PhoneNumberBrowseInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.PhoneNumberBrowseInput(childComplexity), true

	case "XgenObjectMap.PhoneNumberInput":
		if e.complexity.XgenObjectMap.PhoneNumberInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.PhoneNumberInput(childComplexity), true

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

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

	case "XgenObjectMap.UserInput":
		if e.complexity.XgenObjectMap.UserInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.UserInput(childComplexity), true

	case "XgenObjectMap.XgenCursorPaginationInput":
		if e.complexity.XgenObjectMap.XgenCursorPaginationInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenCursorPaginationInput(childComplexity), true

	case "XgenObjectMap.XgenPaginationInput":
		if e.complexity.XgenObjectMap.XgenPaginationInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenPaginationInput(childComplexity), true

	case "XgenObjectMap.XgenResourceActionType":
		if e.complexity.XgenObjectMap.XgenResourceActionType == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenResourceActionType(childComplexity), true

	case "XgenObjectMap.XgenResourceDbConfigInput":
		if e.complexity.XgenObjectMap.XgenResourceDbConfigInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenResourceDbConfigInput(childComplexity), true

	case "XgenObjectMap.XgenResourceFieldDbConfigInput":
		if e.complexity.XgenObjectMap.XgenResourceFieldDbConfigInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenResourceFieldDbConfigInput(childComplexity), true

	case "XgenObjectMap.XgenResourceListActionType":
		if e.complexity.XgenObjectMap.XgenResourceListActionType == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenResourceListActionType(childComplexity), true

	case "XgenObjectMap.XgenSort":
		if e.complexity.XgenObjectMap.XgenSort == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenSort(childComplexity), true

	case "XgenObjectMap.XgenSortDirection":
		if e.complexity.XgenObjectMap.XgenSortDirection == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenSortDirection(childComplexity), true

	case "XgenObjectMap.XgenSortInput":
		if e.complexity.XgenObjectMap.XgenSortInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenSortInput(childComplexity), true

	case "XgenObjectMap.XgenSortResourceConfig":
		if e.complexity.XgenObjectMap.XgenSortResourceConfig == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenSortResourceConfig(childComplexity), true

	case "XgenObjectMap.XgenSortResourceConfigInput":
		if e.complexity.XgenObjectMap.XgenSortResourceConfigInput == nil {
			break
		}

		return e.complexity.XgenObjectMap.XgenSortResourceConfigInput(childComplexity), true

	case "XgenPaginationInputXgenDef.field":
		if e.complexity.XgenPaginationInputXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenPaginationInputXgenDef.Field(childComplexity), true

	case "XgenPaginationInputXgenDef.object":
		if e.complexity.XgenPaginationInputXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenPaginationInputXgenDef.Object(childComplexity), true

	case "XgenResourceAction.Action":
		if e.complexity.XgenResourceAction.Action == nil {
			break
		}

		return e.complexity.XgenResourceAction.Action(childComplexity), true

	case "XgenResourceAction.Resource":
		if e.complexity.XgenResourceAction.Resource == nil {
			break
		}

		return e.complexity.XgenResourceAction.Resource(childComplexity), true

	case "XgenResourceAction.Route":
		if e.complexity.XgenResourceAction.Route == nil {
			break
		}

		return e.complexity.XgenResourceAction.Route(childComplexity), true

	case "XgenResourceAction.SchemaFieldName":
		if e.complexity.XgenResourceAction.SchemaFieldName == nil {
			break
		}

		return e.complexity.XgenResourceAction.SchemaFieldName(childComplexity), true

	case "XgenResourceActionTypeXgenDef.field":
		if e.complexity.XgenResourceActionTypeXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenResourceActionTypeXgenDef.Field(childComplexity), true

	case "XgenResourceActionTypeXgenDef.object":
		if e.complexity.XgenResourceActionTypeXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenResourceActionTypeXgenDef.Object(childComplexity), true

	case "XgenResourceDbConfigInputXgenDef.field":
		if e.complexity.XgenResourceDbConfigInputXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenResourceDbConfigInputXgenDef.Field(childComplexity), true

	case "XgenResourceDbConfigInputXgenDef.object":
		if e.complexity.XgenResourceDbConfigInputXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenResourceDbConfigInputXgenDef.Object(childComplexity), true

	case "XgenResourceDefinition.actions":
		if e.complexity.XgenResourceDefinition.Actions == nil {
			break
		}

		return e.complexity.XgenResourceDefinition.Actions(childComplexity), true

	case "XgenResourceDefinition.objectName":
		if e.complexity.XgenResourceDefinition.ObjectName == nil {
			break
		}

		return e.complexity.XgenResourceDefinition.ObjectName(childComplexity), true

	case "XgenResourceDefinition.properties":
		if e.complexity.XgenResourceDefinition.Properties == nil {
			break
		}

		return e.complexity.XgenResourceDefinition.Properties(childComplexity), true

	case "XgenResourceFieldDbConfigInputXgenDef.field":
		if e.complexity.XgenResourceFieldDbConfigInputXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenResourceFieldDbConfigInputXgenDef.Field(childComplexity), true

	case "XgenResourceFieldDbConfigInputXgenDef.object":
		if e.complexity.XgenResourceFieldDbConfigInputXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenResourceFieldDbConfigInputXgenDef.Object(childComplexity), true

	case "XgenResourceListActionTypeXgenDef.field":
		if e.complexity.XgenResourceListActionTypeXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenResourceListActionTypeXgenDef.Field(childComplexity), true

	case "XgenResourceListActionTypeXgenDef.object":
		if e.complexity.XgenResourceListActionTypeXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenResourceListActionTypeXgenDef.Object(childComplexity), true

	case "XgenResourceMap.car":
		if e.complexity.XgenResourceMap.Car == nil {
			break
		}

		return e.complexity.XgenResourceMap.Car(childComplexity), true

	case "XgenResourceMap.phone_number":
		if e.complexity.XgenResourceMap.PhoneNumber == nil {
			break
		}

		return e.complexity.XgenResourceMap.PhoneNumber(childComplexity), true

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

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

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

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

	case "XgenResourceProperty.Primary":
		if e.complexity.XgenResourceProperty.Primary == nil {
			break
		}

		return e.complexity.XgenResourceProperty.Primary(childComplexity), true

	case "XgenResourceProperty.Route":
		if e.complexity.XgenResourceProperty.Route == nil {
			break
		}

		return e.complexity.XgenResourceProperty.Route(childComplexity), true

	case "XgenSort.by":
		if e.complexity.XgenSort.By == nil {
			break
		}

		return e.complexity.XgenSort.By(childComplexity), true

	case "XgenSort.direction":
		if e.complexity.XgenSort.Direction == nil {
			break
		}

		return e.complexity.XgenSort.Direction(childComplexity), true

	case "XgenSortDirectionXgenDef.field":
		if e.complexity.XgenSortDirectionXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenSortDirectionXgenDef.Field(childComplexity), true

	case "XgenSortDirectionXgenDef.object":
		if e.complexity.XgenSortDirectionXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenSortDirectionXgenDef.Object(childComplexity), true

	case "XgenSortInputXgenDef.field":
		if e.complexity.XgenSortInputXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenSortInputXgenDef.Field(childComplexity), true

	case "XgenSortInputXgenDef.object":
		if e.complexity.XgenSortInputXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenSortInputXgenDef.Object(childComplexity), true

	case "XgenSortResourceConfig.Default":
		if e.complexity.XgenSortResourceConfig.Default == nil {
			break
		}

		return e.complexity.XgenSortResourceConfig.Default(childComplexity), true

	case "XgenSortResourceConfig.Disabled":
		if e.complexity.XgenSortResourceConfig.Disabled == nil {
			break
		}

		return e.complexity.XgenSortResourceConfig.Disabled(childComplexity), true

	case "XgenSortResourceConfigInputXgenDef.field":
		if e.complexity.XgenSortResourceConfigInputXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenSortResourceConfigInputXgenDef.Field(childComplexity), true

	case "XgenSortResourceConfigInputXgenDef.object":
		if e.complexity.XgenSortResourceConfigInputXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenSortResourceConfigInputXgenDef.Object(childComplexity), true

	case "XgenSortResourceConfigXgenDef.field":
		if e.complexity.XgenSortResourceConfigXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenSortResourceConfigXgenDef.Field(childComplexity), true

	case "XgenSortResourceConfigXgenDef.object":
		if e.complexity.XgenSortResourceConfigXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenSortResourceConfigXgenDef.Object(childComplexity), true

	case "XgenSortXgenDef.field":
		if e.complexity.XgenSortXgenDef.Field == nil {
			break
		}

		return e.complexity.XgenSortXgenDef.Field(childComplexity), true

	case "XgenSortXgenDef.object":
		if e.complexity.XgenSortXgenDef.Object == nil {
			break
		}

		return e.complexity.XgenSortXgenDef.Object(childComplexity), true

	}
	return 0, false
}

func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
	rc := graphql.GetOperationContext(ctx)
	ec := executionContext{rc, e, 0, 0, make(chan graphql.DeferredResult)}
	inputUnmarshalMap := graphql.BuildUnmarshalerMap(
		ec.unmarshalInputCarBrowseInput,
		ec.unmarshalInputCarInput,
		ec.unmarshalInputCarSingleSortInput,
		ec.unmarshalInputCarSortInput,
		ec.unmarshalInputDeleteUsers,
		ec.unmarshalInputListUser,
		ec.unmarshalInputPhoneNumberBrowseInput,
		ec.unmarshalInputPhoneNumberInput,
		ec.unmarshalInputPhoneNumberSingleSortInput,
		ec.unmarshalInputPhoneNumberSortInput,
		ec.unmarshalInputUserInput,
		ec.unmarshalInputUserSingleSortInput,
		ec.unmarshalInputUserSortInput,
		ec.unmarshalInputXgenCursorPaginationInput,
		ec.unmarshalInputXgenPaginationInput,
		ec.unmarshalInputXgenResourceDbConfigInput,
		ec.unmarshalInputXgenResourceFieldDbConfigInput,
		ec.unmarshalInputXgenSortInput,
		ec.unmarshalInputXgenSortResourceConfigInput,
	)
	first := true

	switch rc.Operation.Operation {
	case ast.Query:
		return func(ctx context.Context) *graphql.Response {
			var response graphql.Response
			var data graphql.Marshaler
			if first {
				first = false
				ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
				data = ec._Query(ctx, rc.Operation.SelectionSet)
			} else {
				if atomic.LoadInt32(&ec.pendingDeferred) > 0 {
					result := <-ec.deferredResults
					atomic.AddInt32(&ec.pendingDeferred, -1)
					data = result.Result
					response.Path = result.Path
					response.Label = result.Label
					response.Errors = result.Errors
				} else {
					return nil
				}
			}
			var buf bytes.Buffer
			data.MarshalGQL(&buf)
			response.Data = buf.Bytes()
			if atomic.LoadInt32(&ec.deferred) > 0 {
				hasNext := atomic.LoadInt32(&ec.pendingDeferred) > 0
				response.HasNext = &hasNext
			}

			return &response
		}
	case ast.Mutation:
		return func(ctx context.Context) *graphql.Response {
			if !first {
				return nil
			}
			first = false
			ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
			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
	deferred        int32
	pendingDeferred int32
	deferredResults chan graphql.DeferredResult
}

func (ec *executionContext) processDeferredGroup(dg graphql.DeferredGroup) {
	atomic.AddInt32(&ec.pendingDeferred, 1)
	go func() {
		ctx := graphql.WithFreshResponseContext(dg.Context)
		dg.FieldSet.Dispatch(ctx)
		ds := graphql.DeferredResult{
			Path:   dg.Path,
			Label:  dg.Label,
			Result: dg.FieldSet,
			Errors: graphql.GetErrors(ctx),
		}
		// null fields should bubble up
		if dg.FieldSet.Invalids > 0 {
			ds.Result = graphql.Null
		}
		ec.deferredResults <- ds
	}()
}

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
}

//go:embed "generated_xgen_directives.graphql"
var sourcesFS embed.FS

func sourceData(filename string) string {
	data, err := sourcesFS.ReadFile(filename)
	if err != nil {
		panic(fmt.Sprintf("codegen problem: %s not available", filename))
	}
	return string(data)
}

var sources = []*ast.Source{
	{Name: "../schema.main.graphql", Input: `type User
@Resource(Name: "user", Primary: true, Route: "user", DB: {Table: "user"})
{
    id: ID! @Field(Label: "ID", Description: "ID of the user", DB: {Column: "id", PrimaryKey: true})
    name: String! @Field(Label: "Text", Description: "Text of the user", DB: {Column: "name", Unique: true})
    cars: [Car!]! @Field(Label: "Cars", Description: "Cars of the user", DB: {})
    phoneNumbers: [Phone!]! @Field(Label: "Phone Numbers", Description: "Phone numbers of the user", DB: {})
}

type Car
@Resource(Name: "car", Primary: true, Route: "car", DB: {Table: "car"})
{
    id: ID! @Field(Label: "ID", Description: "ID of the todo", DB: {Column: "id", PrimaryKey: true})
    make: String! @Field(Label: "Make", Description: "Car make", DB: {Column: "make"})
    done: Boolean! @Field(Label: "Done", Description: "Done of the todo", DB: {Column: "done"})
    user: User! @Field(Label: "User", Description: "User of the todo", DB: {})
}

input CarInput
@Action(Resource: "car", Action: CREATE_MUTATION, Route: "new")
@Action(Resource: "car", Action: UPDATE_MUTATION, Route: "update")
{
    id: ID @ActionField(Label: "ID", Description: "ID of the car", MapTo: ["Car.ID"])
    make: String @ActionField(Label: "Make", Description: "Text of the todo", MapTo: ["Car.Make"])
    done: Boolean @ActionField(Label: "Done", Description: "Done of the todo", MapTo: ["Car.Done"])
    user: UserInput @ActionField(Label: "User", Description: "User of the todo", MapTo: ["Car.User"])
}

input UserInput
@Action(Resource: "user", Action: CREATE_MUTATION, Route: "new")
@Action(Resource: "user", Action: UPDATE_MUTATION, Route: "update")
{
    id: ID @ActionField(Label: "ID", Description: "ID of the user", MapTo: ["User.ID"])
    name: String @ActionField(Label: "Name", Description: "Name", MapTo: ["User.Name"])
    cars: [CarInput!] @ActionField(Label: "Cars", Description: "Cars of the user", MapTo: ["User.Cars"])
    phones: [PhoneNumberInput!] @ActionField(Label: "Phone Numbers", Description: "Phone numbers of the user", MapTo: ["User.PhoneNumbers"])
}

input DeleteUsers
@ListAction(Resource: "user", Action: BATCH_DELETE_MUTATION, Route: "delete")
{
    ids: [ID!] @ActionField(Label: "IDs", Description: "IDs of users")
}

input ListUser
@ListAction(
    Resource: "user",
    Action: BROWSE_QUERY,
    Route: "list",
    Pagination: true,
    Sort: {Default: [{by: "name", direction: ASC}]},
)
{
    id: ID @ActionField(Label: "ID", Description: "ID", MapTo: ["User.ID"])
    name: String @ActionField(Label: "Name", Description: "Name", MapTo: ["User.Name"])
}

input CarBrowseInput
@ListAction(Resource: "car", Action: BROWSE_QUERY, Route: "list")
{
    id: ID @ActionField(Label: "ID", Description: "ID")
    userId: ID @ActionField(Label: "User ID", Description: "User ID")
    make: String @ActionField(Label: "Make", Description: "Make")
}

type Phone
@Resource(Name: "phone_number", Primary: true, Route: "phone-number", DB: {Table: "phone_number"})
{
    id: ID! @Field(Label: "ID", Description: "ID of the phone number", DB: {Column: "id", PrimaryKey: true})
    number: String! @Field(Label: "Number", Description: "Number of phone", DB: {Column: "number"})
    user: User! @Field(Label: "User", Description: "User of the todo", DB: {})
}

input PhoneNumberBrowseInput
@ListAction(Resource: "phone_number", Action: BROWSE_QUERY, Route: "list")
{
    id: ID @ActionField(Label: "ID", Description: "ID", MapTo: ["Phone.ID"])
    number: ID @ActionField(Label: "Number", Description: "Number of phone", MapTo: ["Phone.Number"])
}

input PhoneNumberInput
@Action(Resource: "phone_number", Action: CREATE_MUTATION, Route: "new")
@Action(Resource: "phone_number", Action: UPDATE_MUTATION, Route: "update")
{
    id: ID @ActionField(Label: "ID", Description: "ID of the phone number", MapTo: ["Phone.ID"])
    number: String @ActionField(Label: "Name", Description: "Number of phone", MapTo: ["Phone.Number"])
    user: UserInput @ActionField(Label: "User", Description: "User of the phone", MapTo: ["Phone.User"])
}`, BuiltIn: false},
	{Name: "generated_xgen_directives.graphql", Input: sourceData("generated_xgen_directives.graphql"), BuiltIn: false},
	{Name: "../../schema", Input: `type XgenIntrospection {
  annotation: XgenAnnotationMap
  object: XgenObjectMap
  resource: XgenResourceMap
}
"""This directive is used to mark the object as a resource action"""
type Action {
  Resource: String!
  Action: XgenResourceActionType!
  Route: String
  SchemaFieldName: String
}
"""This directive is used to mark the object as a resource field"""
type Field {
  Label: String
  Description: String
}
"""This directive is used to mark the object as a resource"""
type Resource {
  Name: String!
  Route: String
  Primary: Boolean
}
"""This directive is used to mark the object as a resource list action"""
type ListAction {
  Resource: String!
  Action: XgenResourceListActionType!
  Route: String
  Pagination: Boolean
  Sort: XgenSortResourceConfig
  SchemaFieldName: String
}
"""This directive is used to mark the object as a resource field"""
type ActionField {
  Label: String
  Description: String
  """Map field to resource field, {resource}.{field}, eg. user.id"""
  MapTo: [String!]
}
type XgenAnnotationMap {
  ListAction: [ListActionAnnotationSingle!]!
  Resource: [ResourceAnnotationSingle!]!
  Action: [ActionAnnotationSingle!]!
}
type ListActionAnnotationSingle {
  name: String
  value: ListAction
}
type ResourceAnnotationSingle {
  name: String
  value: Resource
}
type ActionAnnotationSingle {
  name: String
  value: Action
}
type XgenFieldDef {
  Field: Field
  ActionField: ActionField
}
type XgenObjectDefinition {
  Action: Action
  Resource: Resource
  ListAction: ListAction
}
type XgenObjectField {
  name: String
  definition: XgenFieldDef
}
type XgenObjectMap {
  XgenPaginationInput: XgenPaginationInputXgenDef
  XgenResourceFieldDbConfigInput: XgenResourceFieldDbConfigInputXgenDef
  XgenResourceListActionType: XgenResourceListActionTypeXgenDef
  XgenResourceActionType: XgenResourceActionTypeXgenDef
  CarInput: CarInputXgenDef
  ListUser: ListUserXgenDef
  Phone: PhoneXgenDef
  DeleteUsers: DeleteUsersXgenDef
  XgenSortInput: XgenSortInputXgenDef
  Car: CarXgenDef
  XgenCursorPaginationInput: XgenCursorPaginationInputXgenDef
  XgenSortResourceConfig: XgenSortResourceConfigXgenDef
  XgenResourceDbConfigInput: XgenResourceDbConfigInputXgenDef
  PhoneNumberBrowseInput: PhoneNumberBrowseInputXgenDef
  XgenSort: XgenSortXgenDef
  UserInput: UserInputXgenDef
  User: UserXgenDef
  CarBrowseInput: CarBrowseInputXgenDef
  XgenSortDirection: XgenSortDirectionXgenDef
  XgenSortResourceConfigInput: XgenSortResourceConfigInputXgenDef
  PhoneNumberInput: PhoneNumberInputXgenDef
}
type XgenPaginationInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenResourceFieldDbConfigInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenResourceListActionTypeXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenResourceActionTypeXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type CarInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type ListUserXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type PhoneXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type DeleteUsersXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenSortInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type CarXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenCursorPaginationInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenSortResourceConfigXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenResourceDbConfigInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type PhoneNumberBrowseInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenSortXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type UserInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type UserXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type CarBrowseInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenSortDirectionXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenSortResourceConfigInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type PhoneNumberInputXgenDef {
  object: XgenObjectDefinition
  field: [XgenObjectField!]!
}
type XgenResourceMap {
  user: XgenResourceDefinition
  phone_number: XgenResourceDefinition
  car: XgenResourceDefinition
}
type XgenResourceDefinition {
  objectName: String
  properties: XgenResourceProperty
  actions: [XgenResourceAction]!
}
type XgenResourceProperty {
  Name: String!
  Route: String
  Primary: Boolean
}
type XgenResourceAction {
  Resource: String!
  Action: XgenResourceActionType!
  Route: String
  SchemaFieldName: String
}
enum CAR_SORTABLE_FIELD {
  id
  make
  done
  user
}
input CarSingleSortInput {
  field: CAR_SORTABLE_FIELD!
  direction: XgenSortDirection
}
input CarSortInput {
  by: [CarSingleSortInput!]
}
enum PHONE_NUMBER_SORTABLE_FIELD {
  id
  number
  user
}
input PhoneNumberSingleSortInput {
  field: PHONE_NUMBER_SORTABLE_FIELD!
  direction: XgenSortDirection
}
input PhoneNumberSortInput {
  by: [PhoneNumberSingleSortInput!]
}
enum USER_SORTABLE_FIELD {
  id
  name
  cars
  phoneNumbers
}
input UserSingleSortInput {
  field: USER_SORTABLE_FIELD!
  direction: XgenSortDirection
}
input UserSortInput {
  by: [UserSingleSortInput!]
}
extend type Query {
  _xgen_introspection: XgenIntrospection
}
extend type Query {
  car_browse(where: CarBrowseInput): [Car]!
  user_browse(where: ListUser, pagination: XgenPaginationInput, sort: UserSortInput): [User]!
  phone_number_browse(where: PhoneNumberBrowseInput): [Phone]!
}
extend type Mutation {
  user_batch_delete(input: DeleteUsers): [User]!
  user_create(input: UserInput): User
  user_update(input: UserInput): User
  car_create(input: CarInput): Car
  car_update(input: CarInput): Car
  phone_number_create(input: PhoneNumberInput): Phone
  phone_number_update(input: PhoneNumberInput): Phone
}`, BuiltIn: false},
}
var parsedSchema = gqlparser.MustLoadSchema(sources...)

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

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

func (ec *executionContext) dir_ActionField_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["Label"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Label"))
		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Label"] = arg0
	var arg1 *string
	if tmp, ok := rawArgs["Description"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Description"))
		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Description"] = arg1
	var arg2 []string
	if tmp, ok := rawArgs["MapTo"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("MapTo"))
		arg2, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["MapTo"] = arg2
	return args, nil
}

func (ec *executionContext) dir_Action_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["Resource"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Resource"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Resource"] = arg0
	var arg1 XgenResourceActionType
	if tmp, ok := rawArgs["Action"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Action"))
		arg1, err = ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Action"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["Route"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Route"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Route"] = arg2
	var arg3 *string
	if tmp, ok := rawArgs["SchemaFieldName"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("SchemaFieldName"))
		arg3, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["SchemaFieldName"] = arg3
	return args, nil
}

func (ec *executionContext) dir_ExcludeArgumentFromType_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["exclude"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("exclude"))
		arg0, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["exclude"] = arg0
	return args, nil
}

func (ec *executionContext) dir_Field_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["Label"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Label"))
		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Label"] = arg0
	var arg1 *string
	if tmp, ok := rawArgs["Description"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Description"))
		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Description"] = arg1
	var arg2 *XgenResourceFieldDbConfigInput
	if tmp, ok := rawArgs["DB"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("DB"))
		arg2, err = ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["DB"] = arg2
	return args, nil
}

func (ec *executionContext) dir_ListAction_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["Resource"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Resource"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Resource"] = arg0
	var arg1 XgenResourceListActionType
	if tmp, ok := rawArgs["Action"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Action"))
		arg1, err = ec.unmarshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Action"] = arg1
	var arg2 *string
	if tmp, ok := rawArgs["Route"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Route"))
		arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Route"] = arg2
	var arg3 *bool
	if tmp, ok := rawArgs["Pagination"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Pagination"))
		arg3, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Pagination"] = arg3
	var arg4 *XgenSortResourceConfigInput
	if tmp, ok := rawArgs["Sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Sort"))
		arg4, err = ec.unmarshalOXgenSortResourceConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortResourceConfigInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Sort"] = arg4
	var arg5 *string
	if tmp, ok := rawArgs["SchemaFieldName"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("SchemaFieldName"))
		arg5, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["SchemaFieldName"] = arg5
	return args, nil
}

func (ec *executionContext) dir_Resource_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
	var arg1 *string
	if tmp, ok := rawArgs["Route"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Route"))
		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Route"] = arg1
	var arg2 *bool
	if tmp, ok := rawArgs["Primary"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Primary"))
		arg2, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["Primary"] = arg2
	var arg3 *XgenResourceDbConfigInput
	if tmp, ok := rawArgs["DB"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("DB"))
		arg3, err = ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["DB"] = arg3
	return args, nil
}

func (ec *executionContext) dir_ToObjectType_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["type"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("type"))
		arg0, err = ec.unmarshalNString2string(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["type"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_car_create_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *CarInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOCarInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_car_update_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *CarInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOCarInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_phone_number_create_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *PhoneNumberInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOPhoneNumberInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_phone_number_update_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *PhoneNumberInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOPhoneNumberInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_user_batch_delete_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *DeleteUsers
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalODeleteUsers2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐDeleteUsers(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_user_create_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *UserInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOUserInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	return args, nil
}

func (ec *executionContext) field_Mutation_user_update_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *UserInput
	if tmp, ok := rawArgs["input"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
		arg0, err = ec.unmarshalOUserInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["input"] = arg0
	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_car_browse_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *CarBrowseInput
	if tmp, ok := rawArgs["where"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("where"))
		arg0, err = ec.unmarshalOCarBrowseInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarBrowseInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["where"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_phone_number_browse_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *PhoneNumberBrowseInput
	if tmp, ok := rawArgs["where"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("where"))
		arg0, err = ec.unmarshalOPhoneNumberBrowseInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberBrowseInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["where"] = arg0
	return args, nil
}

func (ec *executionContext) field_Query_user_browse_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
	var err error
	args := map[string]interface{}{}
	var arg0 *ListUser
	if tmp, ok := rawArgs["where"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("where"))
		arg0, err = ec.unmarshalOListUser2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListUser(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["where"] = arg0
	var arg1 *XgenPaginationInput
	if tmp, ok := rawArgs["pagination"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("pagination"))
		arg1, err = ec.unmarshalOXgenPaginationInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenPaginationInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["pagination"] = arg1
	var arg2 *UserSortInput
	if tmp, ok := rawArgs["sort"]; ok {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sort"))
		arg2, err = ec.unmarshalOUserSortInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserSortInput(ctx, tmp)
		if err != nil {
			return nil, err
		}
	}
	args["sort"] = arg2
	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) _Action_Resource(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Action_Resource(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Resource, 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) fieldContext_Action_Resource(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Action",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Action_Action(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Action_Action(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Action, 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.(XgenResourceActionType)
	fc.Result = res
	return ec.marshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Action_Action(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Action",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type XgenResourceActionType does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Action_Route(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Action_Route(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Route, 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) fieldContext_Action_Route(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Action",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Action_SchemaFieldName(ctx context.Context, field graphql.CollectedField, obj *Action) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Action_SchemaFieldName(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SchemaFieldName, 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) fieldContext_Action_SchemaFieldName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Action",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ActionAnnotationSingle_name(ctx context.Context, field graphql.CollectedField, obj *ActionAnnotationSingle) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ActionAnnotationSingle_name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext_ActionAnnotationSingle_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ActionAnnotationSingle",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ActionAnnotationSingle_value(ctx context.Context, field graphql.CollectedField, obj *ActionAnnotationSingle) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ActionAnnotationSingle_value(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.(*Action)
	fc.Result = res
	return ec.marshalOAction2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐAction(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_ActionAnnotationSingle_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ActionAnnotationSingle",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Resource":
				return ec.fieldContext_Action_Resource(ctx, field)
			case "Action":
				return ec.fieldContext_Action_Action(ctx, field)
			case "Route":
				return ec.fieldContext_Action_Route(ctx, field)
			case "SchemaFieldName":
				return ec.fieldContext_Action_SchemaFieldName(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Action", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _ActionField_Label(ctx context.Context, field graphql.CollectedField, obj *ActionField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ActionField_Label(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Label, 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) fieldContext_ActionField_Label(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ActionField",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ActionField_Description(ctx context.Context, field graphql.CollectedField, obj *ActionField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ActionField_Description(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_ActionField_Description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ActionField",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ActionField_MapTo(ctx context.Context, field graphql.CollectedField, obj *ActionField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ActionField_MapTo(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.MapTo, 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) fieldContext_ActionField_MapTo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ActionField",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Car_id(ctx context.Context, field graphql.CollectedField, obj *Car) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Car_id(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.ID, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "ID of the todo")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{"Column": "id", "PrimaryKey": true})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive0, label, description, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(int); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be int`, tmp)
	})
	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.marshalNID2int(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Car_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Car",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Car_make(ctx context.Context, field graphql.CollectedField, obj *Car) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Car_make(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.Make, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "Make")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "Car make")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{"Column": "make"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive0, label, description, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(string); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
	})
	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) fieldContext_Car_make(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Car",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Car_done(ctx context.Context, field graphql.CollectedField, obj *Car) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Car_done(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.Done, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "Done")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "Done of the todo")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{"Column": "done"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive0, label, description, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(bool); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be bool`, tmp)
	})
	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) fieldContext_Car_done(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Car",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Car_user(ctx context.Context, field graphql.CollectedField, obj *Car) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Car_user(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.User, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "user")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "user")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "user"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, obj, directive0, name, route, primary, db)
		}
		directive2 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "User")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "User of the todo")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive1, label, description, db)
		}

		tmp, err := directive2(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*User); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.User`, tmp)
	})
	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ᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Car_user(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Car",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_User_id(ctx, field)
			case "name":
				return ec.fieldContext_User_name(ctx, field)
			case "cars":
				return ec.fieldContext_User_cars(ctx, field)
			case "phoneNumbers":
				return ec.fieldContext_User_phoneNumbers(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CarBrowseInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *CarBrowseInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_CarBrowseInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_CarBrowseInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CarBrowseInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CarBrowseInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *CarBrowseInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_CarBrowseInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_CarBrowseInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CarBrowseInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CarInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *CarInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_CarInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_CarInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CarInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CarInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *CarInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_CarInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_CarInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CarInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CarXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *CarXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_CarXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_CarXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CarXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _CarXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *CarXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_CarXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_CarXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "CarXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _DeleteUsersXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *DeleteUsersXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_DeleteUsersXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_DeleteUsersXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "DeleteUsersXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _DeleteUsersXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *DeleteUsersXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_DeleteUsersXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_DeleteUsersXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "DeleteUsersXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Field_Label(ctx context.Context, field graphql.CollectedField, obj *Field) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Field_Label(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Label, 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) fieldContext_Field_Label(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Field",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Field_Description(ctx context.Context, field graphql.CollectedField, obj *Field) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Field_Description(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Field_Description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Field",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ListAction_Resource(ctx context.Context, field graphql.CollectedField, obj *ListAction) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ListAction_Resource(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Resource, 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) fieldContext_ListAction_Resource(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ListAction",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ListAction_Action(ctx context.Context, field graphql.CollectedField, obj *ListAction) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ListAction_Action(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Action, 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.(XgenResourceListActionType)
	fc.Result = res
	return ec.marshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_ListAction_Action(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ListAction",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type XgenResourceListActionType does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ListAction_Route(ctx context.Context, field graphql.CollectedField, obj *ListAction) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ListAction_Route(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Route, 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) fieldContext_ListAction_Route(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ListAction",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ListAction_Pagination(ctx context.Context, field graphql.CollectedField, obj *ListAction) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ListAction_Pagination(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Pagination, 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) fieldContext_ListAction_Pagination(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ListAction",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ListAction_Sort(ctx context.Context, field graphql.CollectedField, obj *ListAction) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ListAction_Sort(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Sort, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenSortResourceConfig)
	fc.Result = res
	return ec.marshalOXgenSortResourceConfig2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortResourceConfig(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_ListAction_Sort(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ListAction",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Disabled":
				return ec.fieldContext_XgenSortResourceConfig_Disabled(ctx, field)
			case "Default":
				return ec.fieldContext_XgenSortResourceConfig_Default(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenSortResourceConfig", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _ListAction_SchemaFieldName(ctx context.Context, field graphql.CollectedField, obj *ListAction) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ListAction_SchemaFieldName(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SchemaFieldName, 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) fieldContext_ListAction_SchemaFieldName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ListAction",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ListActionAnnotationSingle_name(ctx context.Context, field graphql.CollectedField, obj *ListActionAnnotationSingle) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ListActionAnnotationSingle_name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext_ListActionAnnotationSingle_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ListActionAnnotationSingle",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ListActionAnnotationSingle_value(ctx context.Context, field graphql.CollectedField, obj *ListActionAnnotationSingle) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ListActionAnnotationSingle_value(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.(*ListAction)
	fc.Result = res
	return ec.marshalOListAction2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListAction(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_ListActionAnnotationSingle_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ListActionAnnotationSingle",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Resource":
				return ec.fieldContext_ListAction_Resource(ctx, field)
			case "Action":
				return ec.fieldContext_ListAction_Action(ctx, field)
			case "Route":
				return ec.fieldContext_ListAction_Route(ctx, field)
			case "Pagination":
				return ec.fieldContext_ListAction_Pagination(ctx, field)
			case "Sort":
				return ec.fieldContext_ListAction_Sort(ctx, field)
			case "SchemaFieldName":
				return ec.fieldContext_ListAction_SchemaFieldName(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ListAction", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _ListUserXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *ListUserXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ListUserXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_ListUserXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ListUserXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _ListUserXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *ListUserXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ListUserXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_ListUserXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ListUserXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_user_batch_delete(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Mutation_user_batch_delete(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UserBatchDelete(rctx, fc.Args["input"].(*DeleteUsers))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "user")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "user")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "user"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, nil, directive0, name, route, primary, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.([]*User); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.User`, tmp)
	})
	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ᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Mutation_user_batch_delete(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_User_id(ctx, field)
			case "name":
				return ec.fieldContext_User_name(ctx, field)
			case "cars":
				return ec.fieldContext_User_cars(ctx, field)
			case "phoneNumbers":
				return ec.fieldContext_User_phoneNumbers(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_user_batch_delete_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_user_create(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Mutation_user_create(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UserCreate(rctx, fc.Args["input"].(*UserInput))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "user")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "user")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "user"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, nil, directive0, name, route, primary, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*User); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.User`, tmp)
	})
	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ᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Mutation_user_create(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_User_id(ctx, field)
			case "name":
				return ec.fieldContext_User_name(ctx, field)
			case "cars":
				return ec.fieldContext_User_cars(ctx, field)
			case "phoneNumbers":
				return ec.fieldContext_User_phoneNumbers(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_user_create_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_user_update(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Mutation_user_update(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().UserUpdate(rctx, fc.Args["input"].(*UserInput))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "user")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "user")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "user"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, nil, directive0, name, route, primary, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*User); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.User`, tmp)
	})
	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ᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Mutation_user_update(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_User_id(ctx, field)
			case "name":
				return ec.fieldContext_User_name(ctx, field)
			case "cars":
				return ec.fieldContext_User_cars(ctx, field)
			case "phoneNumbers":
				return ec.fieldContext_User_phoneNumbers(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_user_update_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_car_create(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Mutation_car_create(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().CarCreate(rctx, fc.Args["input"].(*CarInput))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "car")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "car")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "car"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, nil, directive0, name, route, primary, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*Car); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.Car`, tmp)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Car)
	fc.Result = res
	return ec.marshalOCar2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCar(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Mutation_car_create(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Car_id(ctx, field)
			case "make":
				return ec.fieldContext_Car_make(ctx, field)
			case "done":
				return ec.fieldContext_Car_done(ctx, field)
			case "user":
				return ec.fieldContext_Car_user(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Car", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_car_create_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_car_update(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Mutation_car_update(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().CarUpdate(rctx, fc.Args["input"].(*CarInput))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "car")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "car")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "car"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, nil, directive0, name, route, primary, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*Car); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.Car`, tmp)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Car)
	fc.Result = res
	return ec.marshalOCar2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCar(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Mutation_car_update(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Car_id(ctx, field)
			case "make":
				return ec.fieldContext_Car_make(ctx, field)
			case "done":
				return ec.fieldContext_Car_done(ctx, field)
			case "user":
				return ec.fieldContext_Car_user(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Car", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_car_update_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_phone_number_create(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Mutation_phone_number_create(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().PhoneNumberCreate(rctx, fc.Args["input"].(*PhoneNumberInput))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "phone_number")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "phone-number")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "phone_number"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, nil, directive0, name, route, primary, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*Phone); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.Phone`, tmp)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Phone)
	fc.Result = res
	return ec.marshalOPhone2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhone(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Mutation_phone_number_create(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Phone_id(ctx, field)
			case "number":
				return ec.fieldContext_Phone_number(ctx, field)
			case "user":
				return ec.fieldContext_Phone_user(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Phone", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_phone_number_create_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Mutation_phone_number_update(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Mutation_phone_number_update(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Mutation().PhoneNumberUpdate(rctx, fc.Args["input"].(*PhoneNumberInput))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "phone_number")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "phone-number")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "phone_number"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, nil, directive0, name, route, primary, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*Phone); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.Phone`, tmp)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Phone)
	fc.Result = res
	return ec.marshalOPhone2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhone(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Mutation_phone_number_update(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Mutation",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Phone_id(ctx, field)
			case "number":
				return ec.fieldContext_Phone_number(ctx, field)
			case "user":
				return ec.fieldContext_Phone_user(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Phone", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Mutation_phone_number_update_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Phone_id(ctx context.Context, field graphql.CollectedField, obj *Phone) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Phone_id(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.ID, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "ID of the phone number")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{"Column": "id", "PrimaryKey": true})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive0, label, description, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(int); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be int`, tmp)
	})
	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.marshalNID2int(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Phone_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Phone",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Phone_number(ctx context.Context, field graphql.CollectedField, obj *Phone) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Phone_number(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.Number, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "Number")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "Number of phone")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{"Column": "number"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive0, label, description, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(string); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
	})
	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) fieldContext_Phone_number(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Phone",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Phone_user(ctx context.Context, field graphql.CollectedField, obj *Phone) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Phone_user(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.User, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "user")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "user")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "user"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, obj, directive0, name, route, primary, db)
		}
		directive2 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "User")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "User of the todo")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive1, label, description, db)
		}

		tmp, err := directive2(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(*User); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.User`, tmp)
	})
	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ᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Phone_user(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Phone",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_User_id(ctx, field)
			case "name":
				return ec.fieldContext_User_name(ctx, field)
			case "cars":
				return ec.fieldContext_User_cars(ctx, field)
			case "phoneNumbers":
				return ec.fieldContext_User_phoneNumbers(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PhoneNumberBrowseInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *PhoneNumberBrowseInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_PhoneNumberBrowseInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_PhoneNumberBrowseInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PhoneNumberBrowseInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PhoneNumberBrowseInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *PhoneNumberBrowseInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_PhoneNumberBrowseInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_PhoneNumberBrowseInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PhoneNumberBrowseInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PhoneNumberInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *PhoneNumberInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_PhoneNumberInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_PhoneNumberInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PhoneNumberInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PhoneNumberInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *PhoneNumberInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_PhoneNumberInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_PhoneNumberInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PhoneNumberInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PhoneXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *PhoneXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_PhoneXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_PhoneXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PhoneXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _PhoneXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *PhoneXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_PhoneXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_PhoneXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "PhoneXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Query__xgen_introspection(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Query__xgen_introspection(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.resolvers.Query().XgenIntrospection(rctx)
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenIntrospection)
	fc.Result = res
	return ec.marshalOXgenIntrospection2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenIntrospection(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Query__xgen_introspection(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "annotation":
				return ec.fieldContext_XgenIntrospection_annotation(ctx, field)
			case "object":
				return ec.fieldContext_XgenIntrospection_object(ctx, field)
			case "resource":
				return ec.fieldContext_XgenIntrospection_resource(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenIntrospection", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Query_car_browse(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Query_car_browse(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().CarBrowse(rctx, fc.Args["where"].(*CarBrowseInput))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "car")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "car")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "car"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, nil, directive0, name, route, primary, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.([]*Car); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.Car`, tmp)
	})
	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.([]*Car)
	fc.Result = res
	return ec.marshalNCar2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCar(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Query_car_browse(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Car_id(ctx, field)
			case "make":
				return ec.fieldContext_Car_make(ctx, field)
			case "done":
				return ec.fieldContext_Car_done(ctx, field)
			case "user":
				return ec.fieldContext_Car_user(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Car", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_car_browse_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_user_browse(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Query_user_browse(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().UserBrowse(rctx, fc.Args["where"].(*ListUser), fc.Args["pagination"].(*XgenPaginationInput), fc.Args["sort"].(*UserSortInput))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "user")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "user")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "user"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, nil, directive0, name, route, primary, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.([]*User); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.User`, tmp)
	})
	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ᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUser(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Query_user_browse(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_User_id(ctx, field)
			case "name":
				return ec.fieldContext_User_name(ctx, field)
			case "cars":
				return ec.fieldContext_User_cars(ctx, field)
			case "phoneNumbers":
				return ec.fieldContext_User_phoneNumbers(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_user_browse_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query_phone_number_browse(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Query_phone_number_browse(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return ec.resolvers.Query().PhoneNumberBrowse(rctx, fc.Args["where"].(*PhoneNumberBrowseInput))
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "phone_number")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "phone-number")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "phone_number"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, nil, directive0, name, route, primary, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.([]*Phone); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.Phone`, tmp)
	})
	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.([]*Phone)
	fc.Result = res
	return ec.marshalNPhone2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhone(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_Query_phone_number_browse(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: true,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Phone_id(ctx, field)
			case "number":
				return ec.fieldContext_Phone_number(ctx, field)
			case "user":
				return ec.fieldContext_Phone_user(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Phone", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query_phone_number_browse_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Query___type(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return ec.introspectType(fc.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) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Query___schema(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext_Query___schema(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Query",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "description":
				return ec.fieldContext___Schema_description(ctx, field)
			case "types":
				return ec.fieldContext___Schema_types(ctx, field)
			case "queryType":
				return ec.fieldContext___Schema_queryType(ctx, field)
			case "mutationType":
				return ec.fieldContext___Schema_mutationType(ctx, field)
			case "subscriptionType":
				return ec.fieldContext___Schema_subscriptionType(ctx, field)
			case "directives":
				return ec.fieldContext___Schema_directives(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _Resource_Name(ctx context.Context, field graphql.CollectedField, obj *Resource) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Resource_Name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext_Resource_Name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Resource",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Resource_Route(ctx context.Context, field graphql.CollectedField, obj *Resource) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Resource_Route(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Route, 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) fieldContext_Resource_Route(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Resource",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _Resource_Primary(ctx context.Context, field graphql.CollectedField, obj *Resource) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_Resource_Primary(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Primary, 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) fieldContext_Resource_Primary(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "Resource",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ResourceAnnotationSingle_name(ctx context.Context, field graphql.CollectedField, obj *ResourceAnnotationSingle) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ResourceAnnotationSingle_name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext_ResourceAnnotationSingle_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ResourceAnnotationSingle",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _ResourceAnnotationSingle_value(ctx context.Context, field graphql.CollectedField, obj *ResourceAnnotationSingle) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_ResourceAnnotationSingle_value(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.(*Resource)
	fc.Result = res
	return ec.marshalOResource2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐResource(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_ResourceAnnotationSingle_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "ResourceAnnotationSingle",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Name":
				return ec.fieldContext_Resource_Name(ctx, field)
			case "Route":
				return ec.fieldContext_Resource_Route(ctx, field)
			case "Primary":
				return ec.fieldContext_Resource_Primary(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Resource", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_User_id(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.ID, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "ID of the user")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{"Column": "id", "PrimaryKey": true})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive0, label, description, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(int); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be int`, tmp)
	})
	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.marshalNID2int(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_User_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type ID does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _User_name(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_User_name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.Name, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "Text")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "Text of the user")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{"Column": "name", "Unique": true})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive0, label, description, db)
		}

		tmp, err := directive1(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.(string); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
	})
	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) fieldContext_User_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _User_cars(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_User_cars(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.Cars, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "car")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "car")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "car"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, obj, directive0, name, route, primary, db)
		}
		directive2 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "Cars")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "Cars of the user")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive1, label, description, db)
		}

		tmp, err := directive2(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.([]*Car); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.Car`, tmp)
	})
	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.([]*Car)
	fc.Result = res
	return ec.marshalNCar2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_User_cars(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Car_id(ctx, field)
			case "make":
				return ec.fieldContext_Car_make(ctx, field)
			case "done":
				return ec.fieldContext_Car_done(ctx, field)
			case "user":
				return ec.fieldContext_Car_user(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Car", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _User_phoneNumbers(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_User_phoneNumbers(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		directive0 := func(rctx context.Context) (interface{}, error) {
			ctx = rctx // use context from middleware stack in children
			return obj.PhoneNumbers, nil
		}
		directive1 := func(ctx context.Context) (interface{}, error) {
			name, err := ec.unmarshalNString2string(ctx, "phone_number")
			if err != nil {
				return nil, err
			}
			route, err := ec.unmarshalOString2ᚖstring(ctx, "phone-number")
			if err != nil {
				return nil, err
			}
			primary, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx, map[string]interface{}{"Table": "phone_number"})
			if err != nil {
				return nil, err
			}
			if ec.directives.Resource == nil {
				return nil, errors.New("directive Resource is not implemented")
			}
			return ec.directives.Resource(ctx, obj, directive0, name, route, primary, db)
		}
		directive2 := func(ctx context.Context) (interface{}, error) {
			label, err := ec.unmarshalOString2ᚖstring(ctx, "Phone Numbers")
			if err != nil {
				return nil, err
			}
			description, err := ec.unmarshalOString2ᚖstring(ctx, "Phone numbers of the user")
			if err != nil {
				return nil, err
			}
			db, err := ec.unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx, map[string]interface{}{})
			if err != nil {
				return nil, err
			}
			if ec.directives.Field == nil {
				return nil, errors.New("directive Field is not implemented")
			}
			return ec.directives.Field(ctx, obj, directive1, label, description, db)
		}

		tmp, err := directive2(rctx)
		if err != nil {
			return nil, graphql.ErrorOnPath(ctx, err)
		}
		if tmp == nil {
			return nil, nil
		}
		if data, ok := tmp.([]*Phone); ok {
			return data, nil
		}
		return nil, fmt.Errorf(`unexpected type %T from directive, should be []*github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.Phone`, tmp)
	})
	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.([]*Phone)
	fc.Result = res
	return ec.marshalNPhone2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_User_phoneNumbers(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "User",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Phone_id(ctx, field)
			case "number":
				return ec.fieldContext_Phone_number(ctx, field)
			case "user":
				return ec.fieldContext_Phone_user(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Phone", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _UserInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *UserInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_UserInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_UserInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "UserInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _UserInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *UserInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_UserInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_UserInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "UserInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _UserXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *UserXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_UserXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_UserXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "UserXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _UserXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *UserXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_UserXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_UserXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "UserXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenAnnotationMap_ListAction(ctx context.Context, field graphql.CollectedField, obj *XgenAnnotationMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenAnnotationMap_ListAction(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ListAction, 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.([]*ListActionAnnotationSingle)
	fc.Result = res
	return ec.marshalNListActionAnnotationSingle2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListActionAnnotationSingleᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenAnnotationMap_ListAction(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenAnnotationMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_ListActionAnnotationSingle_name(ctx, field)
			case "value":
				return ec.fieldContext_ListActionAnnotationSingle_value(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ListActionAnnotationSingle", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenAnnotationMap_Resource(ctx context.Context, field graphql.CollectedField, obj *XgenAnnotationMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenAnnotationMap_Resource(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Resource, 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.([]*ResourceAnnotationSingle)
	fc.Result = res
	return ec.marshalNResourceAnnotationSingle2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐResourceAnnotationSingleᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenAnnotationMap_Resource(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenAnnotationMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_ResourceAnnotationSingle_name(ctx, field)
			case "value":
				return ec.fieldContext_ResourceAnnotationSingle_value(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ResourceAnnotationSingle", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenAnnotationMap_Action(ctx context.Context, field graphql.CollectedField, obj *XgenAnnotationMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenAnnotationMap_Action(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Action, 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.([]*ActionAnnotationSingle)
	fc.Result = res
	return ec.marshalNActionAnnotationSingle2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐActionAnnotationSingleᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenAnnotationMap_Action(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenAnnotationMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_ActionAnnotationSingle_name(ctx, field)
			case "value":
				return ec.fieldContext_ActionAnnotationSingle_value(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ActionAnnotationSingle", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenCursorPaginationInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenCursorPaginationInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenCursorPaginationInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenCursorPaginationInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenCursorPaginationInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenCursorPaginationInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenCursorPaginationInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenCursorPaginationInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenCursorPaginationInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenCursorPaginationInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenFieldDef_Field(ctx context.Context, field graphql.CollectedField, obj *XgenFieldDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenFieldDef_Field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Field)
	fc.Result = res
	return ec.marshalOField2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐField(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenFieldDef_Field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenFieldDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Label":
				return ec.fieldContext_Field_Label(ctx, field)
			case "Description":
				return ec.fieldContext_Field_Description(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Field", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenFieldDef_ActionField(ctx context.Context, field graphql.CollectedField, obj *XgenFieldDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenFieldDef_ActionField(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ActionField, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*ActionField)
	fc.Result = res
	return ec.marshalOActionField2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐActionField(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenFieldDef_ActionField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenFieldDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Label":
				return ec.fieldContext_ActionField_Label(ctx, field)
			case "Description":
				return ec.fieldContext_ActionField_Description(ctx, field)
			case "MapTo":
				return ec.fieldContext_ActionField_MapTo(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ActionField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenIntrospection_annotation(ctx context.Context, field graphql.CollectedField, obj *XgenIntrospection) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenIntrospection_annotation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Annotation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenAnnotationMap)
	fc.Result = res
	return ec.marshalOXgenAnnotationMap2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenAnnotationMap(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenIntrospection_annotation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenIntrospection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "ListAction":
				return ec.fieldContext_XgenAnnotationMap_ListAction(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenAnnotationMap_Resource(ctx, field)
			case "Action":
				return ec.fieldContext_XgenAnnotationMap_Action(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenAnnotationMap", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenIntrospection_object(ctx context.Context, field graphql.CollectedField, obj *XgenIntrospection) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenIntrospection_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectMap)
	fc.Result = res
	return ec.marshalOXgenObjectMap2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectMap(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenIntrospection_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenIntrospection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "XgenPaginationInput":
				return ec.fieldContext_XgenObjectMap_XgenPaginationInput(ctx, field)
			case "XgenResourceFieldDbConfigInput":
				return ec.fieldContext_XgenObjectMap_XgenResourceFieldDbConfigInput(ctx, field)
			case "XgenResourceListActionType":
				return ec.fieldContext_XgenObjectMap_XgenResourceListActionType(ctx, field)
			case "XgenResourceActionType":
				return ec.fieldContext_XgenObjectMap_XgenResourceActionType(ctx, field)
			case "CarInput":
				return ec.fieldContext_XgenObjectMap_CarInput(ctx, field)
			case "ListUser":
				return ec.fieldContext_XgenObjectMap_ListUser(ctx, field)
			case "Phone":
				return ec.fieldContext_XgenObjectMap_Phone(ctx, field)
			case "DeleteUsers":
				return ec.fieldContext_XgenObjectMap_DeleteUsers(ctx, field)
			case "XgenSortInput":
				return ec.fieldContext_XgenObjectMap_XgenSortInput(ctx, field)
			case "Car":
				return ec.fieldContext_XgenObjectMap_Car(ctx, field)
			case "XgenCursorPaginationInput":
				return ec.fieldContext_XgenObjectMap_XgenCursorPaginationInput(ctx, field)
			case "XgenSortResourceConfig":
				return ec.fieldContext_XgenObjectMap_XgenSortResourceConfig(ctx, field)
			case "XgenResourceDbConfigInput":
				return ec.fieldContext_XgenObjectMap_XgenResourceDbConfigInput(ctx, field)
			case "PhoneNumberBrowseInput":
				return ec.fieldContext_XgenObjectMap_PhoneNumberBrowseInput(ctx, field)
			case "XgenSort":
				return ec.fieldContext_XgenObjectMap_XgenSort(ctx, field)
			case "UserInput":
				return ec.fieldContext_XgenObjectMap_UserInput(ctx, field)
			case "User":
				return ec.fieldContext_XgenObjectMap_User(ctx, field)
			case "CarBrowseInput":
				return ec.fieldContext_XgenObjectMap_CarBrowseInput(ctx, field)
			case "XgenSortDirection":
				return ec.fieldContext_XgenObjectMap_XgenSortDirection(ctx, field)
			case "XgenSortResourceConfigInput":
				return ec.fieldContext_XgenObjectMap_XgenSortResourceConfigInput(ctx, field)
			case "PhoneNumberInput":
				return ec.fieldContext_XgenObjectMap_PhoneNumberInput(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectMap", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenIntrospection_resource(ctx context.Context, field graphql.CollectedField, obj *XgenIntrospection) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenIntrospection_resource(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Resource, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenResourceMap)
	fc.Result = res
	return ec.marshalOXgenResourceMap2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceMap(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenIntrospection_resource(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenIntrospection",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "user":
				return ec.fieldContext_XgenResourceMap_user(ctx, field)
			case "phone_number":
				return ec.fieldContext_XgenResourceMap_phone_number(ctx, field)
			case "car":
				return ec.fieldContext_XgenResourceMap_car(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenResourceMap", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectDefinition_Action(ctx context.Context, field graphql.CollectedField, obj *XgenObjectDefinition) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Action, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Action)
	fc.Result = res
	return ec.marshalOAction2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐAction(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectDefinition_Action(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectDefinition",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Resource":
				return ec.fieldContext_Action_Resource(ctx, field)
			case "Action":
				return ec.fieldContext_Action_Action(ctx, field)
			case "Route":
				return ec.fieldContext_Action_Route(ctx, field)
			case "SchemaFieldName":
				return ec.fieldContext_Action_SchemaFieldName(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Action", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectDefinition_Resource(ctx context.Context, field graphql.CollectedField, obj *XgenObjectDefinition) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Resource, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*Resource)
	fc.Result = res
	return ec.marshalOResource2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐResource(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectDefinition_Resource(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectDefinition",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Name":
				return ec.fieldContext_Resource_Name(ctx, field)
			case "Route":
				return ec.fieldContext_Resource_Route(ctx, field)
			case "Primary":
				return ec.fieldContext_Resource_Primary(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Resource", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectDefinition_ListAction(ctx context.Context, field graphql.CollectedField, obj *XgenObjectDefinition) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ListAction, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*ListAction)
	fc.Result = res
	return ec.marshalOListAction2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListAction(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectDefinition_ListAction(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectDefinition",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Resource":
				return ec.fieldContext_ListAction_Resource(ctx, field)
			case "Action":
				return ec.fieldContext_ListAction_Action(ctx, field)
			case "Route":
				return ec.fieldContext_ListAction_Route(ctx, field)
			case "Pagination":
				return ec.fieldContext_ListAction_Pagination(ctx, field)
			case "Sort":
				return ec.fieldContext_ListAction_Sort(ctx, field)
			case "SchemaFieldName":
				return ec.fieldContext_ListAction_SchemaFieldName(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ListAction", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectField_name(ctx context.Context, field graphql.CollectedField, obj *XgenObjectField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectField_name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext_XgenObjectField_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectField",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectField_definition(ctx context.Context, field graphql.CollectedField, obj *XgenObjectField) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectField_definition(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Definition, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenFieldDef)
	fc.Result = res
	return ec.marshalOXgenFieldDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenFieldDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectField_definition(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectField",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Field":
				return ec.fieldContext_XgenFieldDef_Field(ctx, field)
			case "ActionField":
				return ec.fieldContext_XgenFieldDef_ActionField(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenFieldDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenPaginationInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenPaginationInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenPaginationInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenPaginationInputXgenDef)
	fc.Result = res
	return ec.marshalOXgenPaginationInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenPaginationInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenPaginationInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenPaginationInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenPaginationInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenPaginationInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenResourceFieldDbConfigInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenResourceFieldDbConfigInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenResourceFieldDbConfigInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenResourceFieldDbConfigInputXgenDef)
	fc.Result = res
	return ec.marshalOXgenResourceFieldDbConfigInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenResourceFieldDbConfigInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenResourceFieldDbConfigInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenResourceFieldDbConfigInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenResourceFieldDbConfigInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenResourceListActionType(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenResourceListActionType(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenResourceListActionType, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenResourceListActionTypeXgenDef)
	fc.Result = res
	return ec.marshalOXgenResourceListActionTypeXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionTypeXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenResourceListActionType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenResourceListActionTypeXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenResourceListActionTypeXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenResourceListActionTypeXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenResourceActionType(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenResourceActionType(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenResourceActionType, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenResourceActionTypeXgenDef)
	fc.Result = res
	return ec.marshalOXgenResourceActionTypeXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionTypeXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenResourceActionType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenResourceActionTypeXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenResourceActionTypeXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenResourceActionTypeXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_CarInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_CarInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CarInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*CarInputXgenDef)
	fc.Result = res
	return ec.marshalOCarInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_CarInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_CarInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_CarInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type CarInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_ListUser(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_ListUser(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ListUser, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*ListUserXgenDef)
	fc.Result = res
	return ec.marshalOListUserXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListUserXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_ListUser(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_ListUserXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_ListUserXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type ListUserXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_Phone(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_Phone(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Phone, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*PhoneXgenDef)
	fc.Result = res
	return ec.marshalOPhoneXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_Phone(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_PhoneXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_PhoneXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PhoneXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_DeleteUsers(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_DeleteUsers(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.DeleteUsers, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*DeleteUsersXgenDef)
	fc.Result = res
	return ec.marshalODeleteUsersXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐDeleteUsersXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_DeleteUsers(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_DeleteUsersXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_DeleteUsersXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type DeleteUsersXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenSortInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenSortInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenSortInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenSortInputXgenDef)
	fc.Result = res
	return ec.marshalOXgenSortInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenSortInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenSortInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenSortInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenSortInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_Car(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_Car(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Car, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*CarXgenDef)
	fc.Result = res
	return ec.marshalOCarXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_Car(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_CarXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_CarXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type CarXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenCursorPaginationInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenCursorPaginationInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenCursorPaginationInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenCursorPaginationInputXgenDef)
	fc.Result = res
	return ec.marshalOXgenCursorPaginationInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenCursorPaginationInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenCursorPaginationInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenCursorPaginationInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenCursorPaginationInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenCursorPaginationInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenSortResourceConfig(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenSortResourceConfig(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenSortResourceConfig, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenSortResourceConfigXgenDef)
	fc.Result = res
	return ec.marshalOXgenSortResourceConfigXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortResourceConfigXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenSortResourceConfig(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenSortResourceConfigXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenSortResourceConfigXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenSortResourceConfigXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenResourceDbConfigInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenResourceDbConfigInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenResourceDbConfigInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenResourceDbConfigInputXgenDef)
	fc.Result = res
	return ec.marshalOXgenResourceDbConfigInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenResourceDbConfigInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenResourceDbConfigInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenResourceDbConfigInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenResourceDbConfigInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_PhoneNumberBrowseInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_PhoneNumberBrowseInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PhoneNumberBrowseInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*PhoneNumberBrowseInputXgenDef)
	fc.Result = res
	return ec.marshalOPhoneNumberBrowseInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberBrowseInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_PhoneNumberBrowseInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_PhoneNumberBrowseInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_PhoneNumberBrowseInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PhoneNumberBrowseInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenSort(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenSort(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenSort, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenSortXgenDef)
	fc.Result = res
	return ec.marshalOXgenSortXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenSort(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenSortXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenSortXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenSortXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_UserInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_UserInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.UserInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*UserInputXgenDef)
	fc.Result = res
	return ec.marshalOUserInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_UserInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_UserInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_UserInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type UserInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_User(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_User(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.User, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*UserXgenDef)
	fc.Result = res
	return ec.marshalOUserXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_User(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_UserXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_UserXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type UserXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_CarBrowseInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_CarBrowseInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CarBrowseInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*CarBrowseInputXgenDef)
	fc.Result = res
	return ec.marshalOCarBrowseInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarBrowseInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_CarBrowseInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_CarBrowseInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_CarBrowseInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type CarBrowseInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenSortDirection(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenSortDirection(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenSortDirection, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenSortDirectionXgenDef)
	fc.Result = res
	return ec.marshalOXgenSortDirectionXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortDirectionXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenSortDirection(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenSortDirectionXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenSortDirectionXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenSortDirectionXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_XgenSortResourceConfigInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_XgenSortResourceConfigInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.XgenSortResourceConfigInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenSortResourceConfigInputXgenDef)
	fc.Result = res
	return ec.marshalOXgenSortResourceConfigInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortResourceConfigInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_XgenSortResourceConfigInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_XgenSortResourceConfigInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_XgenSortResourceConfigInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenSortResourceConfigInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenObjectMap_PhoneNumberInput(ctx context.Context, field graphql.CollectedField, obj *XgenObjectMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenObjectMap_PhoneNumberInput(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PhoneNumberInput, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*PhoneNumberInputXgenDef)
	fc.Result = res
	return ec.marshalOPhoneNumberInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberInputXgenDef(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenObjectMap_PhoneNumberInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenObjectMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "object":
				return ec.fieldContext_PhoneNumberInputXgenDef_object(ctx, field)
			case "field":
				return ec.fieldContext_PhoneNumberInputXgenDef_field(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type PhoneNumberInputXgenDef", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenPaginationInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenPaginationInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenPaginationInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenPaginationInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenPaginationInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenPaginationInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenPaginationInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenPaginationInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenPaginationInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenPaginationInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceAction_Resource(ctx context.Context, field graphql.CollectedField, obj *XgenResourceAction) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceAction_Resource(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Resource, 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) fieldContext_XgenResourceAction_Resource(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceAction",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceAction_Action(ctx context.Context, field graphql.CollectedField, obj *XgenResourceAction) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceAction_Action(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Action, 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.(XgenResourceActionType)
	fc.Result = res
	return ec.marshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceAction_Action(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceAction",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type XgenResourceActionType does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceAction_Route(ctx context.Context, field graphql.CollectedField, obj *XgenResourceAction) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceAction_Route(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Route, 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) fieldContext_XgenResourceAction_Route(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceAction",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceAction_SchemaFieldName(ctx context.Context, field graphql.CollectedField, obj *XgenResourceAction) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceAction_SchemaFieldName(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SchemaFieldName, 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) fieldContext_XgenResourceAction_SchemaFieldName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceAction",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceActionTypeXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenResourceActionTypeXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceActionTypeXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceActionTypeXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceActionTypeXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceActionTypeXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenResourceActionTypeXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceActionTypeXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceActionTypeXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceActionTypeXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceDbConfigInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenResourceDbConfigInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceDbConfigInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceDbConfigInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceDbConfigInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceDbConfigInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenResourceDbConfigInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceDbConfigInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceDbConfigInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceDbConfigInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceDefinition_objectName(ctx context.Context, field graphql.CollectedField, obj *XgenResourceDefinition) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceDefinition_objectName(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ObjectName, 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) fieldContext_XgenResourceDefinition_objectName(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceDefinition",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceDefinition_properties(ctx context.Context, field graphql.CollectedField, obj *XgenResourceDefinition) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceDefinition_properties(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Properties, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenResourceProperty)
	fc.Result = res
	return ec.marshalOXgenResourceProperty2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceProperty(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceDefinition_properties(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceDefinition",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Name":
				return ec.fieldContext_XgenResourceProperty_Name(ctx, field)
			case "Route":
				return ec.fieldContext_XgenResourceProperty_Route(ctx, field)
			case "Primary":
				return ec.fieldContext_XgenResourceProperty_Primary(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenResourceProperty", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceDefinition_actions(ctx context.Context, field graphql.CollectedField, obj *XgenResourceDefinition) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceDefinition_actions(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Actions, 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.([]*XgenResourceAction)
	fc.Result = res
	return ec.marshalNXgenResourceAction2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceAction(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceDefinition_actions(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceDefinition",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Resource":
				return ec.fieldContext_XgenResourceAction_Resource(ctx, field)
			case "Action":
				return ec.fieldContext_XgenResourceAction_Action(ctx, field)
			case "Route":
				return ec.fieldContext_XgenResourceAction_Route(ctx, field)
			case "SchemaFieldName":
				return ec.fieldContext_XgenResourceAction_SchemaFieldName(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenResourceAction", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceFieldDbConfigInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenResourceFieldDbConfigInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceFieldDbConfigInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceFieldDbConfigInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceFieldDbConfigInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceFieldDbConfigInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenResourceFieldDbConfigInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceFieldDbConfigInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceFieldDbConfigInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceFieldDbConfigInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceListActionTypeXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenResourceListActionTypeXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceListActionTypeXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceListActionTypeXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceListActionTypeXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceListActionTypeXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenResourceListActionTypeXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceListActionTypeXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceListActionTypeXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceListActionTypeXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceMap_user(ctx context.Context, field graphql.CollectedField, obj *XgenResourceMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceMap_user(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.User, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenResourceDefinition)
	fc.Result = res
	return ec.marshalOXgenResourceDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceMap_user(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "objectName":
				return ec.fieldContext_XgenResourceDefinition_objectName(ctx, field)
			case "properties":
				return ec.fieldContext_XgenResourceDefinition_properties(ctx, field)
			case "actions":
				return ec.fieldContext_XgenResourceDefinition_actions(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenResourceDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceMap_phone_number(ctx context.Context, field graphql.CollectedField, obj *XgenResourceMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceMap_phone_number(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.PhoneNumber, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenResourceDefinition)
	fc.Result = res
	return ec.marshalOXgenResourceDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceMap_phone_number(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "objectName":
				return ec.fieldContext_XgenResourceDefinition_objectName(ctx, field)
			case "properties":
				return ec.fieldContext_XgenResourceDefinition_properties(ctx, field)
			case "actions":
				return ec.fieldContext_XgenResourceDefinition_actions(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenResourceDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceMap_car(ctx context.Context, field graphql.CollectedField, obj *XgenResourceMap) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceMap_car(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Car, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenResourceDefinition)
	fc.Result = res
	return ec.marshalOXgenResourceDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenResourceMap_car(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceMap",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "objectName":
				return ec.fieldContext_XgenResourceDefinition_objectName(ctx, field)
			case "properties":
				return ec.fieldContext_XgenResourceDefinition_properties(ctx, field)
			case "actions":
				return ec.fieldContext_XgenResourceDefinition_actions(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenResourceDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceProperty_Name(ctx context.Context, field graphql.CollectedField, obj *XgenResourceProperty) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceProperty_Name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext_XgenResourceProperty_Name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceProperty",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceProperty_Route(ctx context.Context, field graphql.CollectedField, obj *XgenResourceProperty) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceProperty_Route(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Route, 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) fieldContext_XgenResourceProperty_Route(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceProperty",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenResourceProperty_Primary(ctx context.Context, field graphql.CollectedField, obj *XgenResourceProperty) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenResourceProperty_Primary(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Primary, 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) fieldContext_XgenResourceProperty_Primary(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenResourceProperty",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSort_by(ctx context.Context, field graphql.CollectedField, obj *XgenSort) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSort_by(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.By, 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) fieldContext_XgenSort_by(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSort",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSort_direction(ctx context.Context, field graphql.CollectedField, obj *XgenSort) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSort_direction(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Direction, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenSortDirection)
	fc.Result = res
	return ec.marshalOXgenSortDirection2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortDirection(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSort_direction(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSort",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type XgenSortDirection does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortDirectionXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenSortDirectionXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortDirectionXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortDirectionXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortDirectionXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortDirectionXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenSortDirectionXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortDirectionXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortDirectionXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortDirectionXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenSortInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenSortInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortResourceConfig_Disabled(ctx context.Context, field graphql.CollectedField, obj *XgenSortResourceConfig) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortResourceConfig_Disabled(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Disabled, 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) fieldContext_XgenSortResourceConfig_Disabled(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortResourceConfig",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortResourceConfig_Default(ctx context.Context, field graphql.CollectedField, obj *XgenSortResourceConfig) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortResourceConfig_Default(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Default, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.([]*XgenSort)
	fc.Result = res
	return ec.marshalOXgenSort2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortResourceConfig_Default(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortResourceConfig",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "by":
				return ec.fieldContext_XgenSort_by(ctx, field)
			case "direction":
				return ec.fieldContext_XgenSort_direction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenSort", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortResourceConfigInputXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenSortResourceConfigInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortResourceConfigInputXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortResourceConfigInputXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortResourceConfigInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortResourceConfigInputXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenSortResourceConfigInputXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortResourceConfigInputXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortResourceConfigInputXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortResourceConfigInputXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortResourceConfigXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenSortResourceConfigXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortResourceConfigXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortResourceConfigXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortResourceConfigXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortResourceConfigXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenSortResourceConfigXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortResourceConfigXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortResourceConfigXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortResourceConfigXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortXgenDef_object(ctx context.Context, field graphql.CollectedField, obj *XgenSortXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortXgenDef_object(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Object, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*XgenObjectDefinition)
	fc.Result = res
	return ec.marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortXgenDef_object(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "Action":
				return ec.fieldContext_XgenObjectDefinition_Action(ctx, field)
			case "Resource":
				return ec.fieldContext_XgenObjectDefinition_Resource(ctx, field)
			case "ListAction":
				return ec.fieldContext_XgenObjectDefinition_ListAction(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectDefinition", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _XgenSortXgenDef_field(ctx context.Context, field graphql.CollectedField, obj *XgenSortXgenDef) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_XgenSortXgenDef_field(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Field, 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.([]*XgenObjectField)
	fc.Result = res
	return ec.marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_XgenSortXgenDef_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "XgenSortXgenDef",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext_XgenObjectField_name(ctx, field)
			case "definition":
				return ec.fieldContext_XgenObjectField_definition(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type XgenObjectField", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Directive_name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Directive_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Directive_description(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext___Directive_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Directive_locations(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Directive_locations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type __DirectiveLocation does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Directive_args(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___InputValue_name(ctx, field)
			case "description":
				return ec.fieldContext___InputValue_description(ctx, field)
			case "type":
				return ec.fieldContext___InputValue_type(ctx, field)
			case "defaultValue":
				return ec.fieldContext___InputValue_defaultValue(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Directive_isRepeatable(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.IsRepeatable, 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) fieldContext___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Directive",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___EnumValue_name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___EnumValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___EnumValue_description(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext___EnumValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___EnumValue_isDeprecated(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___EnumValue_deprecationReason(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__EnumValue",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Field_name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Field_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Field_description(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext___Field_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Field_args(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___InputValue_name(ctx, field)
			case "description":
				return ec.fieldContext___InputValue_description(ctx, field)
			case "type":
				return ec.fieldContext___InputValue_type(ctx, field)
			case "defaultValue":
				return ec.fieldContext___InputValue_defaultValue(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Field_type(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Field_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Field_isDeprecated(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Field_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type Boolean does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Field_deprecationReason(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Field_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Field",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___InputValue_name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___InputValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___InputValue_description(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext___InputValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___InputValue_type(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___InputValue_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___InputValue_defaultValue(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__InputValue",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Schema_description(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext___Schema_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Schema_types(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Schema_types(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Schema_queryType(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Schema_queryType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Schema_mutationType(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Schema_mutationType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Schema_subscriptionType(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Schema_directives(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Schema_directives(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Schema",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___Directive_name(ctx, field)
			case "description":
				return ec.fieldContext___Directive_description(ctx, field)
			case "locations":
				return ec.fieldContext___Directive_locations(ctx, field)
			case "args":
				return ec.fieldContext___Directive_args(ctx, field)
			case "isRepeatable":
				return ec.fieldContext___Directive_isRepeatable(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Type_kind(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Type_kind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type __TypeKind does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Type_name(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Type_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Type_description(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext___Type_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Type_fields(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Fields(fc.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) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___Field_name(ctx, field)
			case "description":
				return ec.fieldContext___Field_description(ctx, field)
			case "args":
				return ec.fieldContext___Field_args(ctx, field)
			case "type":
				return ec.fieldContext___Field_type(ctx, field)
			case "isDeprecated":
				return ec.fieldContext___Field_isDeprecated(ctx, field)
			case "deprecationReason":
				return ec.fieldContext___Field_deprecationReason(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Type_interfaces(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Type_interfaces(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Type_possibleTypes(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Type_possibleTypes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Type_enumValues(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.EnumValues(fc.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) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___EnumValue_name(ctx, field)
			case "description":
				return ec.fieldContext___EnumValue_description(ctx, field)
			case "isDeprecated":
				return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
			case "deprecationReason":
				return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name)
		},
	}
	defer func() {
		if r := recover(); r != nil {
			err = ec.Recover(ctx, r)
			ec.Error(ctx, err)
		}
	}()
	ctx = graphql.WithFieldContext(ctx, fc)
	if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
		ec.Error(ctx, err)
		return fc, err
	}
	return fc, nil
}

func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Type_inputFields(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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) fieldContext___Type_inputFields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "name":
				return ec.fieldContext___InputValue_name(ctx, field)
			case "description":
				return ec.fieldContext___InputValue_description(ctx, field)
			case "type":
				return ec.fieldContext___InputValue_type(ctx, field)
			case "defaultValue":
				return ec.fieldContext___InputValue_defaultValue(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Type_ofType(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	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)
}

func (ec *executionContext) fieldContext___Type_ofType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "kind":
				return ec.fieldContext___Type_kind(ctx, field)
			case "name":
				return ec.fieldContext___Type_name(ctx, field)
			case "description":
				return ec.fieldContext___Type_description(ctx, field)
			case "fields":
				return ec.fieldContext___Type_fields(ctx, field)
			case "interfaces":
				return ec.fieldContext___Type_interfaces(ctx, field)
			case "possibleTypes":
				return ec.fieldContext___Type_possibleTypes(ctx, field)
			case "enumValues":
				return ec.fieldContext___Type_enumValues(ctx, field)
			case "inputFields":
				return ec.fieldContext___Type_inputFields(ctx, field)
			case "ofType":
				return ec.fieldContext___Type_ofType(ctx, field)
			case "specifiedByURL":
				return ec.fieldContext___Type_specifiedByURL(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext___Type_specifiedByURL(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.SpecifiedByURL(), 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) fieldContext___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "__Type",
		Field:      field,
		IsMethod:   true,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

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

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

func (ec *executionContext) unmarshalInputCarBrowseInput(ctx context.Context, obj interface{}) (CarBrowseInput, error) {
	var it CarBrowseInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"id", "userId", "make"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOID2ᚖint(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx, "BROWSE_QUERY")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "list")
				if err != nil {
					return nil, err
				}
				if ec.directives.ListAction == nil {
					return nil, errors.New("directive ListAction is not implemented")
				}
				return ec.directives.ListAction(ctx, obj, directive0, resource, action, route, nil, nil, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive1, label, description, nil)
			}

			tmp, err := directive2(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*int); ok {
				it.ID = data
			} else if tmp == nil {
				it.ID = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "userId":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userId"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOID2ᚖint(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx, "BROWSE_QUERY")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "list")
				if err != nil {
					return nil, err
				}
				if ec.directives.ListAction == nil {
					return nil, errors.New("directive ListAction is not implemented")
				}
				return ec.directives.ListAction(ctx, obj, directive0, resource, action, route, nil, nil, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "User ID")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "User ID")
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive1, label, description, nil)
			}

			tmp, err := directive2(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*int); ok {
				it.UserID = data
			} else if tmp == nil {
				it.UserID = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "make":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("make"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx, "BROWSE_QUERY")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "list")
				if err != nil {
					return nil, err
				}
				if ec.directives.ListAction == nil {
					return nil, errors.New("directive ListAction is not implemented")
				}
				return ec.directives.ListAction(ctx, obj, directive0, resource, action, route, nil, nil, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "Make")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "Make")
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive1, label, description, nil)
			}

			tmp, err := directive2(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*string); ok {
				it.Make = data
			} else if tmp == nil {
				it.Make = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputCarInput(ctx context.Context, obj interface{}) (CarInput, error) {
	var it CarInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"id", "make", "done", "user"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOID2ᚖint(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "ID of the car")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"Car.ID"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive2, label, description, mapTo)
			}

			tmp, err := directive3(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*int); ok {
				it.ID = data
			} else if tmp == nil {
				it.ID = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "make":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("make"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "Make")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "Text of the todo")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"Car.Make"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive2, label, description, mapTo)
			}

			tmp, err := directive3(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*string); ok {
				it.Make = data
			} else if tmp == nil {
				it.Make = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "done":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("done"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOBoolean2ᚖbool(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "Done")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "Done of the todo")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"Car.Done"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive2, label, description, mapTo)
			}

			tmp, err := directive3(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*bool); ok {
				it.Done = data
			} else if tmp == nil {
				it.Done = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *bool`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "user":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("user"))
			directive0 := func(ctx context.Context) (interface{}, error) {
				return ec.unmarshalOUserInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserInput(ctx, v)
			}
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive2, resource, action, route, nil)
			}
			directive4 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive3, resource, action, route, nil)
			}
			directive5 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "User")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "User of the todo")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"Car.User"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive4, label, description, mapTo)
			}

			tmp, err := directive5(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*UserInput); ok {
				it.User = data
			} else if tmp == nil {
				it.User = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.UserInput`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputCarSingleSortInput(ctx context.Context, obj interface{}) (CarSingleSortInput, error) {
	var it CarSingleSortInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"field", "direction"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "field":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field"))
			data, err := ec.unmarshalNCAR_SORTABLE_FIELD2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarSortableField(ctx, v)
			if err != nil {
				return it, err
			}
			it.Field = data
		case "direction":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction"))
			data, err := ec.unmarshalOXgenSortDirection2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortDirection(ctx, v)
			if err != nil {
				return it, err
			}
			it.Direction = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputCarSortInput(ctx context.Context, obj interface{}) (CarSortInput, error) {
	var it CarSortInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"by"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "by":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("by"))
			data, err := ec.unmarshalOCarSingleSortInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarSingleSortInputᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.By = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputDeleteUsers(ctx context.Context, obj interface{}) (DeleteUsers, error) {
	var it DeleteUsers
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"ids"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "ids":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ids"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOID2ᚕintᚄ(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx, "BATCH_DELETE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "delete")
				if err != nil {
					return nil, err
				}
				if ec.directives.ListAction == nil {
					return nil, errors.New("directive ListAction is not implemented")
				}
				return ec.directives.ListAction(ctx, obj, directive0, resource, action, route, nil, nil, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "IDs")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "IDs of users")
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive1, label, description, nil)
			}

			tmp, err := directive2(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.([]int); ok {
				it.Ids = data
			} else if tmp == nil {
				it.Ids = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be []int`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputListUser(ctx context.Context, obj interface{}) (ListUser, error) {
	var it ListUser
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"id", "name"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOID2ᚖint(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx, "BROWSE_QUERY")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "list")
				if err != nil {
					return nil, err
				}
				pagination, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
				if err != nil {
					return nil, err
				}
				sort, err := ec.unmarshalOXgenSortResourceConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortResourceConfigInput(ctx, map[string]interface{}{"Default": []interface{}{map[string]interface{}{"by": "name", "direction": "ASC"}}})
				if err != nil {
					return nil, err
				}
				if ec.directives.ListAction == nil {
					return nil, errors.New("directive ListAction is not implemented")
				}
				return ec.directives.ListAction(ctx, obj, directive0, resource, action, route, pagination, sort, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"User.ID"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive1, label, description, mapTo)
			}

			tmp, err := directive2(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*int); ok {
				it.ID = data
			} else if tmp == nil {
				it.ID = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "name":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx, "BROWSE_QUERY")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "list")
				if err != nil {
					return nil, err
				}
				pagination, err := ec.unmarshalOBoolean2ᚖbool(ctx, true)
				if err != nil {
					return nil, err
				}
				sort, err := ec.unmarshalOXgenSortResourceConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortResourceConfigInput(ctx, map[string]interface{}{"Default": []interface{}{map[string]interface{}{"by": "name", "direction": "ASC"}}})
				if err != nil {
					return nil, err
				}
				if ec.directives.ListAction == nil {
					return nil, errors.New("directive ListAction is not implemented")
				}
				return ec.directives.ListAction(ctx, obj, directive0, resource, action, route, pagination, sort, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "Name")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "Name")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"User.Name"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive1, label, description, mapTo)
			}

			tmp, err := directive2(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*string); ok {
				it.Name = data
			} else if tmp == nil {
				it.Name = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputPhoneNumberBrowseInput(ctx context.Context, obj interface{}) (PhoneNumberBrowseInput, error) {
	var it PhoneNumberBrowseInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"id", "number"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOID2ᚖint(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "phone_number")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx, "BROWSE_QUERY")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "list")
				if err != nil {
					return nil, err
				}
				if ec.directives.ListAction == nil {
					return nil, errors.New("directive ListAction is not implemented")
				}
				return ec.directives.ListAction(ctx, obj, directive0, resource, action, route, nil, nil, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"Phone.ID"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive1, label, description, mapTo)
			}

			tmp, err := directive2(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*int); ok {
				it.ID = data
			} else if tmp == nil {
				it.ID = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "number":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("number"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOID2ᚖint(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "phone_number")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx, "BROWSE_QUERY")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "list")
				if err != nil {
					return nil, err
				}
				if ec.directives.ListAction == nil {
					return nil, errors.New("directive ListAction is not implemented")
				}
				return ec.directives.ListAction(ctx, obj, directive0, resource, action, route, nil, nil, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "Number")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "Number of phone")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"Phone.Number"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive1, label, description, mapTo)
			}

			tmp, err := directive2(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*int); ok {
				it.Number = data
			} else if tmp == nil {
				it.Number = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputPhoneNumberInput(ctx context.Context, obj interface{}) (PhoneNumberInput, error) {
	var it PhoneNumberInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"id", "number", "user"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOID2ᚖint(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "phone_number")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "phone_number")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "ID of the phone number")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"Phone.ID"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive2, label, description, mapTo)
			}

			tmp, err := directive3(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*int); ok {
				it.ID = data
			} else if tmp == nil {
				it.ID = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "number":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("number"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "phone_number")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "phone_number")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "Name")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "Number of phone")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"Phone.Number"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive2, label, description, mapTo)
			}

			tmp, err := directive3(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*string); ok {
				it.Number = data
			} else if tmp == nil {
				it.Number = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "user":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("user"))
			directive0 := func(ctx context.Context) (interface{}, error) {
				return ec.unmarshalOUserInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserInput(ctx, v)
			}
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "phone_number")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive2, resource, action, route, nil)
			}
			directive4 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "phone_number")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive3, resource, action, route, nil)
			}
			directive5 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "User")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "User of the phone")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"Phone.User"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive4, label, description, mapTo)
			}

			tmp, err := directive5(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*UserInput); ok {
				it.User = data
			} else if tmp == nil {
				it.User = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.UserInput`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputPhoneNumberSingleSortInput(ctx context.Context, obj interface{}) (PhoneNumberSingleSortInput, error) {
	var it PhoneNumberSingleSortInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"field", "direction"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "field":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field"))
			data, err := ec.unmarshalNPHONE_NUMBER_SORTABLE_FIELD2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberSortableField(ctx, v)
			if err != nil {
				return it, err
			}
			it.Field = data
		case "direction":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction"))
			data, err := ec.unmarshalOXgenSortDirection2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortDirection(ctx, v)
			if err != nil {
				return it, err
			}
			it.Direction = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputPhoneNumberSortInput(ctx context.Context, obj interface{}) (PhoneNumberSortInput, error) {
	var it PhoneNumberSortInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"by"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "by":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("by"))
			data, err := ec.unmarshalOPhoneNumberSingleSortInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberSingleSortInputᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.By = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputUserInput(ctx context.Context, obj interface{}) (UserInput, error) {
	var it UserInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"id", "name", "cars", "phones"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "id":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOID2ᚖint(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "ID")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "ID of the user")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"User.ID"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive2, label, description, mapTo)
			}

			tmp, err := directive3(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*int); ok {
				it.ID = data
			} else if tmp == nil {
				it.ID = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "name":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
			directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, v) }
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "Name")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "Name")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"User.Name"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive2, label, description, mapTo)
			}

			tmp, err := directive3(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.(*string); ok {
				it.Name = data
			} else if tmp == nil {
				it.Name = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "cars":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("cars"))
			directive0 := func(ctx context.Context) (interface{}, error) {
				return ec.unmarshalOCarInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarInputᚄ(ctx, v)
			}
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "car")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive2, resource, action, route, nil)
			}
			directive4 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive3, resource, action, route, nil)
			}
			directive5 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "Cars")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "Cars of the user")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"User.Cars"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive4, label, description, mapTo)
			}

			tmp, err := directive5(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.([]*CarInput); ok {
				it.Cars = data
			} else if tmp == nil {
				it.Cars = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be []*github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.CarInput`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		case "phones":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("phones"))
			directive0 := func(ctx context.Context) (interface{}, error) {
				return ec.unmarshalOPhoneNumberInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberInputᚄ(ctx, v)
			}
			directive1 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "phone_number")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive0, resource, action, route, nil)
			}
			directive2 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "phone_number")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive1, resource, action, route, nil)
			}
			directive3 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "CREATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "new")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive2, resource, action, route, nil)
			}
			directive4 := func(ctx context.Context) (interface{}, error) {
				resource, err := ec.unmarshalNString2string(ctx, "user")
				if err != nil {
					return nil, err
				}
				action, err := ec.unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx, "UPDATE_MUTATION")
				if err != nil {
					return nil, err
				}
				route, err := ec.unmarshalOString2ᚖstring(ctx, "update")
				if err != nil {
					return nil, err
				}
				if ec.directives.Action == nil {
					return nil, errors.New("directive Action is not implemented")
				}
				return ec.directives.Action(ctx, obj, directive3, resource, action, route, nil)
			}
			directive5 := func(ctx context.Context) (interface{}, error) {
				label, err := ec.unmarshalOString2ᚖstring(ctx, "Phone Numbers")
				if err != nil {
					return nil, err
				}
				description, err := ec.unmarshalOString2ᚖstring(ctx, "Phone numbers of the user")
				if err != nil {
					return nil, err
				}
				mapTo, err := ec.unmarshalOString2ᚕstringᚄ(ctx, []interface{}{"User.PhoneNumbers"})
				if err != nil {
					return nil, err
				}
				if ec.directives.ActionField == nil {
					return nil, errors.New("directive ActionField is not implemented")
				}
				return ec.directives.ActionField(ctx, obj, directive4, label, description, mapTo)
			}

			tmp, err := directive5(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.([]*PhoneNumberInput); ok {
				it.Phones = data
			} else if tmp == nil {
				it.Phones = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be []*github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.PhoneNumberInput`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputUserSingleSortInput(ctx context.Context, obj interface{}) (UserSingleSortInput, error) {
	var it UserSingleSortInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"field", "direction"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "field":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field"))
			data, err := ec.unmarshalNUSER_SORTABLE_FIELD2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserSortableField(ctx, v)
			if err != nil {
				return it, err
			}
			it.Field = data
		case "direction":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction"))
			data, err := ec.unmarshalOXgenSortDirection2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortDirection(ctx, v)
			if err != nil {
				return it, err
			}
			it.Direction = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputUserSortInput(ctx context.Context, obj interface{}) (UserSortInput, error) {
	var it UserSortInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"by"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "by":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("by"))
			data, err := ec.unmarshalOUserSingleSortInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserSingleSortInputᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.By = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputXgenCursorPaginationInput(ctx context.Context, obj interface{}) (XgenCursorPaginationInput, error) {
	var it XgenCursorPaginationInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"first", "after", "last", "before"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "first":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
			it.First = data
		case "after":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.After = data
		case "last":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
			it.Last = data
		case "before":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Before = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputXgenPaginationInput(ctx context.Context, obj interface{}) (XgenPaginationInput, error) {
	var it XgenPaginationInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"page", "size"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "page":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("page"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
			it.Page = data
		case "size":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("size"))
			data, err := ec.unmarshalNInt2int(ctx, v)
			if err != nil {
				return it, err
			}
			it.Size = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputXgenResourceDbConfigInput(ctx context.Context, obj interface{}) (XgenResourceDbConfigInput, error) {
	var it XgenResourceDbConfigInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"Table"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "Table":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Table"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.Table = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputXgenResourceFieldDbConfigInput(ctx context.Context, obj interface{}) (XgenResourceFieldDbConfigInput, error) {
	var it XgenResourceFieldDbConfigInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"Column", "PrimaryKey", "AutoIncrement", "Unique", "NotNull", "Index", "UniqueIndex", "Size", "Precision", "Type", "Scale", "AutoIncrementIncrement"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "Column":
			var err error

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

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

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

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

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

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

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

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Size"))
			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
			it.Size = data
		case "Precision":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Precision"))
			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
			it.Precision = data
		case "Type":
			var err error

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

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Scale"))
			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
			it.Scale = data
		case "AutoIncrementIncrement":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("AutoIncrementIncrement"))
			data, err := ec.unmarshalOInt2ᚖint(ctx, v)
			if err != nil {
				return it, err
			}
			it.AutoIncrementIncrement = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputXgenSortInput(ctx context.Context, obj interface{}) (XgenSortInput, error) {
	var it XgenSortInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"by", "direction"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "by":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("by"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.By = data
		case "direction":
			var err error

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction"))
			data, err := ec.unmarshalOXgenSortDirection2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortDirection(ctx, v)
			if err != nil {
				return it, err
			}
			it.Direction = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputXgenSortResourceConfigInput(ctx context.Context, obj interface{}) (XgenSortResourceConfigInput, error) {
	var it XgenSortResourceConfigInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"Disabled", "Default"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "Disabled":
			var err error

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

			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Default"))
			directive0 := func(ctx context.Context) (interface{}, error) {
				return ec.unmarshalOXgenSortInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortInputᚄ(ctx, v)
			}
			directive1 := func(ctx context.Context) (interface{}, error) {
				typeArg, err := ec.unmarshalNString2string(ctx, "[XgenSort!]")
				if err != nil {
					return nil, err
				}
				if ec.directives.ToObjectType == nil {
					return nil, errors.New("directive ToObjectType is not implemented")
				}
				return ec.directives.ToObjectType(ctx, obj, directive0, typeArg)
			}

			tmp, err := directive1(ctx)
			if err != nil {
				return it, graphql.ErrorOnPath(ctx, err)
			}
			if data, ok := tmp.([]*XgenSortInput); ok {
				it.Default = data
			} else if tmp == nil {
				it.Default = nil
			} else {
				err := fmt.Errorf(`unexpected type %T from directive, should be []*github.com/ikhfa/goxgen/cmd/internal/integration/gorm_advanced/generated.XgenSortInput`, tmp)
				return it, graphql.ErrorOnPath(ctx, err)
			}
		}
	}

	return it, nil
}

// endregion **************************** input.gotpl *****************************

// region    ************************** interface.gotpl ***************************

// endregion ************************** interface.gotpl ***************************

// region    **************************** object.gotpl ****************************

var actionImplementors = []string{"Action"}

func (ec *executionContext) _Action(ctx context.Context, sel ast.SelectionSet, obj *Action) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, actionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Action")
		case "Resource":
			out.Values[i] = ec._Action_Resource(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "Action":
			out.Values[i] = ec._Action_Action(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "Route":
			out.Values[i] = ec._Action_Route(ctx, field, obj)
		case "SchemaFieldName":
			out.Values[i] = ec._Action_SchemaFieldName(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var actionAnnotationSingleImplementors = []string{"ActionAnnotationSingle"}

func (ec *executionContext) _ActionAnnotationSingle(ctx context.Context, sel ast.SelectionSet, obj *ActionAnnotationSingle) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, actionAnnotationSingleImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ActionAnnotationSingle")
		case "name":
			out.Values[i] = ec._ActionAnnotationSingle_name(ctx, field, obj)
		case "value":
			out.Values[i] = ec._ActionAnnotationSingle_value(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var actionFieldImplementors = []string{"ActionField"}

func (ec *executionContext) _ActionField(ctx context.Context, sel ast.SelectionSet, obj *ActionField) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, actionFieldImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ActionField")
		case "Label":
			out.Values[i] = ec._ActionField_Label(ctx, field, obj)
		case "Description":
			out.Values[i] = ec._ActionField_Description(ctx, field, obj)
		case "MapTo":
			out.Values[i] = ec._ActionField_MapTo(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var carImplementors = []string{"Car"}

func (ec *executionContext) _Car(ctx context.Context, sel ast.SelectionSet, obj *Car) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, carImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Car")
		case "id":
			out.Values[i] = ec._Car_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "make":
			out.Values[i] = ec._Car_make(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "done":
			out.Values[i] = ec._Car_done(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "user":
			out.Values[i] = ec._Car_user(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var carBrowseInputXgenDefImplementors = []string{"CarBrowseInputXgenDef"}

func (ec *executionContext) _CarBrowseInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *CarBrowseInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, carBrowseInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CarBrowseInputXgenDef")
		case "object":
			out.Values[i] = ec._CarBrowseInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._CarBrowseInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var carInputXgenDefImplementors = []string{"CarInputXgenDef"}

func (ec *executionContext) _CarInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *CarInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, carInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CarInputXgenDef")
		case "object":
			out.Values[i] = ec._CarInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._CarInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var carXgenDefImplementors = []string{"CarXgenDef"}

func (ec *executionContext) _CarXgenDef(ctx context.Context, sel ast.SelectionSet, obj *CarXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, carXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("CarXgenDef")
		case "object":
			out.Values[i] = ec._CarXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._CarXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var deleteUsersXgenDefImplementors = []string{"DeleteUsersXgenDef"}

func (ec *executionContext) _DeleteUsersXgenDef(ctx context.Context, sel ast.SelectionSet, obj *DeleteUsersXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, deleteUsersXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("DeleteUsersXgenDef")
		case "object":
			out.Values[i] = ec._DeleteUsersXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._DeleteUsersXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var fieldImplementors = []string{"Field"}

func (ec *executionContext) _Field(ctx context.Context, sel ast.SelectionSet, obj *Field) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, fieldImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Field")
		case "Label":
			out.Values[i] = ec._Field_Label(ctx, field, obj)
		case "Description":
			out.Values[i] = ec._Field_Description(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var listActionImplementors = []string{"ListAction"}

func (ec *executionContext) _ListAction(ctx context.Context, sel ast.SelectionSet, obj *ListAction) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, listActionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ListAction")
		case "Resource":
			out.Values[i] = ec._ListAction_Resource(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "Action":
			out.Values[i] = ec._ListAction_Action(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "Route":
			out.Values[i] = ec._ListAction_Route(ctx, field, obj)
		case "Pagination":
			out.Values[i] = ec._ListAction_Pagination(ctx, field, obj)
		case "Sort":
			out.Values[i] = ec._ListAction_Sort(ctx, field, obj)
		case "SchemaFieldName":
			out.Values[i] = ec._ListAction_SchemaFieldName(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var listActionAnnotationSingleImplementors = []string{"ListActionAnnotationSingle"}

func (ec *executionContext) _ListActionAnnotationSingle(ctx context.Context, sel ast.SelectionSet, obj *ListActionAnnotationSingle) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, listActionAnnotationSingleImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ListActionAnnotationSingle")
		case "name":
			out.Values[i] = ec._ListActionAnnotationSingle_name(ctx, field, obj)
		case "value":
			out.Values[i] = ec._ListActionAnnotationSingle_value(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var listUserXgenDefImplementors = []string{"ListUserXgenDef"}

func (ec *executionContext) _ListUserXgenDef(ctx context.Context, sel ast.SelectionSet, obj *ListUserXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, listUserXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ListUserXgenDef")
		case "object":
			out.Values[i] = ec._ListUserXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._ListUserXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	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)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
			Object: field.Name,
			Field:  field,
		})

		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Mutation")
		case "user_batch_delete":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_user_batch_delete(ctx, field)
			})
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "user_create":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_user_create(ctx, field)
			})
		case "user_update":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_user_update(ctx, field)
			})
		case "car_create":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_car_create(ctx, field)
			})
		case "car_update":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_car_update(ctx, field)
			})
		case "phone_number_create":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_phone_number_create(ctx, field)
			})
		case "phone_number_update":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Mutation_phone_number_update(ctx, field)
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var phoneImplementors = []string{"Phone"}

func (ec *executionContext) _Phone(ctx context.Context, sel ast.SelectionSet, obj *Phone) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, phoneImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Phone")
		case "id":
			out.Values[i] = ec._Phone_id(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "number":
			out.Values[i] = ec._Phone_number(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "user":
			out.Values[i] = ec._Phone_user(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var phoneNumberBrowseInputXgenDefImplementors = []string{"PhoneNumberBrowseInputXgenDef"}

func (ec *executionContext) _PhoneNumberBrowseInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *PhoneNumberBrowseInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, phoneNumberBrowseInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PhoneNumberBrowseInputXgenDef")
		case "object":
			out.Values[i] = ec._PhoneNumberBrowseInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._PhoneNumberBrowseInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var phoneNumberInputXgenDefImplementors = []string{"PhoneNumberInputXgenDef"}

func (ec *executionContext) _PhoneNumberInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *PhoneNumberInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, phoneNumberInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PhoneNumberInputXgenDef")
		case "object":
			out.Values[i] = ec._PhoneNumberInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._PhoneNumberInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var phoneXgenDefImplementors = []string{"PhoneXgenDef"}

func (ec *executionContext) _PhoneXgenDef(ctx context.Context, sel ast.SelectionSet, obj *PhoneXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, phoneXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("PhoneXgenDef")
		case "object":
			out.Values[i] = ec._PhoneXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._PhoneXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	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)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
			Object: field.Name,
			Field:  field,
		})

		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Query")
		case "_xgen_introspection":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query__xgen_introspection(ctx, field)
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "car_browse":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_car_browse(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "user_browse":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_user_browse(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "phone_number_browse":
			field := field

			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
				defer func() {
					if r := recover(); r != nil {
						ec.Error(ctx, ec.Recover(ctx, r))
					}
				}()
				res = ec._Query_phone_number_browse(ctx, field)
				if res == graphql.Null {
					atomic.AddUint32(&fs.Invalids, 1)
				}
				return res
			}

			rrm := func(ctx context.Context) graphql.Marshaler {
				return ec.OperationContext.RootResolverMiddleware(ctx,
					func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
			}

			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
		case "__type":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Query___type(ctx, field)
			})
		case "__schema":
			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
				return ec._Query___schema(ctx, field)
			})
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var resourceImplementors = []string{"Resource"}

func (ec *executionContext) _Resource(ctx context.Context, sel ast.SelectionSet, obj *Resource) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, resourceImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("Resource")
		case "Name":
			out.Values[i] = ec._Resource_Name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "Route":
			out.Values[i] = ec._Resource_Route(ctx, field, obj)
		case "Primary":
			out.Values[i] = ec._Resource_Primary(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var resourceAnnotationSingleImplementors = []string{"ResourceAnnotationSingle"}

func (ec *executionContext) _ResourceAnnotationSingle(ctx context.Context, sel ast.SelectionSet, obj *ResourceAnnotationSingle) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, resourceAnnotationSingleImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("ResourceAnnotationSingle")
		case "name":
			out.Values[i] = ec._ResourceAnnotationSingle_name(ctx, field, obj)
		case "value":
			out.Values[i] = ec._ResourceAnnotationSingle_value(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	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)
	deferred := make(map[string]*graphql.FieldSet)
	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 {
				out.Invalids++
			}
		case "name":
			out.Values[i] = ec._User_name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "cars":
			out.Values[i] = ec._User_cars(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "phoneNumbers":
			out.Values[i] = ec._User_phoneNumbers(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var userInputXgenDefImplementors = []string{"UserInputXgenDef"}

func (ec *executionContext) _UserInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *UserInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, userInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UserInputXgenDef")
		case "object":
			out.Values[i] = ec._UserInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._UserInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var userXgenDefImplementors = []string{"UserXgenDef"}

func (ec *executionContext) _UserXgenDef(ctx context.Context, sel ast.SelectionSet, obj *UserXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, userXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("UserXgenDef")
		case "object":
			out.Values[i] = ec._UserXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._UserXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenAnnotationMapImplementors = []string{"XgenAnnotationMap"}

func (ec *executionContext) _XgenAnnotationMap(ctx context.Context, sel ast.SelectionSet, obj *XgenAnnotationMap) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenAnnotationMapImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenAnnotationMap")
		case "ListAction":
			out.Values[i] = ec._XgenAnnotationMap_ListAction(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "Resource":
			out.Values[i] = ec._XgenAnnotationMap_Resource(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "Action":
			out.Values[i] = ec._XgenAnnotationMap_Action(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenCursorPaginationInputXgenDefImplementors = []string{"XgenCursorPaginationInputXgenDef"}

func (ec *executionContext) _XgenCursorPaginationInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenCursorPaginationInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenCursorPaginationInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenCursorPaginationInputXgenDef")
		case "object":
			out.Values[i] = ec._XgenCursorPaginationInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenCursorPaginationInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenFieldDefImplementors = []string{"XgenFieldDef"}

func (ec *executionContext) _XgenFieldDef(ctx context.Context, sel ast.SelectionSet, obj *XgenFieldDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenFieldDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenFieldDef")
		case "Field":
			out.Values[i] = ec._XgenFieldDef_Field(ctx, field, obj)
		case "ActionField":
			out.Values[i] = ec._XgenFieldDef_ActionField(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenIntrospectionImplementors = []string{"XgenIntrospection"}

func (ec *executionContext) _XgenIntrospection(ctx context.Context, sel ast.SelectionSet, obj *XgenIntrospection) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenIntrospectionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenIntrospection")
		case "annotation":
			out.Values[i] = ec._XgenIntrospection_annotation(ctx, field, obj)
		case "object":
			out.Values[i] = ec._XgenIntrospection_object(ctx, field, obj)
		case "resource":
			out.Values[i] = ec._XgenIntrospection_resource(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenObjectDefinitionImplementors = []string{"XgenObjectDefinition"}

func (ec *executionContext) _XgenObjectDefinition(ctx context.Context, sel ast.SelectionSet, obj *XgenObjectDefinition) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenObjectDefinitionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenObjectDefinition")
		case "Action":
			out.Values[i] = ec._XgenObjectDefinition_Action(ctx, field, obj)
		case "Resource":
			out.Values[i] = ec._XgenObjectDefinition_Resource(ctx, field, obj)
		case "ListAction":
			out.Values[i] = ec._XgenObjectDefinition_ListAction(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenObjectFieldImplementors = []string{"XgenObjectField"}

func (ec *executionContext) _XgenObjectField(ctx context.Context, sel ast.SelectionSet, obj *XgenObjectField) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenObjectFieldImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenObjectField")
		case "name":
			out.Values[i] = ec._XgenObjectField_name(ctx, field, obj)
		case "definition":
			out.Values[i] = ec._XgenObjectField_definition(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenObjectMapImplementors = []string{"XgenObjectMap"}

func (ec *executionContext) _XgenObjectMap(ctx context.Context, sel ast.SelectionSet, obj *XgenObjectMap) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenObjectMapImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenObjectMap")
		case "XgenPaginationInput":
			out.Values[i] = ec._XgenObjectMap_XgenPaginationInput(ctx, field, obj)
		case "XgenResourceFieldDbConfigInput":
			out.Values[i] = ec._XgenObjectMap_XgenResourceFieldDbConfigInput(ctx, field, obj)
		case "XgenResourceListActionType":
			out.Values[i] = ec._XgenObjectMap_XgenResourceListActionType(ctx, field, obj)
		case "XgenResourceActionType":
			out.Values[i] = ec._XgenObjectMap_XgenResourceActionType(ctx, field, obj)
		case "CarInput":
			out.Values[i] = ec._XgenObjectMap_CarInput(ctx, field, obj)
		case "ListUser":
			out.Values[i] = ec._XgenObjectMap_ListUser(ctx, field, obj)
		case "Phone":
			out.Values[i] = ec._XgenObjectMap_Phone(ctx, field, obj)
		case "DeleteUsers":
			out.Values[i] = ec._XgenObjectMap_DeleteUsers(ctx, field, obj)
		case "XgenSortInput":
			out.Values[i] = ec._XgenObjectMap_XgenSortInput(ctx, field, obj)
		case "Car":
			out.Values[i] = ec._XgenObjectMap_Car(ctx, field, obj)
		case "XgenCursorPaginationInput":
			out.Values[i] = ec._XgenObjectMap_XgenCursorPaginationInput(ctx, field, obj)
		case "XgenSortResourceConfig":
			out.Values[i] = ec._XgenObjectMap_XgenSortResourceConfig(ctx, field, obj)
		case "XgenResourceDbConfigInput":
			out.Values[i] = ec._XgenObjectMap_XgenResourceDbConfigInput(ctx, field, obj)
		case "PhoneNumberBrowseInput":
			out.Values[i] = ec._XgenObjectMap_PhoneNumberBrowseInput(ctx, field, obj)
		case "XgenSort":
			out.Values[i] = ec._XgenObjectMap_XgenSort(ctx, field, obj)
		case "UserInput":
			out.Values[i] = ec._XgenObjectMap_UserInput(ctx, field, obj)
		case "User":
			out.Values[i] = ec._XgenObjectMap_User(ctx, field, obj)
		case "CarBrowseInput":
			out.Values[i] = ec._XgenObjectMap_CarBrowseInput(ctx, field, obj)
		case "XgenSortDirection":
			out.Values[i] = ec._XgenObjectMap_XgenSortDirection(ctx, field, obj)
		case "XgenSortResourceConfigInput":
			out.Values[i] = ec._XgenObjectMap_XgenSortResourceConfigInput(ctx, field, obj)
		case "PhoneNumberInput":
			out.Values[i] = ec._XgenObjectMap_PhoneNumberInput(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenPaginationInputXgenDefImplementors = []string{"XgenPaginationInputXgenDef"}

func (ec *executionContext) _XgenPaginationInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenPaginationInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenPaginationInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenPaginationInputXgenDef")
		case "object":
			out.Values[i] = ec._XgenPaginationInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenPaginationInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenResourceActionImplementors = []string{"XgenResourceAction"}

func (ec *executionContext) _XgenResourceAction(ctx context.Context, sel ast.SelectionSet, obj *XgenResourceAction) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenResourceActionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenResourceAction")
		case "Resource":
			out.Values[i] = ec._XgenResourceAction_Resource(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "Action":
			out.Values[i] = ec._XgenResourceAction_Action(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "Route":
			out.Values[i] = ec._XgenResourceAction_Route(ctx, field, obj)
		case "SchemaFieldName":
			out.Values[i] = ec._XgenResourceAction_SchemaFieldName(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenResourceActionTypeXgenDefImplementors = []string{"XgenResourceActionTypeXgenDef"}

func (ec *executionContext) _XgenResourceActionTypeXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenResourceActionTypeXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenResourceActionTypeXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenResourceActionTypeXgenDef")
		case "object":
			out.Values[i] = ec._XgenResourceActionTypeXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenResourceActionTypeXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenResourceDbConfigInputXgenDefImplementors = []string{"XgenResourceDbConfigInputXgenDef"}

func (ec *executionContext) _XgenResourceDbConfigInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenResourceDbConfigInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenResourceDbConfigInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenResourceDbConfigInputXgenDef")
		case "object":
			out.Values[i] = ec._XgenResourceDbConfigInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenResourceDbConfigInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenResourceDefinitionImplementors = []string{"XgenResourceDefinition"}

func (ec *executionContext) _XgenResourceDefinition(ctx context.Context, sel ast.SelectionSet, obj *XgenResourceDefinition) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenResourceDefinitionImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenResourceDefinition")
		case "objectName":
			out.Values[i] = ec._XgenResourceDefinition_objectName(ctx, field, obj)
		case "properties":
			out.Values[i] = ec._XgenResourceDefinition_properties(ctx, field, obj)
		case "actions":
			out.Values[i] = ec._XgenResourceDefinition_actions(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenResourceFieldDbConfigInputXgenDefImplementors = []string{"XgenResourceFieldDbConfigInputXgenDef"}

func (ec *executionContext) _XgenResourceFieldDbConfigInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenResourceFieldDbConfigInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenResourceFieldDbConfigInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenResourceFieldDbConfigInputXgenDef")
		case "object":
			out.Values[i] = ec._XgenResourceFieldDbConfigInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenResourceFieldDbConfigInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenResourceListActionTypeXgenDefImplementors = []string{"XgenResourceListActionTypeXgenDef"}

func (ec *executionContext) _XgenResourceListActionTypeXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenResourceListActionTypeXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenResourceListActionTypeXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenResourceListActionTypeXgenDef")
		case "object":
			out.Values[i] = ec._XgenResourceListActionTypeXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenResourceListActionTypeXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenResourceMapImplementors = []string{"XgenResourceMap"}

func (ec *executionContext) _XgenResourceMap(ctx context.Context, sel ast.SelectionSet, obj *XgenResourceMap) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenResourceMapImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenResourceMap")
		case "user":
			out.Values[i] = ec._XgenResourceMap_user(ctx, field, obj)
		case "phone_number":
			out.Values[i] = ec._XgenResourceMap_phone_number(ctx, field, obj)
		case "car":
			out.Values[i] = ec._XgenResourceMap_car(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenResourcePropertyImplementors = []string{"XgenResourceProperty"}

func (ec *executionContext) _XgenResourceProperty(ctx context.Context, sel ast.SelectionSet, obj *XgenResourceProperty) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenResourcePropertyImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenResourceProperty")
		case "Name":
			out.Values[i] = ec._XgenResourceProperty_Name(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "Route":
			out.Values[i] = ec._XgenResourceProperty_Route(ctx, field, obj)
		case "Primary":
			out.Values[i] = ec._XgenResourceProperty_Primary(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenSortImplementors = []string{"XgenSort"}

func (ec *executionContext) _XgenSort(ctx context.Context, sel ast.SelectionSet, obj *XgenSort) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenSortImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenSort")
		case "by":
			out.Values[i] = ec._XgenSort_by(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "direction":
			out.Values[i] = ec._XgenSort_direction(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenSortDirectionXgenDefImplementors = []string{"XgenSortDirectionXgenDef"}

func (ec *executionContext) _XgenSortDirectionXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenSortDirectionXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenSortDirectionXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenSortDirectionXgenDef")
		case "object":
			out.Values[i] = ec._XgenSortDirectionXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenSortDirectionXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenSortInputXgenDefImplementors = []string{"XgenSortInputXgenDef"}

func (ec *executionContext) _XgenSortInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenSortInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenSortInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenSortInputXgenDef")
		case "object":
			out.Values[i] = ec._XgenSortInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenSortInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenSortResourceConfigImplementors = []string{"XgenSortResourceConfig"}

func (ec *executionContext) _XgenSortResourceConfig(ctx context.Context, sel ast.SelectionSet, obj *XgenSortResourceConfig) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenSortResourceConfigImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenSortResourceConfig")
		case "Disabled":
			out.Values[i] = ec._XgenSortResourceConfig_Disabled(ctx, field, obj)
		case "Default":
			out.Values[i] = ec._XgenSortResourceConfig_Default(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenSortResourceConfigInputXgenDefImplementors = []string{"XgenSortResourceConfigInputXgenDef"}

func (ec *executionContext) _XgenSortResourceConfigInputXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenSortResourceConfigInputXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenSortResourceConfigInputXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenSortResourceConfigInputXgenDef")
		case "object":
			out.Values[i] = ec._XgenSortResourceConfigInputXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenSortResourceConfigInputXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenSortResourceConfigXgenDefImplementors = []string{"XgenSortResourceConfigXgenDef"}

func (ec *executionContext) _XgenSortResourceConfigXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenSortResourceConfigXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenSortResourceConfigXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenSortResourceConfigXgenDef")
		case "object":
			out.Values[i] = ec._XgenSortResourceConfigXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenSortResourceConfigXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var xgenSortXgenDefImplementors = []string{"XgenSortXgenDef"}

func (ec *executionContext) _XgenSortXgenDef(ctx context.Context, sel ast.SelectionSet, obj *XgenSortXgenDef) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, xgenSortXgenDefImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("XgenSortXgenDef")
		case "object":
			out.Values[i] = ec._XgenSortXgenDef_object(ctx, field, obj)
		case "field":
			out.Values[i] = ec._XgenSortXgenDef_field(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	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)
	deferred := make(map[string]*graphql.FieldSet)
	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 {
				out.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 {
				out.Invalids++
			}
		case "args":
			out.Values[i] = ec.___Directive_args(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "isRepeatable":
			out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	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)
	deferred := make(map[string]*graphql.FieldSet)
	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 {
				out.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 {
				out.Invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	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)
	deferred := make(map[string]*graphql.FieldSet)
	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 {
				out.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 {
				out.Invalids++
			}
		case "type":
			out.Values[i] = ec.___Field_type(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "isDeprecated":
			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "deprecationReason":
			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	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)
	deferred := make(map[string]*graphql.FieldSet)
	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 {
				out.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 {
				out.Invalids++
			}
		case "defaultValue":
			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	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)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("__Schema")
		case "description":
			out.Values[i] = ec.___Schema_description(ctx, field, obj)
		case "types":
			out.Values[i] = ec.___Schema_types(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "queryType":
			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.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 {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	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)
	deferred := make(map[string]*graphql.FieldSet)
	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 {
				out.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)
		case "specifiedByURL":
			out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

// endregion **************************** object.gotpl ****************************

// region    ***************************** type.gotpl *****************************

func (ec *executionContext) marshalNActionAnnotationSingle2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐActionAnnotationSingleᚄ(ctx context.Context, sel ast.SelectionSet, v []*ActionAnnotationSingle) 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.marshalNActionAnnotationSingle2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐActionAnnotationSingle(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNActionAnnotationSingle2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐActionAnnotationSingle(ctx context.Context, sel ast.SelectionSet, v *ActionAnnotationSingle) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._ActionAnnotationSingle(ctx, sel, v)
}

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, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNCAR_SORTABLE_FIELD2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarSortableField(ctx context.Context, v interface{}) (CarSortableField, error) {
	var res CarSortableField
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNCAR_SORTABLE_FIELD2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarSortableField(ctx context.Context, sel ast.SelectionSet, v CarSortableField) graphql.Marshaler {
	return v
}

func (ec *executionContext) marshalNCar2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCar(ctx context.Context, sel ast.SelectionSet, v []*Car) 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.marshalOCar2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCar(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	return ret
}

func (ec *executionContext) marshalNCar2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarᚄ(ctx context.Context, sel ast.SelectionSet, v []*Car) 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.marshalNCar2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCar(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNCar2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCar(ctx context.Context, sel ast.SelectionSet, v *Car) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Car(ctx, sel, v)
}

func (ec *executionContext) unmarshalNCarInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarInput(ctx context.Context, v interface{}) (*CarInput, error) {
	res, err := ec.unmarshalInputCarInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNCarSingleSortInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarSingleSortInput(ctx context.Context, v interface{}) (*CarSingleSortInput, error) {
	res, err := ec.unmarshalInputCarSingleSortInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNID2int(ctx context.Context, v interface{}) (int, error) {
	res, err := graphql.UnmarshalInt(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNID2int(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, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

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, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) marshalNListActionAnnotationSingle2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListActionAnnotationSingleᚄ(ctx context.Context, sel ast.SelectionSet, v []*ListActionAnnotationSingle) 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.marshalNListActionAnnotationSingle2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListActionAnnotationSingle(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNListActionAnnotationSingle2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListActionAnnotationSingle(ctx context.Context, sel ast.SelectionSet, v *ListActionAnnotationSingle) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._ListActionAnnotationSingle(ctx, sel, v)
}

func (ec *executionContext) unmarshalNPHONE_NUMBER_SORTABLE_FIELD2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberSortableField(ctx context.Context, v interface{}) (PhoneNumberSortableField, error) {
	var res PhoneNumberSortableField
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNPHONE_NUMBER_SORTABLE_FIELD2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberSortableField(ctx context.Context, sel ast.SelectionSet, v PhoneNumberSortableField) graphql.Marshaler {
	return v
}

func (ec *executionContext) marshalNPhone2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhone(ctx context.Context, sel ast.SelectionSet, v []*Phone) 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.marshalOPhone2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhone(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	return ret
}

func (ec *executionContext) marshalNPhone2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneᚄ(ctx context.Context, sel ast.SelectionSet, v []*Phone) 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.marshalNPhone2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhone(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNPhone2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhone(ctx context.Context, sel ast.SelectionSet, v *Phone) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._Phone(ctx, sel, v)
}

func (ec *executionContext) unmarshalNPhoneNumberInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberInput(ctx context.Context, v interface{}) (*PhoneNumberInput, error) {
	res, err := ec.unmarshalInputPhoneNumberInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) unmarshalNPhoneNumberSingleSortInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberSingleSortInput(ctx context.Context, v interface{}) (*PhoneNumberSingleSortInput, error) {
	res, err := ec.unmarshalInputPhoneNumberSingleSortInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNResourceAnnotationSingle2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐResourceAnnotationSingleᚄ(ctx context.Context, sel ast.SelectionSet, v []*ResourceAnnotationSingle) 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.marshalNResourceAnnotationSingle2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐResourceAnnotationSingle(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNResourceAnnotationSingle2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐResourceAnnotationSingle(ctx context.Context, sel ast.SelectionSet, v *ResourceAnnotationSingle) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._ResourceAnnotationSingle(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, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalNUSER_SORTABLE_FIELD2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserSortableField(ctx context.Context, v interface{}) (UserSortableField, error) {
	var res UserSortableField
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNUSER_SORTABLE_FIELD2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserSortableField(ctx context.Context, sel ast.SelectionSet, v UserSortableField) graphql.Marshaler {
	return v
}

func (ec *executionContext) marshalNUser2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐ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.marshalOUser2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUser(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	return ret
}

func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._User(ctx, sel, v)
}

func (ec *executionContext) unmarshalNUserSingleSortInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserSingleSortInput(ctx context.Context, v interface{}) (*UserSingleSortInput, error) {
	res, err := ec.unmarshalInputUserSingleSortInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNXgenObjectField2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []*XgenObjectField) 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.marshalNXgenObjectField2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectField(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) marshalNXgenObjectField2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectField(ctx context.Context, sel ast.SelectionSet, v *XgenObjectField) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._XgenObjectField(ctx, sel, v)
}

func (ec *executionContext) marshalNXgenResourceAction2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceAction(ctx context.Context, sel ast.SelectionSet, v []*XgenResourceAction) 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.marshalOXgenResourceAction2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceAction(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	return ret
}

func (ec *executionContext) unmarshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx context.Context, v interface{}) (XgenResourceActionType, error) {
	var res XgenResourceActionType
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNXgenResourceActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionType(ctx context.Context, sel ast.SelectionSet, v XgenResourceActionType) graphql.Marshaler {
	return v
}

func (ec *executionContext) unmarshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx context.Context, v interface{}) (XgenResourceListActionType, error) {
	var res XgenResourceListActionType
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNXgenResourceListActionType2githubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionType(ctx context.Context, sel ast.SelectionSet, v XgenResourceListActionType) graphql.Marshaler {
	return v
}

func (ec *executionContext) marshalNXgenSort2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSort(ctx context.Context, sel ast.SelectionSet, v *XgenSort) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._XgenSort(ctx, sel, v)
}

func (ec *executionContext) unmarshalNXgenSortInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortInput(ctx context.Context, v interface{}) (*XgenSortInput, error) {
	res, err := ec.unmarshalInputXgenSortInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
	var vSlice []interface{}
	if v != nil {
		vSlice = graphql.CoerceList(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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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, "the requested element is null which the schema does not allow")
		}
		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, "the requested element is null which the schema does not allow")
		}
	}
	return res
}

func (ec *executionContext) marshalOAction2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐAction(ctx context.Context, sel ast.SelectionSet, v *Action) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Action(ctx, sel, v)
}

func (ec *executionContext) marshalOActionField2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐActionField(ctx context.Context, sel ast.SelectionSet, v *ActionField) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._ActionField(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 {
	res := graphql.MarshalBoolean(v)
	return res
}

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
	}
	res := graphql.MarshalBoolean(*v)
	return res
}

func (ec *executionContext) marshalOCar2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCar(ctx context.Context, sel ast.SelectionSet, v *Car) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Car(ctx, sel, v)
}

func (ec *executionContext) unmarshalOCarBrowseInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarBrowseInput(ctx context.Context, v interface{}) (*CarBrowseInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputCarBrowseInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOCarBrowseInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarBrowseInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *CarBrowseInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._CarBrowseInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) unmarshalOCarInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarInputᚄ(ctx context.Context, v interface{}) ([]*CarInput, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		vSlice = graphql.CoerceList(v)
	}
	var err error
	res := make([]*CarInput, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNCarInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarInput(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOCarInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarInput(ctx context.Context, v interface{}) (*CarInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputCarInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOCarInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *CarInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._CarInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) unmarshalOCarSingleSortInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarSingleSortInputᚄ(ctx context.Context, v interface{}) ([]*CarSingleSortInput, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		vSlice = graphql.CoerceList(v)
	}
	var err error
	res := make([]*CarSingleSortInput, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNCarSingleSortInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarSingleSortInput(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOCarXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐCarXgenDef(ctx context.Context, sel ast.SelectionSet, v *CarXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._CarXgenDef(ctx, sel, v)
}

func (ec *executionContext) unmarshalODeleteUsers2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐDeleteUsers(ctx context.Context, v interface{}) (*DeleteUsers, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputDeleteUsers(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalODeleteUsersXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐDeleteUsersXgenDef(ctx context.Context, sel ast.SelectionSet, v *DeleteUsersXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._DeleteUsersXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOField2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐField(ctx context.Context, sel ast.SelectionSet, v *Field) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Field(ctx, sel, v)
}

func (ec *executionContext) unmarshalOID2ᚕintᚄ(ctx context.Context, v interface{}) ([]int, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		vSlice = graphql.CoerceList(v)
	}
	var err error
	res := make([]int, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNID2int(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOID2ᚕ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.marshalNID2int(ctx, sel, v[i])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOID2ᚖ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) marshalOID2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	res := graphql.MarshalInt(*v)
	return res
}

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
	}
	res := graphql.MarshalInt(*v)
	return res
}

func (ec *executionContext) marshalOListAction2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListAction(ctx context.Context, sel ast.SelectionSet, v *ListAction) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._ListAction(ctx, sel, v)
}

func (ec *executionContext) unmarshalOListUser2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListUser(ctx context.Context, v interface{}) (*ListUser, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputListUser(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOListUserXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐListUserXgenDef(ctx context.Context, sel ast.SelectionSet, v *ListUserXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._ListUserXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOPhone2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhone(ctx context.Context, sel ast.SelectionSet, v *Phone) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Phone(ctx, sel, v)
}

func (ec *executionContext) unmarshalOPhoneNumberBrowseInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberBrowseInput(ctx context.Context, v interface{}) (*PhoneNumberBrowseInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputPhoneNumberBrowseInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOPhoneNumberBrowseInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberBrowseInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *PhoneNumberBrowseInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._PhoneNumberBrowseInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) unmarshalOPhoneNumberInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberInputᚄ(ctx context.Context, v interface{}) ([]*PhoneNumberInput, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		vSlice = graphql.CoerceList(v)
	}
	var err error
	res := make([]*PhoneNumberInput, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNPhoneNumberInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberInput(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOPhoneNumberInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberInput(ctx context.Context, v interface{}) (*PhoneNumberInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputPhoneNumberInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOPhoneNumberInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *PhoneNumberInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._PhoneNumberInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) unmarshalOPhoneNumberSingleSortInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberSingleSortInputᚄ(ctx context.Context, v interface{}) ([]*PhoneNumberSingleSortInput, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		vSlice = graphql.CoerceList(v)
	}
	var err error
	res := make([]*PhoneNumberSingleSortInput, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNPhoneNumberSingleSortInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneNumberSingleSortInput(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOPhoneXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐPhoneXgenDef(ctx context.Context, sel ast.SelectionSet, v *PhoneXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._PhoneXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOResource2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐResource(ctx context.Context, sel ast.SelectionSet, v *Resource) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._Resource(ctx, sel, 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 {
		vSlice = graphql.CoerceList(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])
	}

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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
	}
	res := graphql.MarshalString(*v)
	return res
}

func (ec *executionContext) marshalOUser2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐ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) unmarshalOUserInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserInput(ctx context.Context, v interface{}) (*UserInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputUserInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOUserInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *UserInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._UserInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) unmarshalOUserSingleSortInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserSingleSortInputᚄ(ctx context.Context, v interface{}) ([]*UserSingleSortInput, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		vSlice = graphql.CoerceList(v)
	}
	var err error
	res := make([]*UserSingleSortInput, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNUserSingleSortInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserSingleSortInput(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) unmarshalOUserSortInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserSortInput(ctx context.Context, v interface{}) (*UserSortInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputUserSortInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOUserXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐUserXgenDef(ctx context.Context, sel ast.SelectionSet, v *UserXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._UserXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenAnnotationMap2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenAnnotationMap(ctx context.Context, sel ast.SelectionSet, v *XgenAnnotationMap) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenAnnotationMap(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenCursorPaginationInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenCursorPaginationInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenCursorPaginationInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenCursorPaginationInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenFieldDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenFieldDef(ctx context.Context, sel ast.SelectionSet, v *XgenFieldDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenFieldDef(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenIntrospection2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenIntrospection(ctx context.Context, sel ast.SelectionSet, v *XgenIntrospection) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenIntrospection(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenObjectDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectDefinition(ctx context.Context, sel ast.SelectionSet, v *XgenObjectDefinition) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenObjectDefinition(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenObjectMap2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenObjectMap(ctx context.Context, sel ast.SelectionSet, v *XgenObjectMap) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenObjectMap(ctx, sel, v)
}

func (ec *executionContext) unmarshalOXgenPaginationInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenPaginationInput(ctx context.Context, v interface{}) (*XgenPaginationInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputXgenPaginationInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOXgenPaginationInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenPaginationInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenPaginationInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenPaginationInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenResourceAction2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceAction(ctx context.Context, sel ast.SelectionSet, v *XgenResourceAction) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenResourceAction(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenResourceActionTypeXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceActionTypeXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenResourceActionTypeXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenResourceActionTypeXgenDef(ctx, sel, v)
}

func (ec *executionContext) unmarshalOXgenResourceDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInput(ctx context.Context, v interface{}) (*XgenResourceDbConfigInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputXgenResourceDbConfigInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOXgenResourceDbConfigInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDbConfigInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenResourceDbConfigInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenResourceDbConfigInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenResourceDefinition2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceDefinition(ctx context.Context, sel ast.SelectionSet, v *XgenResourceDefinition) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenResourceDefinition(ctx, sel, v)
}

func (ec *executionContext) unmarshalOXgenResourceFieldDbConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInput(ctx context.Context, v interface{}) (*XgenResourceFieldDbConfigInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputXgenResourceFieldDbConfigInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOXgenResourceFieldDbConfigInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceFieldDbConfigInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenResourceFieldDbConfigInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenResourceFieldDbConfigInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenResourceListActionTypeXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceListActionTypeXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenResourceListActionTypeXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenResourceListActionTypeXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenResourceMap2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceMap(ctx context.Context, sel ast.SelectionSet, v *XgenResourceMap) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenResourceMap(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenResourceProperty2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenResourceProperty(ctx context.Context, sel ast.SelectionSet, v *XgenResourceProperty) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenResourceProperty(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenSort2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortᚄ(ctx context.Context, sel ast.SelectionSet, v []*XgenSort) 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.marshalNXgenSort2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSort(ctx, sel, v[i])
		}
		if isLen1 {
			f(i)
		} else {
			go f(i)
		}

	}
	wg.Wait()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	return ret
}

func (ec *executionContext) unmarshalOXgenSortDirection2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortDirection(ctx context.Context, v interface{}) (*XgenSortDirection, error) {
	if v == nil {
		return nil, nil
	}
	var res = new(XgenSortDirection)
	err := res.UnmarshalGQL(v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOXgenSortDirection2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortDirection(ctx context.Context, sel ast.SelectionSet, v *XgenSortDirection) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return v
}

func (ec *executionContext) marshalOXgenSortDirectionXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortDirectionXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenSortDirectionXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenSortDirectionXgenDef(ctx, sel, v)
}

func (ec *executionContext) unmarshalOXgenSortInput2ᚕᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortInputᚄ(ctx context.Context, v interface{}) ([]*XgenSortInput, error) {
	if v == nil {
		return nil, nil
	}
	var vSlice []interface{}
	if v != nil {
		vSlice = graphql.CoerceList(v)
	}
	var err error
	res := make([]*XgenSortInput, len(vSlice))
	for i := range vSlice {
		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
		res[i], err = ec.unmarshalNXgenSortInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortInput(ctx, vSlice[i])
		if err != nil {
			return nil, err
		}
	}
	return res, nil
}

func (ec *executionContext) marshalOXgenSortInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenSortInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenSortInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenSortResourceConfig2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortResourceConfig(ctx context.Context, sel ast.SelectionSet, v *XgenSortResourceConfig) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenSortResourceConfig(ctx, sel, v)
}

func (ec *executionContext) unmarshalOXgenSortResourceConfigInput2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortResourceConfigInput(ctx context.Context, v interface{}) (*XgenSortResourceConfigInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputXgenSortResourceConfigInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalOXgenSortResourceConfigInputXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortResourceConfigInputXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenSortResourceConfigInputXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenSortResourceConfigInputXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenSortResourceConfigXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortResourceConfigXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenSortResourceConfigXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenSortResourceConfigXgenDef(ctx, sel, v)
}

func (ec *executionContext) marshalOXgenSortXgenDef2ᚖgithubᚗcomᚋgoxgenᚋgoxgenᚋcmdᚋinternalᚋintegrationᚋgorm_advancedᚋgeneratedᚐXgenSortXgenDef(ctx context.Context, sel ast.SelectionSet, v *XgenSortXgenDef) graphql.Marshaler {
	if v == nil {
		return graphql.Null
	}
	return ec._XgenSortXgenDef(ctx, sel, v)
}

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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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()

	for _, e := range ret {
		if e == graphql.Null {
			return graphql.Null
		}
	}

	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 *****************************