gql_collection.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"

	"entgo.io/contrib/entgql"
	"entgo.io/ent/dialect/sql"
	"github.com/99designs/gqlgen/graphql"
	"github.com/ecshreve/dndgen/ent/abilitybonus"
	"github.com/ecshreve/dndgen/ent/abilityscore"
	"github.com/ecshreve/dndgen/ent/armor"
	"github.com/ecshreve/dndgen/ent/armorclass"
	"github.com/ecshreve/dndgen/ent/class"
	"github.com/ecshreve/dndgen/ent/coin"
	"github.com/ecshreve/dndgen/ent/damagetype"
	"github.com/ecshreve/dndgen/ent/equipment"
	"github.com/ecshreve/dndgen/ent/equipmentcategory"
	"github.com/ecshreve/dndgen/ent/equipmentchoice"
	"github.com/ecshreve/dndgen/ent/equipmentcost"
	"github.com/ecshreve/dndgen/ent/gear"
	"github.com/ecshreve/dndgen/ent/language"
	"github.com/ecshreve/dndgen/ent/magicschool"
	"github.com/ecshreve/dndgen/ent/proficiency"
	"github.com/ecshreve/dndgen/ent/proficiencychoice"
	"github.com/ecshreve/dndgen/ent/race"
	"github.com/ecshreve/dndgen/ent/rule"
	"github.com/ecshreve/dndgen/ent/rulesection"
	"github.com/ecshreve/dndgen/ent/skill"
	"github.com/ecshreve/dndgen/ent/subrace"
	"github.com/ecshreve/dndgen/ent/tool"
	"github.com/ecshreve/dndgen/ent/trait"
	"github.com/ecshreve/dndgen/ent/vehicle"
	"github.com/ecshreve/dndgen/ent/weapon"
	"github.com/ecshreve/dndgen/ent/weapondamage"
	"github.com/ecshreve/dndgen/ent/weaponproperty"
)

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (ab *AbilityBonusQuery) CollectFields(ctx context.Context, satisfies ...string) (*AbilityBonusQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return ab, nil
	}
	if err := ab.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return ab, nil
}

func (ab *AbilityBonusQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(abilitybonus.Columns))
		selectedFields = []string{abilitybonus.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "abilityScore":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AbilityScoreClient{config: ab.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ab.withAbilityScore = query
			if _, ok := fieldSeen[abilitybonus.FieldAbilityScoreID]; !ok {
				selectedFields = append(selectedFields, abilitybonus.FieldAbilityScoreID)
				fieldSeen[abilitybonus.FieldAbilityScoreID] = struct{}{}
			}
		case "race":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&RaceClient{config: ab.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ab.withRace = query
		case "subrace":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&SubraceClient{config: ab.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ab.withSubrace = query
		case "abilityScoreID":
			if _, ok := fieldSeen[abilitybonus.FieldAbilityScoreID]; !ok {
				selectedFields = append(selectedFields, abilitybonus.FieldAbilityScoreID)
				fieldSeen[abilitybonus.FieldAbilityScoreID] = struct{}{}
			}
		case "bonus":
			if _, ok := fieldSeen[abilitybonus.FieldBonus]; !ok {
				selectedFields = append(selectedFields, abilitybonus.FieldBonus)
				fieldSeen[abilitybonus.FieldBonus] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ab.Select(selectedFields...)
	}
	return nil
}

type abilitybonusPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AbilityBonusPaginateOption
}

func newAbilityBonusPaginateArgs(rv map[string]any) *abilitybonusPaginateArgs {
	args := &abilitybonusPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[whereField].(*AbilityBonusWhereInput); ok {
		args.opts = append(args.opts, WithAbilityBonusFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (as *AbilityScoreQuery) CollectFields(ctx context.Context, satisfies ...string) (*AbilityScoreQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return as, nil
	}
	if err := as.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return as, nil
}

func (as *AbilityScoreQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(abilityscore.Columns))
		selectedFields = []string{abilityscore.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "skills":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&SkillClient{config: as.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			as.WithNamedSkills(alias, func(wq *SkillQuery) {
				*wq = *query
			})
		case "abilityBonuses":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AbilityBonusClient{config: as.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			as.WithNamedAbilityBonuses(alias, func(wq *AbilityBonusQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[abilityscore.FieldIndx]; !ok {
				selectedFields = append(selectedFields, abilityscore.FieldIndx)
				fieldSeen[abilityscore.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[abilityscore.FieldName]; !ok {
				selectedFields = append(selectedFields, abilityscore.FieldName)
				fieldSeen[abilityscore.FieldName] = struct{}{}
			}
		case "fullName":
			if _, ok := fieldSeen[abilityscore.FieldFullName]; !ok {
				selectedFields = append(selectedFields, abilityscore.FieldFullName)
				fieldSeen[abilityscore.FieldFullName] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[abilityscore.FieldDesc]; !ok {
				selectedFields = append(selectedFields, abilityscore.FieldDesc)
				fieldSeen[abilityscore.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		as.Select(selectedFields...)
	}
	return nil
}

type abilityscorePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AbilityScorePaginateOption
}

func newAbilityScorePaginateArgs(rv map[string]any) *abilityscorePaginateArgs {
	args := &abilityscorePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &AbilityScoreOrder{Field: &AbilityScoreOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithAbilityScoreOrder(order))
			}
		case *AbilityScoreOrder:
			if v != nil {
				args.opts = append(args.opts, WithAbilityScoreOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AbilityScoreWhereInput); ok {
		args.opts = append(args.opts, WithAbilityScoreFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (a *ArmorQuery) CollectFields(ctx context.Context, satisfies ...string) (*ArmorQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return a, nil
	}
	if err := a.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return a, nil
}

func (a *ArmorQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(armor.Columns))
		selectedFields = []string{armor.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "equipment":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentClient{config: a.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			a.withEquipment = query
			if _, ok := fieldSeen[armor.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, armor.FieldEquipmentID)
				fieldSeen[armor.FieldEquipmentID] = struct{}{}
			}
		case "armorClass":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ArmorClassClient{config: a.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			a.WithNamedArmorClass(alias, func(wq *ArmorClassQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[armor.FieldIndx]; !ok {
				selectedFields = append(selectedFields, armor.FieldIndx)
				fieldSeen[armor.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[armor.FieldName]; !ok {
				selectedFields = append(selectedFields, armor.FieldName)
				fieldSeen[armor.FieldName] = struct{}{}
			}
		case "armorCategory":
			if _, ok := fieldSeen[armor.FieldArmorCategory]; !ok {
				selectedFields = append(selectedFields, armor.FieldArmorCategory)
				fieldSeen[armor.FieldArmorCategory] = struct{}{}
			}
		case "stealthDisadvantage":
			if _, ok := fieldSeen[armor.FieldStealthDisadvantage]; !ok {
				selectedFields = append(selectedFields, armor.FieldStealthDisadvantage)
				fieldSeen[armor.FieldStealthDisadvantage] = struct{}{}
			}
		case "minStrength":
			if _, ok := fieldSeen[armor.FieldMinStrength]; !ok {
				selectedFields = append(selectedFields, armor.FieldMinStrength)
				fieldSeen[armor.FieldMinStrength] = struct{}{}
			}
		case "equipmentID":
			if _, ok := fieldSeen[armor.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, armor.FieldEquipmentID)
				fieldSeen[armor.FieldEquipmentID] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		a.Select(selectedFields...)
	}
	return nil
}

type armorPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ArmorPaginateOption
}

func newArmorPaginateArgs(rv map[string]any) *armorPaginateArgs {
	args := &armorPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &ArmorOrder{Field: &ArmorOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithArmorOrder(order))
			}
		case *ArmorOrder:
			if v != nil {
				args.opts = append(args.opts, WithArmorOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*ArmorWhereInput); ok {
		args.opts = append(args.opts, WithArmorFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (ac *ArmorClassQuery) CollectFields(ctx context.Context, satisfies ...string) (*ArmorClassQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return ac, nil
	}
	if err := ac.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return ac, nil
}

func (ac *ArmorClassQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(armorclass.Columns))
		selectedFields = []string{armorclass.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "base":
			if _, ok := fieldSeen[armorclass.FieldBase]; !ok {
				selectedFields = append(selectedFields, armorclass.FieldBase)
				fieldSeen[armorclass.FieldBase] = struct{}{}
			}
		case "dexBonus":
			if _, ok := fieldSeen[armorclass.FieldDexBonus]; !ok {
				selectedFields = append(selectedFields, armorclass.FieldDexBonus)
				fieldSeen[armorclass.FieldDexBonus] = struct{}{}
			}
		case "maxBonus":
			if _, ok := fieldSeen[armorclass.FieldMaxBonus]; !ok {
				selectedFields = append(selectedFields, armorclass.FieldMaxBonus)
				fieldSeen[armorclass.FieldMaxBonus] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ac.Select(selectedFields...)
	}
	return nil
}

type armorclassPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ArmorClassPaginateOption
}

func newArmorClassPaginateArgs(rv map[string]any) *armorclassPaginateArgs {
	args := &armorclassPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[whereField].(*ArmorClassWhereInput); ok {
		args.opts = append(args.opts, WithArmorClassFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (c *ClassQuery) CollectFields(ctx context.Context, satisfies ...string) (*ClassQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return c, nil
	}
	if err := c.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return c, nil
}

func (c *ClassQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(class.Columns))
		selectedFields = []string{class.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "proficiencies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ProficiencyClient{config: c.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			c.WithNamedProficiencies(alias, func(wq *ProficiencyQuery) {
				*wq = *query
			})
		case "proficiencyChoices":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ProficiencyChoiceClient{config: c.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			c.WithNamedProficiencyChoices(alias, func(wq *ProficiencyChoiceQuery) {
				*wq = *query
			})
		case "equipment":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentClient{config: c.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			c.WithNamedEquipment(alias, func(wq *EquipmentQuery) {
				*wq = *query
			})
		case "equipmentChoices":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentChoiceClient{config: c.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			c.WithNamedEquipmentChoices(alias, func(wq *EquipmentChoiceQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[class.FieldIndx]; !ok {
				selectedFields = append(selectedFields, class.FieldIndx)
				fieldSeen[class.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[class.FieldName]; !ok {
				selectedFields = append(selectedFields, class.FieldName)
				fieldSeen[class.FieldName] = struct{}{}
			}
		case "hitDie":
			if _, ok := fieldSeen[class.FieldHitDie]; !ok {
				selectedFields = append(selectedFields, class.FieldHitDie)
				fieldSeen[class.FieldHitDie] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		c.Select(selectedFields...)
	}
	return nil
}

type classPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ClassPaginateOption
}

func newClassPaginateArgs(rv map[string]any) *classPaginateArgs {
	args := &classPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &ClassOrder{Field: &ClassOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithClassOrder(order))
			}
		case *ClassOrder:
			if v != nil {
				args.opts = append(args.opts, WithClassOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*ClassWhereInput); ok {
		args.opts = append(args.opts, WithClassFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (c *CoinQuery) CollectFields(ctx context.Context, satisfies ...string) (*CoinQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return c, nil
	}
	if err := c.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return c, nil
}

func (c *CoinQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(coin.Columns))
		selectedFields = []string{coin.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "indx":
			if _, ok := fieldSeen[coin.FieldIndx]; !ok {
				selectedFields = append(selectedFields, coin.FieldIndx)
				fieldSeen[coin.FieldIndx] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[coin.FieldDesc]; !ok {
				selectedFields = append(selectedFields, coin.FieldDesc)
				fieldSeen[coin.FieldDesc] = struct{}{}
			}
		case "goldConversionRate":
			if _, ok := fieldSeen[coin.FieldGoldConversionRate]; !ok {
				selectedFields = append(selectedFields, coin.FieldGoldConversionRate)
				fieldSeen[coin.FieldGoldConversionRate] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		c.Select(selectedFields...)
	}
	return nil
}

type coinPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []CoinPaginateOption
}

func newCoinPaginateArgs(rv map[string]any) *coinPaginateArgs {
	args := &coinPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[whereField].(*CoinWhereInput); ok {
		args.opts = append(args.opts, WithCoinFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (dt *DamageTypeQuery) CollectFields(ctx context.Context, satisfies ...string) (*DamageTypeQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return dt, nil
	}
	if err := dt.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return dt, nil
}

func (dt *DamageTypeQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(damagetype.Columns))
		selectedFields = []string{damagetype.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "weaponDamage":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&WeaponDamageClient{config: dt.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			dt.WithNamedWeaponDamage(alias, func(wq *WeaponDamageQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[damagetype.FieldIndx]; !ok {
				selectedFields = append(selectedFields, damagetype.FieldIndx)
				fieldSeen[damagetype.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[damagetype.FieldName]; !ok {
				selectedFields = append(selectedFields, damagetype.FieldName)
				fieldSeen[damagetype.FieldName] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[damagetype.FieldDesc]; !ok {
				selectedFields = append(selectedFields, damagetype.FieldDesc)
				fieldSeen[damagetype.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		dt.Select(selectedFields...)
	}
	return nil
}

type damagetypePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []DamageTypePaginateOption
}

func newDamageTypePaginateArgs(rv map[string]any) *damagetypePaginateArgs {
	args := &damagetypePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &DamageTypeOrder{Field: &DamageTypeOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithDamageTypeOrder(order))
			}
		case *DamageTypeOrder:
			if v != nil {
				args.opts = append(args.opts, WithDamageTypeOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*DamageTypeWhereInput); ok {
		args.opts = append(args.opts, WithDamageTypeFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (e *EquipmentQuery) CollectFields(ctx context.Context, satisfies ...string) (*EquipmentQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return e, nil
	}
	if err := e.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return e, nil
}

func (e *EquipmentQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(equipment.Columns))
		selectedFields = []string{equipment.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "equipmentCategory":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentCategoryClient{config: e.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			e.WithNamedEquipmentCategory(alias, func(wq *EquipmentCategoryQuery) {
				*wq = *query
			})
		case "cost":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentCostClient{config: e.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			e.withCost = query
		case "weapon":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&WeaponClient{config: e.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			e.withWeapon = query
		case "armor":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ArmorClient{config: e.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			e.withArmor = query
		case "gear":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&GearClient{config: e.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			e.withGear = query
		case "tool":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ToolClient{config: e.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			e.withTool = query
		case "vehicle":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&VehicleClient{config: e.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			e.withVehicle = query
		case "class":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ClassClient{config: e.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			e.WithNamedClass(alias, func(wq *ClassQuery) {
				*wq = *query
			})
		case "choice":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentChoiceClient{config: e.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			e.WithNamedChoice(alias, func(wq *EquipmentChoiceQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[equipment.FieldIndx]; !ok {
				selectedFields = append(selectedFields, equipment.FieldIndx)
				fieldSeen[equipment.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[equipment.FieldName]; !ok {
				selectedFields = append(selectedFields, equipment.FieldName)
				fieldSeen[equipment.FieldName] = struct{}{}
			}
		case "weight":
			if _, ok := fieldSeen[equipment.FieldWeight]; !ok {
				selectedFields = append(selectedFields, equipment.FieldWeight)
				fieldSeen[equipment.FieldWeight] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		e.Select(selectedFields...)
	}
	return nil
}

type equipmentPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []EquipmentPaginateOption
}

func newEquipmentPaginateArgs(rv map[string]any) *equipmentPaginateArgs {
	args := &equipmentPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &EquipmentOrder{Field: &EquipmentOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithEquipmentOrder(order))
			}
		case *EquipmentOrder:
			if v != nil {
				args.opts = append(args.opts, WithEquipmentOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*EquipmentWhereInput); ok {
		args.opts = append(args.opts, WithEquipmentFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (ec *EquipmentCategoryQuery) CollectFields(ctx context.Context, satisfies ...string) (*EquipmentCategoryQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return ec, nil
	}
	if err := ec.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return ec, nil
}

func (ec *EquipmentCategoryQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(equipmentcategory.Columns))
		selectedFields = []string{equipmentcategory.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "parent":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentCategoryClient{config: ec.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ec.withParent = query
			if _, ok := fieldSeen[equipmentcategory.FieldParentCategoryID]; !ok {
				selectedFields = append(selectedFields, equipmentcategory.FieldParentCategoryID)
				fieldSeen[equipmentcategory.FieldParentCategoryID] = struct{}{}
			}
		case "children":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentCategoryClient{config: ec.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ec.WithNamedChildren(alias, func(wq *EquipmentCategoryQuery) {
				*wq = *query
			})
		case "equipment":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentClient{config: ec.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ec.WithNamedEquipment(alias, func(wq *EquipmentQuery) {
				*wq = *query
			})
		case "parentCategoryID":
			if _, ok := fieldSeen[equipmentcategory.FieldParentCategoryID]; !ok {
				selectedFields = append(selectedFields, equipmentcategory.FieldParentCategoryID)
				fieldSeen[equipmentcategory.FieldParentCategoryID] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[equipmentcategory.FieldName]; !ok {
				selectedFields = append(selectedFields, equipmentcategory.FieldName)
				fieldSeen[equipmentcategory.FieldName] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ec.Select(selectedFields...)
	}
	return nil
}

type equipmentcategoryPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []EquipmentCategoryPaginateOption
}

func newEquipmentCategoryPaginateArgs(rv map[string]any) *equipmentcategoryPaginateArgs {
	args := &equipmentcategoryPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[whereField].(*EquipmentCategoryWhereInput); ok {
		args.opts = append(args.opts, WithEquipmentCategoryFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (ec *EquipmentChoiceQuery) CollectFields(ctx context.Context, satisfies ...string) (*EquipmentChoiceQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return ec, nil
	}
	if err := ec.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return ec, nil
}

func (ec *EquipmentChoiceQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(equipmentchoice.Columns))
		selectedFields = []string{equipmentchoice.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "class":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ClassClient{config: ec.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ec.WithNamedClass(alias, func(wq *ClassQuery) {
				*wq = *query
			})
		case "equipment":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentClient{config: ec.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ec.WithNamedEquipment(alias, func(wq *EquipmentQuery) {
				*wq = *query
			})
		case "choose":
			if _, ok := fieldSeen[equipmentchoice.FieldChoose]; !ok {
				selectedFields = append(selectedFields, equipmentchoice.FieldChoose)
				fieldSeen[equipmentchoice.FieldChoose] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[equipmentchoice.FieldDesc]; !ok {
				selectedFields = append(selectedFields, equipmentchoice.FieldDesc)
				fieldSeen[equipmentchoice.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ec.Select(selectedFields...)
	}
	return nil
}

type equipmentchoicePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []EquipmentChoicePaginateOption
}

func newEquipmentChoicePaginateArgs(rv map[string]any) *equipmentchoicePaginateArgs {
	args := &equipmentchoicePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[whereField].(*EquipmentChoiceWhereInput); ok {
		args.opts = append(args.opts, WithEquipmentChoiceFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (ec *EquipmentCostQuery) CollectFields(ctx context.Context, satisfies ...string) (*EquipmentCostQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return ec, nil
	}
	if err := ec.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return ec, nil
}

func (ec *EquipmentCostQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(equipmentcost.Columns))
		selectedFields = []string{equipmentcost.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "equipment":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentClient{config: ec.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ec.withEquipment = query
			if _, ok := fieldSeen[equipmentcost.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, equipmentcost.FieldEquipmentID)
				fieldSeen[equipmentcost.FieldEquipmentID] = struct{}{}
			}
		case "coin":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&CoinClient{config: ec.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ec.withCoin = query
			if _, ok := fieldSeen[equipmentcost.FieldCoinID]; !ok {
				selectedFields = append(selectedFields, equipmentcost.FieldCoinID)
				fieldSeen[equipmentcost.FieldCoinID] = struct{}{}
			}
		case "equipmentID":
			if _, ok := fieldSeen[equipmentcost.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, equipmentcost.FieldEquipmentID)
				fieldSeen[equipmentcost.FieldEquipmentID] = struct{}{}
			}
		case "coinID":
			if _, ok := fieldSeen[equipmentcost.FieldCoinID]; !ok {
				selectedFields = append(selectedFields, equipmentcost.FieldCoinID)
				fieldSeen[equipmentcost.FieldCoinID] = struct{}{}
			}
		case "quantity":
			if _, ok := fieldSeen[equipmentcost.FieldQuantity]; !ok {
				selectedFields = append(selectedFields, equipmentcost.FieldQuantity)
				fieldSeen[equipmentcost.FieldQuantity] = struct{}{}
			}
		case "gpValue":
			if _, ok := fieldSeen[equipmentcost.FieldGpValue]; !ok {
				selectedFields = append(selectedFields, equipmentcost.FieldGpValue)
				fieldSeen[equipmentcost.FieldGpValue] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ec.Select(selectedFields...)
	}
	return nil
}

type equipmentcostPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []EquipmentCostPaginateOption
}

func newEquipmentCostPaginateArgs(rv map[string]any) *equipmentcostPaginateArgs {
	args := &equipmentcostPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[whereField].(*EquipmentCostWhereInput); ok {
		args.opts = append(args.opts, WithEquipmentCostFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (ge *GearQuery) CollectFields(ctx context.Context, satisfies ...string) (*GearQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return ge, nil
	}
	if err := ge.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return ge, nil
}

func (ge *GearQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(gear.Columns))
		selectedFields = []string{gear.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "equipment":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentClient{config: ge.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			ge.withEquipment = query
			if _, ok := fieldSeen[gear.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, gear.FieldEquipmentID)
				fieldSeen[gear.FieldEquipmentID] = struct{}{}
			}
		case "indx":
			if _, ok := fieldSeen[gear.FieldIndx]; !ok {
				selectedFields = append(selectedFields, gear.FieldIndx)
				fieldSeen[gear.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[gear.FieldName]; !ok {
				selectedFields = append(selectedFields, gear.FieldName)
				fieldSeen[gear.FieldName] = struct{}{}
			}
		case "gearCategory":
			if _, ok := fieldSeen[gear.FieldGearCategory]; !ok {
				selectedFields = append(selectedFields, gear.FieldGearCategory)
				fieldSeen[gear.FieldGearCategory] = struct{}{}
			}
		case "quantity":
			if _, ok := fieldSeen[gear.FieldQuantity]; !ok {
				selectedFields = append(selectedFields, gear.FieldQuantity)
				fieldSeen[gear.FieldQuantity] = struct{}{}
			}
		case "equipmentID":
			if _, ok := fieldSeen[gear.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, gear.FieldEquipmentID)
				fieldSeen[gear.FieldEquipmentID] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ge.Select(selectedFields...)
	}
	return nil
}

type gearPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []GearPaginateOption
}

func newGearPaginateArgs(rv map[string]any) *gearPaginateArgs {
	args := &gearPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &GearOrder{Field: &GearOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithGearOrder(order))
			}
		case *GearOrder:
			if v != nil {
				args.opts = append(args.opts, WithGearOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*GearWhereInput); ok {
		args.opts = append(args.opts, WithGearFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (l *LanguageQuery) CollectFields(ctx context.Context, satisfies ...string) (*LanguageQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return l, nil
	}
	if err := l.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return l, nil
}

func (l *LanguageQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(language.Columns))
		selectedFields = []string{language.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "raceSpeakers":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&RaceClient{config: l.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			l.WithNamedRaceSpeakers(alias, func(wq *RaceQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[language.FieldIndx]; !ok {
				selectedFields = append(selectedFields, language.FieldIndx)
				fieldSeen[language.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[language.FieldName]; !ok {
				selectedFields = append(selectedFields, language.FieldName)
				fieldSeen[language.FieldName] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[language.FieldDesc]; !ok {
				selectedFields = append(selectedFields, language.FieldDesc)
				fieldSeen[language.FieldDesc] = struct{}{}
			}
		case "languageType":
			if _, ok := fieldSeen[language.FieldLanguageType]; !ok {
				selectedFields = append(selectedFields, language.FieldLanguageType)
				fieldSeen[language.FieldLanguageType] = struct{}{}
			}
		case "script":
			if _, ok := fieldSeen[language.FieldScript]; !ok {
				selectedFields = append(selectedFields, language.FieldScript)
				fieldSeen[language.FieldScript] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		l.Select(selectedFields...)
	}
	return nil
}

type languagePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []LanguagePaginateOption
}

func newLanguagePaginateArgs(rv map[string]any) *languagePaginateArgs {
	args := &languagePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &LanguageOrder{Field: &LanguageOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithLanguageOrder(order))
			}
		case *LanguageOrder:
			if v != nil {
				args.opts = append(args.opts, WithLanguageOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*LanguageWhereInput); ok {
		args.opts = append(args.opts, WithLanguageFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (ms *MagicSchoolQuery) CollectFields(ctx context.Context, satisfies ...string) (*MagicSchoolQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return ms, nil
	}
	if err := ms.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return ms, nil
}

func (ms *MagicSchoolQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(magicschool.Columns))
		selectedFields = []string{magicschool.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "indx":
			if _, ok := fieldSeen[magicschool.FieldIndx]; !ok {
				selectedFields = append(selectedFields, magicschool.FieldIndx)
				fieldSeen[magicschool.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[magicschool.FieldName]; !ok {
				selectedFields = append(selectedFields, magicschool.FieldName)
				fieldSeen[magicschool.FieldName] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[magicschool.FieldDesc]; !ok {
				selectedFields = append(selectedFields, magicschool.FieldDesc)
				fieldSeen[magicschool.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ms.Select(selectedFields...)
	}
	return nil
}

type magicschoolPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []MagicSchoolPaginateOption
}

func newMagicSchoolPaginateArgs(rv map[string]any) *magicschoolPaginateArgs {
	args := &magicschoolPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &MagicSchoolOrder{Field: &MagicSchoolOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithMagicSchoolOrder(order))
			}
		case *MagicSchoolOrder:
			if v != nil {
				args.opts = append(args.opts, WithMagicSchoolOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*MagicSchoolWhereInput); ok {
		args.opts = append(args.opts, WithMagicSchoolFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (pr *ProficiencyQuery) CollectFields(ctx context.Context, satisfies ...string) (*ProficiencyQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return pr, nil
	}
	if err := pr.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return pr, nil
}

func (pr *ProficiencyQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(proficiency.Columns))
		selectedFields = []string{proficiency.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "classes":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ClassClient{config: pr.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedClasses(alias, func(wq *ClassQuery) {
				*wq = *query
			})
		case "races":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&RaceClient{config: pr.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedRaces(alias, func(wq *RaceQuery) {
				*wq = *query
			})
		case "subraces":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&SubraceClient{config: pr.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedSubraces(alias, func(wq *SubraceQuery) {
				*wq = *query
			})
		case "choice":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ProficiencyChoiceClient{config: pr.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedChoice(alias, func(wq *ProficiencyChoiceQuery) {
				*wq = *query
			})
		case "skill":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&SkillClient{config: pr.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedSkill(alias, func(wq *SkillQuery) {
				*wq = *query
			})
		case "equipment":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentClient{config: pr.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedEquipment(alias, func(wq *EquipmentQuery) {
				*wq = *query
			})
		case "equipmentCategory":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentCategoryClient{config: pr.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedEquipmentCategory(alias, func(wq *EquipmentCategoryQuery) {
				*wq = *query
			})
		case "savingThrow":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AbilityScoreClient{config: pr.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pr.WithNamedSavingThrow(alias, func(wq *AbilityScoreQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[proficiency.FieldIndx]; !ok {
				selectedFields = append(selectedFields, proficiency.FieldIndx)
				fieldSeen[proficiency.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[proficiency.FieldName]; !ok {
				selectedFields = append(selectedFields, proficiency.FieldName)
				fieldSeen[proficiency.FieldName] = struct{}{}
			}
		case "proficiencyCategory":
			if _, ok := fieldSeen[proficiency.FieldProficiencyCategory]; !ok {
				selectedFields = append(selectedFields, proficiency.FieldProficiencyCategory)
				fieldSeen[proficiency.FieldProficiencyCategory] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		pr.Select(selectedFields...)
	}
	return nil
}

type proficiencyPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ProficiencyPaginateOption
}

func newProficiencyPaginateArgs(rv map[string]any) *proficiencyPaginateArgs {
	args := &proficiencyPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &ProficiencyOrder{Field: &ProficiencyOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithProficiencyOrder(order))
			}
		case *ProficiencyOrder:
			if v != nil {
				args.opts = append(args.opts, WithProficiencyOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*ProficiencyWhereInput); ok {
		args.opts = append(args.opts, WithProficiencyFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (pc *ProficiencyChoiceQuery) CollectFields(ctx context.Context, satisfies ...string) (*ProficiencyChoiceQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return pc, nil
	}
	if err := pc.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return pc, nil
}

func (pc *ProficiencyChoiceQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(proficiencychoice.Columns))
		selectedFields = []string{proficiencychoice.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "proficiency":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ProficiencyClient{config: pc.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pc.WithNamedProficiency(alias, func(wq *ProficiencyQuery) {
				*wq = *query
			})
		case "parentChoice":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ProficiencyChoiceClient{config: pc.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pc.withParentChoice = query
		case "subChoice":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ProficiencyChoiceClient{config: pc.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pc.WithNamedSubChoice(alias, func(wq *ProficiencyChoiceQuery) {
				*wq = *query
			})
		case "class":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ClassClient{config: pc.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pc.WithNamedClass(alias, func(wq *ClassQuery) {
				*wq = *query
			})
		case "race":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&RaceClient{config: pc.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			pc.WithNamedRace(alias, func(wq *RaceQuery) {
				*wq = *query
			})
		case "choose":
			if _, ok := fieldSeen[proficiencychoice.FieldChoose]; !ok {
				selectedFields = append(selectedFields, proficiencychoice.FieldChoose)
				fieldSeen[proficiencychoice.FieldChoose] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[proficiencychoice.FieldDesc]; !ok {
				selectedFields = append(selectedFields, proficiencychoice.FieldDesc)
				fieldSeen[proficiencychoice.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		pc.Select(selectedFields...)
	}
	return nil
}

type proficiencychoicePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ProficiencyChoicePaginateOption
}

func newProficiencyChoicePaginateArgs(rv map[string]any) *proficiencychoicePaginateArgs {
	args := &proficiencychoicePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[whereField].(*ProficiencyChoiceWhereInput); ok {
		args.opts = append(args.opts, WithProficiencyChoiceFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (r *RaceQuery) CollectFields(ctx context.Context, satisfies ...string) (*RaceQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return r, nil
	}
	if err := r.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return r, nil
}

func (r *RaceQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(race.Columns))
		selectedFields = []string{race.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "proficiencies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ProficiencyClient{config: r.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			r.WithNamedProficiencies(alias, func(wq *ProficiencyQuery) {
				*wq = *query
			})
		case "proficiencyChoice":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ProficiencyChoiceClient{config: r.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			r.WithNamedProficiencyChoice(alias, func(wq *ProficiencyChoiceQuery) {
				*wq = *query
			})
		case "languages":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&LanguageClient{config: r.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			r.WithNamedLanguages(alias, func(wq *LanguageQuery) {
				*wq = *query
			})
		case "subrace":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&SubraceClient{config: r.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			r.WithNamedSubrace(alias, func(wq *SubraceQuery) {
				*wq = *query
			})
		case "traits":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&TraitClient{config: r.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			r.WithNamedTraits(alias, func(wq *TraitQuery) {
				*wq = *query
			})
		case "abilityBonuses":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AbilityBonusClient{config: r.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			r.WithNamedAbilityBonuses(alias, func(wq *AbilityBonusQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[race.FieldIndx]; !ok {
				selectedFields = append(selectedFields, race.FieldIndx)
				fieldSeen[race.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[race.FieldName]; !ok {
				selectedFields = append(selectedFields, race.FieldName)
				fieldSeen[race.FieldName] = struct{}{}
			}
		case "alignment":
			if _, ok := fieldSeen[race.FieldAlignment]; !ok {
				selectedFields = append(selectedFields, race.FieldAlignment)
				fieldSeen[race.FieldAlignment] = struct{}{}
			}
		case "age":
			if _, ok := fieldSeen[race.FieldAge]; !ok {
				selectedFields = append(selectedFields, race.FieldAge)
				fieldSeen[race.FieldAge] = struct{}{}
			}
		case "size":
			if _, ok := fieldSeen[race.FieldSize]; !ok {
				selectedFields = append(selectedFields, race.FieldSize)
				fieldSeen[race.FieldSize] = struct{}{}
			}
		case "sizeDescription":
			if _, ok := fieldSeen[race.FieldSizeDescription]; !ok {
				selectedFields = append(selectedFields, race.FieldSizeDescription)
				fieldSeen[race.FieldSizeDescription] = struct{}{}
			}
		case "languageDesc":
			if _, ok := fieldSeen[race.FieldLanguageDesc]; !ok {
				selectedFields = append(selectedFields, race.FieldLanguageDesc)
				fieldSeen[race.FieldLanguageDesc] = struct{}{}
			}
		case "speed":
			if _, ok := fieldSeen[race.FieldSpeed]; !ok {
				selectedFields = append(selectedFields, race.FieldSpeed)
				fieldSeen[race.FieldSpeed] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		r.Select(selectedFields...)
	}
	return nil
}

type racePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []RacePaginateOption
}

func newRacePaginateArgs(rv map[string]any) *racePaginateArgs {
	args := &racePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &RaceOrder{Field: &RaceOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithRaceOrder(order))
			}
		case *RaceOrder:
			if v != nil {
				args.opts = append(args.opts, WithRaceOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*RaceWhereInput); ok {
		args.opts = append(args.opts, WithRaceFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (r *RuleQuery) CollectFields(ctx context.Context, satisfies ...string) (*RuleQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return r, nil
	}
	if err := r.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return r, nil
}

func (r *RuleQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(rule.Columns))
		selectedFields = []string{rule.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "ruleSections":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&RuleSectionClient{config: r.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			r.WithNamedRuleSections(alias, func(wq *RuleSectionQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[rule.FieldIndx]; !ok {
				selectedFields = append(selectedFields, rule.FieldIndx)
				fieldSeen[rule.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[rule.FieldName]; !ok {
				selectedFields = append(selectedFields, rule.FieldName)
				fieldSeen[rule.FieldName] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[rule.FieldDesc]; !ok {
				selectedFields = append(selectedFields, rule.FieldDesc)
				fieldSeen[rule.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		r.Select(selectedFields...)
	}
	return nil
}

type rulePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []RulePaginateOption
}

func newRulePaginateArgs(rv map[string]any) *rulePaginateArgs {
	args := &rulePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &RuleOrder{Field: &RuleOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithRuleOrder(order))
			}
		case *RuleOrder:
			if v != nil {
				args.opts = append(args.opts, WithRuleOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*RuleWhereInput); ok {
		args.opts = append(args.opts, WithRuleFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (rs *RuleSectionQuery) CollectFields(ctx context.Context, satisfies ...string) (*RuleSectionQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return rs, nil
	}
	if err := rs.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return rs, nil
}

func (rs *RuleSectionQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(rulesection.Columns))
		selectedFields = []string{rulesection.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "rules":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&RuleClient{config: rs.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			rs.WithNamedRules(alias, func(wq *RuleQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[rulesection.FieldIndx]; !ok {
				selectedFields = append(selectedFields, rulesection.FieldIndx)
				fieldSeen[rulesection.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[rulesection.FieldName]; !ok {
				selectedFields = append(selectedFields, rulesection.FieldName)
				fieldSeen[rulesection.FieldName] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[rulesection.FieldDesc]; !ok {
				selectedFields = append(selectedFields, rulesection.FieldDesc)
				fieldSeen[rulesection.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		rs.Select(selectedFields...)
	}
	return nil
}

type rulesectionPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []RuleSectionPaginateOption
}

func newRuleSectionPaginateArgs(rv map[string]any) *rulesectionPaginateArgs {
	args := &rulesectionPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &RuleSectionOrder{Field: &RuleSectionOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithRuleSectionOrder(order))
			}
		case *RuleSectionOrder:
			if v != nil {
				args.opts = append(args.opts, WithRuleSectionOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*RuleSectionWhereInput); ok {
		args.opts = append(args.opts, WithRuleSectionFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (s *SkillQuery) CollectFields(ctx context.Context, satisfies ...string) (*SkillQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return s, nil
	}
	if err := s.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return s, nil
}

func (s *SkillQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(skill.Columns))
		selectedFields = []string{skill.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "abilityScore":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AbilityScoreClient{config: s.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			s.withAbilityScore = query
		case "indx":
			if _, ok := fieldSeen[skill.FieldIndx]; !ok {
				selectedFields = append(selectedFields, skill.FieldIndx)
				fieldSeen[skill.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[skill.FieldName]; !ok {
				selectedFields = append(selectedFields, skill.FieldName)
				fieldSeen[skill.FieldName] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[skill.FieldDesc]; !ok {
				selectedFields = append(selectedFields, skill.FieldDesc)
				fieldSeen[skill.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		s.Select(selectedFields...)
	}
	return nil
}

type skillPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []SkillPaginateOption
}

func newSkillPaginateArgs(rv map[string]any) *skillPaginateArgs {
	args := &skillPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &SkillOrder{Field: &SkillOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithSkillOrder(order))
			}
		case *SkillOrder:
			if v != nil {
				args.opts = append(args.opts, WithSkillOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*SkillWhereInput); ok {
		args.opts = append(args.opts, WithSkillFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (s *SubraceQuery) CollectFields(ctx context.Context, satisfies ...string) (*SubraceQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return s, nil
	}
	if err := s.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return s, nil
}

func (s *SubraceQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(subrace.Columns))
		selectedFields = []string{subrace.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "race":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&RaceClient{config: s.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			s.withRace = query
		case "proficiencies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&ProficiencyClient{config: s.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			s.WithNamedProficiencies(alias, func(wq *ProficiencyQuery) {
				*wq = *query
			})
		case "traits":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&TraitClient{config: s.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			s.WithNamedTraits(alias, func(wq *TraitQuery) {
				*wq = *query
			})
		case "abilityBonuses":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AbilityBonusClient{config: s.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			s.WithNamedAbilityBonuses(alias, func(wq *AbilityBonusQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[subrace.FieldIndx]; !ok {
				selectedFields = append(selectedFields, subrace.FieldIndx)
				fieldSeen[subrace.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[subrace.FieldName]; !ok {
				selectedFields = append(selectedFields, subrace.FieldName)
				fieldSeen[subrace.FieldName] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[subrace.FieldDesc]; !ok {
				selectedFields = append(selectedFields, subrace.FieldDesc)
				fieldSeen[subrace.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		s.Select(selectedFields...)
	}
	return nil
}

type subracePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []SubracePaginateOption
}

func newSubracePaginateArgs(rv map[string]any) *subracePaginateArgs {
	args := &subracePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &SubraceOrder{Field: &SubraceOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithSubraceOrder(order))
			}
		case *SubraceOrder:
			if v != nil {
				args.opts = append(args.opts, WithSubraceOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*SubraceWhereInput); ok {
		args.opts = append(args.opts, WithSubraceFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (t *ToolQuery) CollectFields(ctx context.Context, satisfies ...string) (*ToolQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return t, nil
	}
	if err := t.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return t, nil
}

func (t *ToolQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(tool.Columns))
		selectedFields = []string{tool.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "equipment":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentClient{config: t.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			t.withEquipment = query
			if _, ok := fieldSeen[tool.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, tool.FieldEquipmentID)
				fieldSeen[tool.FieldEquipmentID] = struct{}{}
			}
		case "indx":
			if _, ok := fieldSeen[tool.FieldIndx]; !ok {
				selectedFields = append(selectedFields, tool.FieldIndx)
				fieldSeen[tool.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[tool.FieldName]; !ok {
				selectedFields = append(selectedFields, tool.FieldName)
				fieldSeen[tool.FieldName] = struct{}{}
			}
		case "toolCategory":
			if _, ok := fieldSeen[tool.FieldToolCategory]; !ok {
				selectedFields = append(selectedFields, tool.FieldToolCategory)
				fieldSeen[tool.FieldToolCategory] = struct{}{}
			}
		case "equipmentID":
			if _, ok := fieldSeen[tool.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, tool.FieldEquipmentID)
				fieldSeen[tool.FieldEquipmentID] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		t.Select(selectedFields...)
	}
	return nil
}

type toolPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []ToolPaginateOption
}

func newToolPaginateArgs(rv map[string]any) *toolPaginateArgs {
	args := &toolPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &ToolOrder{Field: &ToolOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithToolOrder(order))
			}
		case *ToolOrder:
			if v != nil {
				args.opts = append(args.opts, WithToolOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*ToolWhereInput); ok {
		args.opts = append(args.opts, WithToolFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (t *TraitQuery) CollectFields(ctx context.Context, satisfies ...string) (*TraitQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return t, nil
	}
	if err := t.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return t, nil
}

func (t *TraitQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(trait.Columns))
		selectedFields = []string{trait.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "races":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&RaceClient{config: t.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			t.WithNamedRaces(alias, func(wq *RaceQuery) {
				*wq = *query
			})
		case "subraces":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&SubraceClient{config: t.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			t.WithNamedSubraces(alias, func(wq *SubraceQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[trait.FieldIndx]; !ok {
				selectedFields = append(selectedFields, trait.FieldIndx)
				fieldSeen[trait.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[trait.FieldName]; !ok {
				selectedFields = append(selectedFields, trait.FieldName)
				fieldSeen[trait.FieldName] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[trait.FieldDesc]; !ok {
				selectedFields = append(selectedFields, trait.FieldDesc)
				fieldSeen[trait.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		t.Select(selectedFields...)
	}
	return nil
}

type traitPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []TraitPaginateOption
}

func newTraitPaginateArgs(rv map[string]any) *traitPaginateArgs {
	args := &traitPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &TraitOrder{Field: &TraitOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithTraitOrder(order))
			}
		case *TraitOrder:
			if v != nil {
				args.opts = append(args.opts, WithTraitOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*TraitWhereInput); ok {
		args.opts = append(args.opts, WithTraitFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (v *VehicleQuery) CollectFields(ctx context.Context, satisfies ...string) (*VehicleQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return v, nil
	}
	if err := v.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return v, nil
}

func (v *VehicleQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(vehicle.Columns))
		selectedFields = []string{vehicle.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "equipment":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentClient{config: v.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			v.withEquipment = query
			if _, ok := fieldSeen[vehicle.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, vehicle.FieldEquipmentID)
				fieldSeen[vehicle.FieldEquipmentID] = struct{}{}
			}
		case "indx":
			if _, ok := fieldSeen[vehicle.FieldIndx]; !ok {
				selectedFields = append(selectedFields, vehicle.FieldIndx)
				fieldSeen[vehicle.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[vehicle.FieldName]; !ok {
				selectedFields = append(selectedFields, vehicle.FieldName)
				fieldSeen[vehicle.FieldName] = struct{}{}
			}
		case "vehicleCategory":
			if _, ok := fieldSeen[vehicle.FieldVehicleCategory]; !ok {
				selectedFields = append(selectedFields, vehicle.FieldVehicleCategory)
				fieldSeen[vehicle.FieldVehicleCategory] = struct{}{}
			}
		case "capacity":
			if _, ok := fieldSeen[vehicle.FieldCapacity]; !ok {
				selectedFields = append(selectedFields, vehicle.FieldCapacity)
				fieldSeen[vehicle.FieldCapacity] = struct{}{}
			}
		case "equipmentID":
			if _, ok := fieldSeen[vehicle.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, vehicle.FieldEquipmentID)
				fieldSeen[vehicle.FieldEquipmentID] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		v.Select(selectedFields...)
	}
	return nil
}

type vehiclePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []VehiclePaginateOption
}

func newVehiclePaginateArgs(rv map[string]any) *vehiclePaginateArgs {
	args := &vehiclePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &VehicleOrder{Field: &VehicleOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithVehicleOrder(order))
			}
		case *VehicleOrder:
			if v != nil {
				args.opts = append(args.opts, WithVehicleOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*VehicleWhereInput); ok {
		args.opts = append(args.opts, WithVehicleFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (w *WeaponQuery) CollectFields(ctx context.Context, satisfies ...string) (*WeaponQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return w, nil
	}
	if err := w.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return w, nil
}

func (w *WeaponQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(weapon.Columns))
		selectedFields = []string{weapon.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "equipment":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&EquipmentClient{config: w.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			w.withEquipment = query
			if _, ok := fieldSeen[weapon.FieldEquipmentID]; !ok {
				selectedFields = append(selectedFields, weapon.FieldEquipmentID)
				fieldSeen[weapon.FieldEquipmentID] = struct{}{}
			}
		case "weaponDamage":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&WeaponDamageClient{config: w.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			w.WithNamedWeaponDamage(alias, func(wq *WeaponDamageQuery) {
				*wq = *query
			})
		case "weaponProperties":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&WeaponPropertyClient{config: w.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			w.WithNamedWeaponProperties(alias, func(wq *WeaponPropertyQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[weapon.FieldIndx]; !ok {
				selectedFields = append(selectedFields, weapon.FieldIndx)
				fieldSeen[weapon.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[weapon.FieldName]; !ok {
				selectedFields = append(selectedFields, weapon.FieldName)
				fieldSeen[weapon.FieldName] = struct{}{}
			}
		case "weaponCategory":
			if _, ok := fieldSeen[weapon.FieldWeaponCategory]; !ok {
				selectedFields = append(selectedFields, weapon.FieldWeaponCategory)
				fieldSeen[weapon.FieldWeaponCategory] = struct{}{}
			}
		case "weaponRange":
			if _, ok := fieldSeen[weapon.FieldWeaponRange]; !ok {
				selectedFields = append(selectedFields, weapon.FieldWeaponRange)
				fieldSeen[weapon.FieldWeaponRange] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		w.Select(selectedFields...)
	}
	return nil
}

type weaponPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []WeaponPaginateOption
}

func newWeaponPaginateArgs(rv map[string]any) *weaponPaginateArgs {
	args := &weaponPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &WeaponOrder{Field: &WeaponOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithWeaponOrder(order))
			}
		case *WeaponOrder:
			if v != nil {
				args.opts = append(args.opts, WithWeaponOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*WeaponWhereInput); ok {
		args.opts = append(args.opts, WithWeaponFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (wd *WeaponDamageQuery) CollectFields(ctx context.Context, satisfies ...string) (*WeaponDamageQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return wd, nil
	}
	if err := wd.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return wd, nil
}

func (wd *WeaponDamageQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(weapondamage.Columns))
		selectedFields = []string{weapondamage.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "weapon":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&WeaponClient{config: wd.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			wd.withWeapon = query
			if _, ok := fieldSeen[weapondamage.FieldWeaponID]; !ok {
				selectedFields = append(selectedFields, weapondamage.FieldWeaponID)
				fieldSeen[weapondamage.FieldWeaponID] = struct{}{}
			}
		case "damageType":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&DamageTypeClient{config: wd.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			wd.withDamageType = query
			if _, ok := fieldSeen[weapondamage.FieldDamageTypeID]; !ok {
				selectedFields = append(selectedFields, weapondamage.FieldDamageTypeID)
				fieldSeen[weapondamage.FieldDamageTypeID] = struct{}{}
			}
		case "weaponID":
			if _, ok := fieldSeen[weapondamage.FieldWeaponID]; !ok {
				selectedFields = append(selectedFields, weapondamage.FieldWeaponID)
				fieldSeen[weapondamage.FieldWeaponID] = struct{}{}
			}
		case "damageTypeID":
			if _, ok := fieldSeen[weapondamage.FieldDamageTypeID]; !ok {
				selectedFields = append(selectedFields, weapondamage.FieldDamageTypeID)
				fieldSeen[weapondamage.FieldDamageTypeID] = struct{}{}
			}
		case "dice":
			if _, ok := fieldSeen[weapondamage.FieldDice]; !ok {
				selectedFields = append(selectedFields, weapondamage.FieldDice)
				fieldSeen[weapondamage.FieldDice] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		wd.Select(selectedFields...)
	}
	return nil
}

type weapondamagePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []WeaponDamagePaginateOption
}

func newWeaponDamagePaginateArgs(rv map[string]any) *weapondamagePaginateArgs {
	args := &weapondamagePaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[whereField].(*WeaponDamageWhereInput); ok {
		args.opts = append(args.opts, WithWeaponDamageFilter(v.Filter))
	}
	return args
}

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (wp *WeaponPropertyQuery) CollectFields(ctx context.Context, satisfies ...string) (*WeaponPropertyQuery, error) {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return wp, nil
	}
	if err := wp.collectField(ctx, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil {
		return nil, err
	}
	return wp, nil
}

func (wp *WeaponPropertyQuery) collectField(ctx context.Context, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error {
	path = append([]string(nil), path...)
	var (
		unknownSeen    bool
		fieldSeen      = make(map[string]struct{}, len(weaponproperty.Columns))
		selectedFields = []string{weaponproperty.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "weapons":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&WeaponClient{config: wp.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, satisfies...); err != nil {
				return err
			}
			wp.WithNamedWeapons(alias, func(wq *WeaponQuery) {
				*wq = *query
			})
		case "indx":
			if _, ok := fieldSeen[weaponproperty.FieldIndx]; !ok {
				selectedFields = append(selectedFields, weaponproperty.FieldIndx)
				fieldSeen[weaponproperty.FieldIndx] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[weaponproperty.FieldName]; !ok {
				selectedFields = append(selectedFields, weaponproperty.FieldName)
				fieldSeen[weaponproperty.FieldName] = struct{}{}
			}
		case "desc":
			if _, ok := fieldSeen[weaponproperty.FieldDesc]; !ok {
				selectedFields = append(selectedFields, weaponproperty.FieldDesc)
				fieldSeen[weaponproperty.FieldDesc] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		wp.Select(selectedFields...)
	}
	return nil
}

type weaponpropertyPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []WeaponPropertyPaginateOption
}

func newWeaponPropertyPaginateArgs(rv map[string]any) *weaponpropertyPaginateArgs {
	args := &weaponpropertyPaginateArgs{}
	if rv == nil {
		return args
	}
	if v := rv[firstField]; v != nil {
		args.first = v.(*int)
	}
	if v := rv[lastField]; v != nil {
		args.last = v.(*int)
	}
	if v := rv[afterField]; v != nil {
		args.after = v.(*Cursor)
	}
	if v := rv[beforeField]; v != nil {
		args.before = v.(*Cursor)
	}
	if v, ok := rv[orderByField]; ok {
		switch v := v.(type) {
		case map[string]any:
			var (
				err1, err2 error
				order      = &WeaponPropertyOrder{Field: &WeaponPropertyOrderField{}, Direction: entgql.OrderDirectionAsc}
			)
			if d, ok := v[directionField]; ok {
				err1 = order.Direction.UnmarshalGQL(d)
			}
			if f, ok := v[fieldField]; ok {
				err2 = order.Field.UnmarshalGQL(f)
			}
			if err1 == nil && err2 == nil {
				args.opts = append(args.opts, WithWeaponPropertyOrder(order))
			}
		case *WeaponPropertyOrder:
			if v != nil {
				args.opts = append(args.opts, WithWeaponPropertyOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*WeaponPropertyWhereInput); ok {
		args.opts = append(args.opts, WithWeaponPropertyFilter(v.Filter))
	}
	return args
}

const (
	afterField     = "after"
	firstField     = "first"
	beforeField    = "before"
	lastField      = "last"
	orderByField   = "orderBy"
	directionField = "direction"
	fieldField     = "field"
	whereField     = "where"
)

func fieldArgs(ctx context.Context, whereInput any, path ...string) map[string]any {
	field := collectedField(ctx, path...)
	if field == nil || field.Arguments == nil {
		return nil
	}
	oc := graphql.GetOperationContext(ctx)
	args := field.ArgumentMap(oc.Variables)
	return unmarshalArgs(ctx, whereInput, args)
}

// unmarshalArgs allows extracting the field arguments from their raw representation.
func unmarshalArgs(ctx context.Context, whereInput any, args map[string]any) map[string]any {
	for _, k := range []string{firstField, lastField} {
		v, ok := args[k]
		if !ok {
			continue
		}
		i, err := graphql.UnmarshalInt(v)
		if err == nil {
			args[k] = &i
		}
	}
	for _, k := range []string{beforeField, afterField} {
		v, ok := args[k]
		if !ok {
			continue
		}
		c := &Cursor{}
		if c.UnmarshalGQL(v) == nil {
			args[k] = c
		}
	}
	if v, ok := args[whereField]; ok && whereInput != nil {
		if err := graphql.UnmarshalInputFromContext(ctx, v, whereInput); err == nil {
			args[whereField] = whereInput
		}
	}

	return args
}

func limitRows(partitionBy string, limit int, orderBy ...sql.Querier) func(s *sql.Selector) {
	return func(s *sql.Selector) {
		d := sql.Dialect(s.Dialect())
		s.SetDistinct(false)
		with := d.With("src_query").
			As(s.Clone()).
			With("limited_query").
			As(
				d.Select("*").
					AppendSelectExprAs(
						sql.RowNumber().PartitionBy(partitionBy).OrderExpr(orderBy...),
						"row_number",
					).
					From(d.Table("src_query")),
			)
		t := d.Table("limited_query").As(s.TableName())
		*s = *d.Select(s.UnqualifiedColumns()...).
			From(t).
			Where(sql.LTE(t.C("row_number"), limit)).
			Prefix(with)
	}
}

// mayAddCondition appends another type condition to the satisfies list
// if condition is enabled (Node/Nodes) and it does not exist in the list.
func mayAddCondition(satisfies []string, typeCond string) []string {
	if len(satisfies) == 0 {
		return satisfies
	}
	for _, s := range satisfies {
		if typeCond == s {
			return satisfies
		}
	}
	return append(satisfies, typeCond)
}