gql_collection.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"database/sql/driver"
	"fmt"

	"entgo.io/contrib/entgql"
	"entgo.io/ent/dialect/sql"
	"github.com/99designs/gqlgen/graphql"
	"github.com/woocoos/knockout-go/pkg/pagination"
	"github.com/woocoos/knockout/ent/app"
	"github.com/woocoos/knockout/ent/appaction"
	"github.com/woocoos/knockout/ent/appdict"
	"github.com/woocoos/knockout/ent/appdictitem"
	"github.com/woocoos/knockout/ent/appmenu"
	"github.com/woocoos/knockout/ent/apppolicy"
	"github.com/woocoos/knockout/ent/appres"
	"github.com/woocoos/knockout/ent/approle"
	"github.com/woocoos/knockout/ent/file"
	"github.com/woocoos/knockout/ent/filesource"
	"github.com/woocoos/knockout/ent/oauthclient"
	"github.com/woocoos/knockout/ent/org"
	"github.com/woocoos/knockout/ent/orgpolicy"
	"github.com/woocoos/knockout/ent/orgrole"
	"github.com/woocoos/knockout/ent/orguserpreference"
	"github.com/woocoos/knockout/ent/permission"
	"github.com/woocoos/knockout/ent/user"
	"github.com/woocoos/knockout/ent/userdevice"
	"github.com/woocoos/knockout/ent/useridentity"
	"github.com/woocoos/knockout/ent/userloginprofile"
	"github.com/woocoos/knockout/ent/userpassword"
)

// CollectFields tells the query-builder to eagerly load connected nodes by resolver context.
func (a *AppQuery) CollectFields(ctx context.Context, satisfies ...string) (*AppQuery, 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 *AppQuery) 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(app.Columns))
		selectedFields = []string{app.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "menus":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppMenuClient{config: a.config}).Query()
			)
			args := newAppMenuPaginateArgs(fieldArgs(ctx, new(AppMenuWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newAppMenuPager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					a.loadTotal = append(a.loadTotal, func(ctx context.Context, nodes []*App) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"app_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(s.C(app.MenusColumn), ids...))
						})
						if err := query.GroupBy(app.MenusColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				} else {
					a.loadTotal = append(a.loadTotal, func(_ context.Context, nodes []*App) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Menus)
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, appmenuImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, app.MenusColumn, limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			a.WithNamedMenus(alias, func(wq *AppMenuQuery) {
				*wq = *query
			})
		case "actions":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppActionClient{config: a.config}).Query()
			)
			args := newAppActionPaginateArgs(fieldArgs(ctx, new(AppActionWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newAppActionPager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					a.loadTotal = append(a.loadTotal, func(ctx context.Context, nodes []*App) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"app_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(s.C(app.ActionsColumn), ids...))
						})
						if err := query.GroupBy(app.ActionsColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				} else {
					a.loadTotal = append(a.loadTotal, func(_ context.Context, nodes []*App) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Actions)
							if nodes[i].Edges.totalCount[1] == nil {
								nodes[i].Edges.totalCount[1] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[1][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, appactionImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, app.ActionsColumn, limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			a.WithNamedActions(alias, func(wq *AppActionQuery) {
				*wq = *query
			})
		case "resources":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppResClient{config: a.config}).Query()
			)
			args := newAppResPaginateArgs(fieldArgs(ctx, new(AppResWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newAppResPager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					a.loadTotal = append(a.loadTotal, func(ctx context.Context, nodes []*App) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"app_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(s.C(app.ResourcesColumn), ids...))
						})
						if err := query.GroupBy(app.ResourcesColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[2] == nil {
								nodes[i].Edges.totalCount[2] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[2][alias] = n
						}
						return nil
					})
				} else {
					a.loadTotal = append(a.loadTotal, func(_ context.Context, nodes []*App) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Resources)
							if nodes[i].Edges.totalCount[2] == nil {
								nodes[i].Edges.totalCount[2] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[2][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, appresImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, app.ResourcesColumn, limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			a.WithNamedResources(alias, func(wq *AppResQuery) {
				*wq = *query
			})
		case "roles":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppRoleClient{config: a.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, approleImplementors)...); err != nil {
				return err
			}
			a.WithNamedRoles(alias, func(wq *AppRoleQuery) {
				*wq = *query
			})
		case "policies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppPolicyClient{config: a.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, apppolicyImplementors)...); err != nil {
				return err
			}
			a.WithNamedPolicies(alias, func(wq *AppPolicyQuery) {
				*wq = *query
			})
		case "orgs":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OrgClient{config: a.config}).Query()
			)
			args := newOrgPaginateArgs(fieldArgs(ctx, new(OrgWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newOrgPager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					a.loadTotal = append(a.loadTotal, func(ctx context.Context, nodes []*App) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"app_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(app.OrgsTable)
							s.Join(joinT).On(s.C(org.FieldID), joinT.C(app.OrgsPrimaryKey[0]))
							s.Where(sql.InValues(joinT.C(app.OrgsPrimaryKey[1]), ids...))
							s.Select(joinT.C(app.OrgsPrimaryKey[1]), sql.Count("*"))
							s.GroupBy(joinT.C(app.OrgsPrimaryKey[1]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[5] == nil {
								nodes[i].Edges.totalCount[5] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[5][alias] = n
						}
						return nil
					})
				} else {
					a.loadTotal = append(a.loadTotal, func(_ context.Context, nodes []*App) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Orgs)
							if nodes[i].Edges.totalCount[5] == nil {
								nodes[i].Edges.totalCount[5] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[5][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, orgImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, app.OrgsPrimaryKey[1], limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			a.WithNamedOrgs(alias, func(wq *OrgQuery) {
				*wq = *query
			})
		case "dicts":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppDictClient{config: a.config}).Query()
			)
			args := newAppDictPaginateArgs(fieldArgs(ctx, new(AppDictWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newAppDictPager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					a.loadTotal = append(a.loadTotal, func(ctx context.Context, nodes []*App) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"app_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(s.C(app.DictsColumn), ids...))
						})
						if err := query.GroupBy(app.DictsColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[6] == nil {
								nodes[i].Edges.totalCount[6] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[6][alias] = n
						}
						return nil
					})
				} else {
					a.loadTotal = append(a.loadTotal, func(_ context.Context, nodes []*App) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Dicts)
							if nodes[i].Edges.totalCount[6] == nil {
								nodes[i].Edges.totalCount[6] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[6][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, appdictImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, app.DictsColumn, limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			a.WithNamedDicts(alias, func(wq *AppDictQuery) {
				*wq = *query
			})
		case "createdBy":
			if _, ok := fieldSeen[app.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, app.FieldCreatedBy)
				fieldSeen[app.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[app.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, app.FieldCreatedAt)
				fieldSeen[app.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[app.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, app.FieldUpdatedBy)
				fieldSeen[app.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[app.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, app.FieldUpdatedAt)
				fieldSeen[app.FieldUpdatedAt] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[app.FieldName]; !ok {
				selectedFields = append(selectedFields, app.FieldName)
				fieldSeen[app.FieldName] = struct{}{}
			}
		case "code":
			if _, ok := fieldSeen[app.FieldCode]; !ok {
				selectedFields = append(selectedFields, app.FieldCode)
				fieldSeen[app.FieldCode] = struct{}{}
			}
		case "kind":
			if _, ok := fieldSeen[app.FieldKind]; !ok {
				selectedFields = append(selectedFields, app.FieldKind)
				fieldSeen[app.FieldKind] = struct{}{}
			}
		case "redirectURI":
			if _, ok := fieldSeen[app.FieldRedirectURI]; !ok {
				selectedFields = append(selectedFields, app.FieldRedirectURI)
				fieldSeen[app.FieldRedirectURI] = struct{}{}
			}
		case "appKey":
			if _, ok := fieldSeen[app.FieldAppKey]; !ok {
				selectedFields = append(selectedFields, app.FieldAppKey)
				fieldSeen[app.FieldAppKey] = struct{}{}
			}
		case "appSecret":
			if _, ok := fieldSeen[app.FieldAppSecret]; !ok {
				selectedFields = append(selectedFields, app.FieldAppSecret)
				fieldSeen[app.FieldAppSecret] = struct{}{}
			}
		case "scopes":
			if _, ok := fieldSeen[app.FieldScopes]; !ok {
				selectedFields = append(selectedFields, app.FieldScopes)
				fieldSeen[app.FieldScopes] = struct{}{}
			}
		case "tokenValidity":
			if _, ok := fieldSeen[app.FieldTokenValidity]; !ok {
				selectedFields = append(selectedFields, app.FieldTokenValidity)
				fieldSeen[app.FieldTokenValidity] = struct{}{}
			}
		case "refreshTokenValidity":
			if _, ok := fieldSeen[app.FieldRefreshTokenValidity]; !ok {
				selectedFields = append(selectedFields, app.FieldRefreshTokenValidity)
				fieldSeen[app.FieldRefreshTokenValidity] = struct{}{}
			}
		case "logoFileID":
			if _, ok := fieldSeen[app.FieldLogoFileID]; !ok {
				selectedFields = append(selectedFields, app.FieldLogoFileID)
				fieldSeen[app.FieldLogoFileID] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[app.FieldComments]; !ok {
				selectedFields = append(selectedFields, app.FieldComments)
				fieldSeen[app.FieldComments] = struct{}{}
			}
		case "status":
			if _, ok := fieldSeen[app.FieldStatus]; !ok {
				selectedFields = append(selectedFields, app.FieldStatus)
				fieldSeen[app.FieldStatus] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		a.Select(selectedFields...)
	}
	return nil
}

type appPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AppPaginateOption
}

func newAppPaginateArgs(rv map[string]any) *appPaginateArgs {
	args := &appPaginateArgs{}
	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      = &AppOrder{Field: &AppOrderField{}, 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, WithAppOrder(order))
			}
		case *AppOrder:
			if v != nil {
				args.opts = append(args.opts, WithAppOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AppWhereInput); ok {
		args.opts = append(args.opts, WithAppFilter(v.Filter))
	}
	return args
}

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

func (aa *AppActionQuery) 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(appaction.Columns))
		selectedFields = []string{appaction.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "app":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppClient{config: aa.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, appImplementors)...); err != nil {
				return err
			}
			aa.withApp = query
			if _, ok := fieldSeen[appaction.FieldAppID]; !ok {
				selectedFields = append(selectedFields, appaction.FieldAppID)
				fieldSeen[appaction.FieldAppID] = struct{}{}
			}
		case "menus":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppMenuClient{config: aa.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, appmenuImplementors)...); err != nil {
				return err
			}
			aa.WithNamedMenus(alias, func(wq *AppMenuQuery) {
				*wq = *query
			})
		case "createdBy":
			if _, ok := fieldSeen[appaction.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, appaction.FieldCreatedBy)
				fieldSeen[appaction.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[appaction.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, appaction.FieldCreatedAt)
				fieldSeen[appaction.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[appaction.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, appaction.FieldUpdatedBy)
				fieldSeen[appaction.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[appaction.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, appaction.FieldUpdatedAt)
				fieldSeen[appaction.FieldUpdatedAt] = struct{}{}
			}
		case "appID":
			if _, ok := fieldSeen[appaction.FieldAppID]; !ok {
				selectedFields = append(selectedFields, appaction.FieldAppID)
				fieldSeen[appaction.FieldAppID] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[appaction.FieldName]; !ok {
				selectedFields = append(selectedFields, appaction.FieldName)
				fieldSeen[appaction.FieldName] = struct{}{}
			}
		case "kind":
			if _, ok := fieldSeen[appaction.FieldKind]; !ok {
				selectedFields = append(selectedFields, appaction.FieldKind)
				fieldSeen[appaction.FieldKind] = struct{}{}
			}
		case "method":
			if _, ok := fieldSeen[appaction.FieldMethod]; !ok {
				selectedFields = append(selectedFields, appaction.FieldMethod)
				fieldSeen[appaction.FieldMethod] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[appaction.FieldComments]; !ok {
				selectedFields = append(selectedFields, appaction.FieldComments)
				fieldSeen[appaction.FieldComments] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		aa.Select(selectedFields...)
	}
	return nil
}

type appactionPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AppActionPaginateOption
}

func newAppActionPaginateArgs(rv map[string]any) *appactionPaginateArgs {
	args := &appactionPaginateArgs{}
	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      = &AppActionOrder{Field: &AppActionOrderField{}, 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, WithAppActionOrder(order))
			}
		case *AppActionOrder:
			if v != nil {
				args.opts = append(args.opts, WithAppActionOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AppActionWhereInput); ok {
		args.opts = append(args.opts, WithAppActionFilter(v.Filter))
	}
	return args
}

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

func (ad *AppDictQuery) 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(appdict.Columns))
		selectedFields = []string{appdict.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "app":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppClient{config: ad.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, appImplementors)...); err != nil {
				return err
			}
			ad.withApp = query
			if _, ok := fieldSeen[appdict.FieldAppID]; !ok {
				selectedFields = append(selectedFields, appdict.FieldAppID)
				fieldSeen[appdict.FieldAppID] = struct{}{}
			}
		case "items":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppDictItemClient{config: ad.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, appdictitemImplementors)...); err != nil {
				return err
			}
			ad.WithNamedItems(alias, func(wq *AppDictItemQuery) {
				*wq = *query
			})
		case "createdBy":
			if _, ok := fieldSeen[appdict.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, appdict.FieldCreatedBy)
				fieldSeen[appdict.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[appdict.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, appdict.FieldCreatedAt)
				fieldSeen[appdict.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[appdict.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, appdict.FieldUpdatedBy)
				fieldSeen[appdict.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[appdict.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, appdict.FieldUpdatedAt)
				fieldSeen[appdict.FieldUpdatedAt] = struct{}{}
			}
		case "appID":
			if _, ok := fieldSeen[appdict.FieldAppID]; !ok {
				selectedFields = append(selectedFields, appdict.FieldAppID)
				fieldSeen[appdict.FieldAppID] = struct{}{}
			}
		case "code":
			if _, ok := fieldSeen[appdict.FieldCode]; !ok {
				selectedFields = append(selectedFields, appdict.FieldCode)
				fieldSeen[appdict.FieldCode] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[appdict.FieldName]; !ok {
				selectedFields = append(selectedFields, appdict.FieldName)
				fieldSeen[appdict.FieldName] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[appdict.FieldComments]; !ok {
				selectedFields = append(selectedFields, appdict.FieldComments)
				fieldSeen[appdict.FieldComments] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ad.Select(selectedFields...)
	}
	return nil
}

type appdictPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AppDictPaginateOption
}

func newAppDictPaginateArgs(rv map[string]any) *appdictPaginateArgs {
	args := &appdictPaginateArgs{}
	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      = &AppDictOrder{Field: &AppDictOrderField{}, 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, WithAppDictOrder(order))
			}
		case *AppDictOrder:
			if v != nil {
				args.opts = append(args.opts, WithAppDictOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AppDictWhereInput); ok {
		args.opts = append(args.opts, WithAppDictFilter(v.Filter))
	}
	return args
}

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

func (adi *AppDictItemQuery) 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(appdictitem.Columns))
		selectedFields = []string{appdictitem.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "dict":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppDictClient{config: adi.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, appdictImplementors)...); err != nil {
				return err
			}
			adi.withDict = query
			if _, ok := fieldSeen[appdictitem.FieldDictID]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldDictID)
				fieldSeen[appdictitem.FieldDictID] = struct{}{}
			}
		case "org":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OrgClient{config: adi.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, orgImplementors)...); err != nil {
				return err
			}
			adi.withOrg = query
			if _, ok := fieldSeen[appdictitem.FieldOrgID]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldOrgID)
				fieldSeen[appdictitem.FieldOrgID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[appdictitem.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldCreatedBy)
				fieldSeen[appdictitem.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[appdictitem.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldCreatedAt)
				fieldSeen[appdictitem.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[appdictitem.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldUpdatedBy)
				fieldSeen[appdictitem.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[appdictitem.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldUpdatedAt)
				fieldSeen[appdictitem.FieldUpdatedAt] = struct{}{}
			}
		case "orgID":
			if _, ok := fieldSeen[appdictitem.FieldOrgID]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldOrgID)
				fieldSeen[appdictitem.FieldOrgID] = struct{}{}
			}
		case "dictID":
			if _, ok := fieldSeen[appdictitem.FieldDictID]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldDictID)
				fieldSeen[appdictitem.FieldDictID] = struct{}{}
			}
		case "refCode":
			if _, ok := fieldSeen[appdictitem.FieldRefCode]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldRefCode)
				fieldSeen[appdictitem.FieldRefCode] = struct{}{}
			}
		case "code":
			if _, ok := fieldSeen[appdictitem.FieldCode]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldCode)
				fieldSeen[appdictitem.FieldCode] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[appdictitem.FieldName]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldName)
				fieldSeen[appdictitem.FieldName] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[appdictitem.FieldComments]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldComments)
				fieldSeen[appdictitem.FieldComments] = struct{}{}
			}
		case "displaySort":
			if _, ok := fieldSeen[appdictitem.FieldDisplaySort]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldDisplaySort)
				fieldSeen[appdictitem.FieldDisplaySort] = struct{}{}
			}
		case "status":
			if _, ok := fieldSeen[appdictitem.FieldStatus]; !ok {
				selectedFields = append(selectedFields, appdictitem.FieldStatus)
				fieldSeen[appdictitem.FieldStatus] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		adi.Select(selectedFields...)
	}
	return nil
}

type appdictitemPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AppDictItemPaginateOption
}

func newAppDictItemPaginateArgs(rv map[string]any) *appdictitemPaginateArgs {
	args := &appdictitemPaginateArgs{}
	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      = &AppDictItemOrder{Field: &AppDictItemOrderField{}, 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, WithAppDictItemOrder(order))
			}
		case *AppDictItemOrder:
			if v != nil {
				args.opts = append(args.opts, WithAppDictItemOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AppDictItemWhereInput); ok {
		args.opts = append(args.opts, WithAppDictItemFilter(v.Filter))
	}
	return args
}

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

func (am *AppMenuQuery) 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(appmenu.Columns))
		selectedFields = []string{appmenu.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "app":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppClient{config: am.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, appImplementors)...); err != nil {
				return err
			}
			am.withApp = query
			if _, ok := fieldSeen[appmenu.FieldAppID]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldAppID)
				fieldSeen[appmenu.FieldAppID] = struct{}{}
			}
		case "action":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppActionClient{config: am.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, appactionImplementors)...); err != nil {
				return err
			}
			am.withAction = query
			if _, ok := fieldSeen[appmenu.FieldActionID]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldActionID)
				fieldSeen[appmenu.FieldActionID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[appmenu.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldCreatedBy)
				fieldSeen[appmenu.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[appmenu.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldCreatedAt)
				fieldSeen[appmenu.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[appmenu.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldUpdatedBy)
				fieldSeen[appmenu.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[appmenu.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldUpdatedAt)
				fieldSeen[appmenu.FieldUpdatedAt] = struct{}{}
			}
		case "appID":
			if _, ok := fieldSeen[appmenu.FieldAppID]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldAppID)
				fieldSeen[appmenu.FieldAppID] = struct{}{}
			}
		case "parentID":
			if _, ok := fieldSeen[appmenu.FieldParentID]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldParentID)
				fieldSeen[appmenu.FieldParentID] = struct{}{}
			}
		case "kind":
			if _, ok := fieldSeen[appmenu.FieldKind]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldKind)
				fieldSeen[appmenu.FieldKind] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[appmenu.FieldName]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldName)
				fieldSeen[appmenu.FieldName] = struct{}{}
			}
		case "icon":
			if _, ok := fieldSeen[appmenu.FieldIcon]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldIcon)
				fieldSeen[appmenu.FieldIcon] = struct{}{}
			}
		case "route":
			if _, ok := fieldSeen[appmenu.FieldRoute]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldRoute)
				fieldSeen[appmenu.FieldRoute] = struct{}{}
			}
		case "actionID":
			if _, ok := fieldSeen[appmenu.FieldActionID]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldActionID)
				fieldSeen[appmenu.FieldActionID] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[appmenu.FieldComments]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldComments)
				fieldSeen[appmenu.FieldComments] = struct{}{}
			}
		case "displaySort":
			if _, ok := fieldSeen[appmenu.FieldDisplaySort]; !ok {
				selectedFields = append(selectedFields, appmenu.FieldDisplaySort)
				fieldSeen[appmenu.FieldDisplaySort] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		am.Select(selectedFields...)
	}
	return nil
}

type appmenuPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AppMenuPaginateOption
}

func newAppMenuPaginateArgs(rv map[string]any) *appmenuPaginateArgs {
	args := &appmenuPaginateArgs{}
	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      = &AppMenuOrder{Field: &AppMenuOrderField{}, 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, WithAppMenuOrder(order))
			}
		case *AppMenuOrder:
			if v != nil {
				args.opts = append(args.opts, WithAppMenuOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AppMenuWhereInput); ok {
		args.opts = append(args.opts, WithAppMenuFilter(v.Filter))
	}
	return args
}

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

func (ap *AppPolicyQuery) 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(apppolicy.Columns))
		selectedFields = []string{apppolicy.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "app":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppClient{config: ap.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, appImplementors)...); err != nil {
				return err
			}
			ap.withApp = query
			if _, ok := fieldSeen[apppolicy.FieldAppID]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldAppID)
				fieldSeen[apppolicy.FieldAppID] = struct{}{}
			}
		case "roles":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppRoleClient{config: ap.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, approleImplementors)...); err != nil {
				return err
			}
			ap.WithNamedRoles(alias, func(wq *AppRoleQuery) {
				*wq = *query
			})
		case "createdBy":
			if _, ok := fieldSeen[apppolicy.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldCreatedBy)
				fieldSeen[apppolicy.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[apppolicy.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldCreatedAt)
				fieldSeen[apppolicy.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[apppolicy.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldUpdatedBy)
				fieldSeen[apppolicy.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[apppolicy.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldUpdatedAt)
				fieldSeen[apppolicy.FieldUpdatedAt] = struct{}{}
			}
		case "appID":
			if _, ok := fieldSeen[apppolicy.FieldAppID]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldAppID)
				fieldSeen[apppolicy.FieldAppID] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[apppolicy.FieldName]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldName)
				fieldSeen[apppolicy.FieldName] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[apppolicy.FieldComments]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldComments)
				fieldSeen[apppolicy.FieldComments] = struct{}{}
			}
		case "rules":
			if _, ok := fieldSeen[apppolicy.FieldRules]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldRules)
				fieldSeen[apppolicy.FieldRules] = struct{}{}
			}
		case "autoGrant":
			if _, ok := fieldSeen[apppolicy.FieldAutoGrant]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldAutoGrant)
				fieldSeen[apppolicy.FieldAutoGrant] = struct{}{}
			}
		case "status":
			if _, ok := fieldSeen[apppolicy.FieldStatus]; !ok {
				selectedFields = append(selectedFields, apppolicy.FieldStatus)
				fieldSeen[apppolicy.FieldStatus] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ap.Select(selectedFields...)
	}
	return nil
}

type apppolicyPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AppPolicyPaginateOption
}

func newAppPolicyPaginateArgs(rv map[string]any) *apppolicyPaginateArgs {
	args := &apppolicyPaginateArgs{}
	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      = &AppPolicyOrder{Field: &AppPolicyOrderField{}, 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, WithAppPolicyOrder(order))
			}
		case *AppPolicyOrder:
			if v != nil {
				args.opts = append(args.opts, WithAppPolicyOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AppPolicyWhereInput); ok {
		args.opts = append(args.opts, WithAppPolicyFilter(v.Filter))
	}
	return args
}

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

func (ar *AppResQuery) 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(appres.Columns))
		selectedFields = []string{appres.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "app":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppClient{config: ar.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, appImplementors)...); err != nil {
				return err
			}
			ar.withApp = query
			if _, ok := fieldSeen[appres.FieldAppID]; !ok {
				selectedFields = append(selectedFields, appres.FieldAppID)
				fieldSeen[appres.FieldAppID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[appres.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, appres.FieldCreatedBy)
				fieldSeen[appres.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[appres.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, appres.FieldCreatedAt)
				fieldSeen[appres.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[appres.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, appres.FieldUpdatedBy)
				fieldSeen[appres.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[appres.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, appres.FieldUpdatedAt)
				fieldSeen[appres.FieldUpdatedAt] = struct{}{}
			}
		case "appID":
			if _, ok := fieldSeen[appres.FieldAppID]; !ok {
				selectedFields = append(selectedFields, appres.FieldAppID)
				fieldSeen[appres.FieldAppID] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[appres.FieldName]; !ok {
				selectedFields = append(selectedFields, appres.FieldName)
				fieldSeen[appres.FieldName] = struct{}{}
			}
		case "typeName":
			if _, ok := fieldSeen[appres.FieldTypeName]; !ok {
				selectedFields = append(selectedFields, appres.FieldTypeName)
				fieldSeen[appres.FieldTypeName] = struct{}{}
			}
		case "arnPattern":
			if _, ok := fieldSeen[appres.FieldArnPattern]; !ok {
				selectedFields = append(selectedFields, appres.FieldArnPattern)
				fieldSeen[appres.FieldArnPattern] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ar.Select(selectedFields...)
	}
	return nil
}

type appresPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AppResPaginateOption
}

func newAppResPaginateArgs(rv map[string]any) *appresPaginateArgs {
	args := &appresPaginateArgs{}
	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      = &AppResOrder{Field: &AppResOrderField{}, 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, WithAppResOrder(order))
			}
		case *AppResOrder:
			if v != nil {
				args.opts = append(args.opts, WithAppResOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AppResWhereInput); ok {
		args.opts = append(args.opts, WithAppResFilter(v.Filter))
	}
	return args
}

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

func (ar *AppRoleQuery) 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(approle.Columns))
		selectedFields = []string{approle.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "app":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppClient{config: ar.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, appImplementors)...); err != nil {
				return err
			}
			ar.withApp = query
			if _, ok := fieldSeen[approle.FieldAppID]; !ok {
				selectedFields = append(selectedFields, approle.FieldAppID)
				fieldSeen[approle.FieldAppID] = struct{}{}
			}
		case "policies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppPolicyClient{config: ar.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, apppolicyImplementors)...); err != nil {
				return err
			}
			ar.WithNamedPolicies(alias, func(wq *AppPolicyQuery) {
				*wq = *query
			})
		case "createdBy":
			if _, ok := fieldSeen[approle.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, approle.FieldCreatedBy)
				fieldSeen[approle.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[approle.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, approle.FieldCreatedAt)
				fieldSeen[approle.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[approle.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, approle.FieldUpdatedBy)
				fieldSeen[approle.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[approle.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, approle.FieldUpdatedAt)
				fieldSeen[approle.FieldUpdatedAt] = struct{}{}
			}
		case "appID":
			if _, ok := fieldSeen[approle.FieldAppID]; !ok {
				selectedFields = append(selectedFields, approle.FieldAppID)
				fieldSeen[approle.FieldAppID] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[approle.FieldName]; !ok {
				selectedFields = append(selectedFields, approle.FieldName)
				fieldSeen[approle.FieldName] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[approle.FieldComments]; !ok {
				selectedFields = append(selectedFields, approle.FieldComments)
				fieldSeen[approle.FieldComments] = struct{}{}
			}
		case "autoGrant":
			if _, ok := fieldSeen[approle.FieldAutoGrant]; !ok {
				selectedFields = append(selectedFields, approle.FieldAutoGrant)
				fieldSeen[approle.FieldAutoGrant] = struct{}{}
			}
		case "editable":
			if _, ok := fieldSeen[approle.FieldEditable]; !ok {
				selectedFields = append(selectedFields, approle.FieldEditable)
				fieldSeen[approle.FieldEditable] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ar.Select(selectedFields...)
	}
	return nil
}

type approlePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []AppRolePaginateOption
}

func newAppRolePaginateArgs(rv map[string]any) *approlePaginateArgs {
	args := &approlePaginateArgs{}
	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      = &AppRoleOrder{Field: &AppRoleOrderField{}, 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, WithAppRoleOrder(order))
			}
		case *AppRoleOrder:
			if v != nil {
				args.opts = append(args.opts, WithAppRoleOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*AppRoleWhereInput); ok {
		args.opts = append(args.opts, WithAppRoleFilter(v.Filter))
	}
	return args
}

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

func (f *FileQuery) 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(file.Columns))
		selectedFields = []string{file.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "source":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&FileSourceClient{config: f.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, filesourceImplementors)...); err != nil {
				return err
			}
			f.withSource = query
			if _, ok := fieldSeen[file.FieldSourceID]; !ok {
				selectedFields = append(selectedFields, file.FieldSourceID)
				fieldSeen[file.FieldSourceID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[file.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, file.FieldCreatedBy)
				fieldSeen[file.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[file.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, file.FieldCreatedAt)
				fieldSeen[file.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[file.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, file.FieldUpdatedBy)
				fieldSeen[file.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[file.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, file.FieldUpdatedAt)
				fieldSeen[file.FieldUpdatedAt] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[file.FieldName]; !ok {
				selectedFields = append(selectedFields, file.FieldName)
				fieldSeen[file.FieldName] = struct{}{}
			}
		case "sourceID":
			if _, ok := fieldSeen[file.FieldSourceID]; !ok {
				selectedFields = append(selectedFields, file.FieldSourceID)
				fieldSeen[file.FieldSourceID] = struct{}{}
			}
		case "tenantID":
			if _, ok := fieldSeen[file.FieldTenantID]; !ok {
				selectedFields = append(selectedFields, file.FieldTenantID)
				fieldSeen[file.FieldTenantID] = struct{}{}
			}
		case "path":
			if _, ok := fieldSeen[file.FieldPath]; !ok {
				selectedFields = append(selectedFields, file.FieldPath)
				fieldSeen[file.FieldPath] = struct{}{}
			}
		case "size":
			if _, ok := fieldSeen[file.FieldSize]; !ok {
				selectedFields = append(selectedFields, file.FieldSize)
				fieldSeen[file.FieldSize] = struct{}{}
			}
		case "mineType":
			if _, ok := fieldSeen[file.FieldMineType]; !ok {
				selectedFields = append(selectedFields, file.FieldMineType)
				fieldSeen[file.FieldMineType] = struct{}{}
			}
		case "md5":
			if _, ok := fieldSeen[file.FieldMd5]; !ok {
				selectedFields = append(selectedFields, file.FieldMd5)
				fieldSeen[file.FieldMd5] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		f.Select(selectedFields...)
	}
	return nil
}

type filePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []FilePaginateOption
}

func newFilePaginateArgs(rv map[string]any) *filePaginateArgs {
	args := &filePaginateArgs{}
	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      = &FileOrder{Field: &FileOrderField{}, 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, WithFileOrder(order))
			}
		case *FileOrder:
			if v != nil {
				args.opts = append(args.opts, WithFileOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*FileWhereInput); ok {
		args.opts = append(args.opts, WithFileFilter(v.Filter))
	}
	return args
}

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

func (fs *FileSourceQuery) 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(filesource.Columns))
		selectedFields = []string{filesource.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "files":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&FileClient{config: fs.config}).Query()
			)
			args := newFilePaginateArgs(fieldArgs(ctx, new(FileWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newFilePager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					fs.loadTotal = append(fs.loadTotal, func(ctx context.Context, nodes []*FileSource) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"source_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(s.C(filesource.FilesColumn), ids...))
						})
						if err := query.GroupBy(filesource.FilesColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				} else {
					fs.loadTotal = append(fs.loadTotal, func(_ context.Context, nodes []*FileSource) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Files)
							if nodes[i].Edges.totalCount[0] == nil {
								nodes[i].Edges.totalCount[0] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[0][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, fileImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, filesource.FilesColumn, limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			fs.WithNamedFiles(alias, func(wq *FileQuery) {
				*wq = *query
			})
		case "createdBy":
			if _, ok := fieldSeen[filesource.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, filesource.FieldCreatedBy)
				fieldSeen[filesource.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[filesource.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, filesource.FieldCreatedAt)
				fieldSeen[filesource.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[filesource.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, filesource.FieldUpdatedBy)
				fieldSeen[filesource.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[filesource.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, filesource.FieldUpdatedAt)
				fieldSeen[filesource.FieldUpdatedAt] = struct{}{}
			}
		case "kind":
			if _, ok := fieldSeen[filesource.FieldKind]; !ok {
				selectedFields = append(selectedFields, filesource.FieldKind)
				fieldSeen[filesource.FieldKind] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[filesource.FieldComments]; !ok {
				selectedFields = append(selectedFields, filesource.FieldComments)
				fieldSeen[filesource.FieldComments] = struct{}{}
			}
		case "endpoint":
			if _, ok := fieldSeen[filesource.FieldEndpoint]; !ok {
				selectedFields = append(selectedFields, filesource.FieldEndpoint)
				fieldSeen[filesource.FieldEndpoint] = struct{}{}
			}
		case "region":
			if _, ok := fieldSeen[filesource.FieldRegion]; !ok {
				selectedFields = append(selectedFields, filesource.FieldRegion)
				fieldSeen[filesource.FieldRegion] = struct{}{}
			}
		case "bucket":
			if _, ok := fieldSeen[filesource.FieldBucket]; !ok {
				selectedFields = append(selectedFields, filesource.FieldBucket)
				fieldSeen[filesource.FieldBucket] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		fs.Select(selectedFields...)
	}
	return nil
}

type filesourcePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []FileSourcePaginateOption
}

func newFileSourcePaginateArgs(rv map[string]any) *filesourcePaginateArgs {
	args := &filesourcePaginateArgs{}
	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      = &FileSourceOrder{Field: &FileSourceOrderField{}, 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, WithFileSourceOrder(order))
			}
		case *FileSourceOrder:
			if v != nil {
				args.opts = append(args.opts, WithFileSourceOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*FileSourceWhereInput); ok {
		args.opts = append(args.opts, WithFileSourceFilter(v.Filter))
	}
	return args
}

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

func (oc *OauthClientQuery) 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(oauthclient.Columns))
		selectedFields = []string{oauthclient.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "user":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserClient{config: oc.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, userImplementors)...); err != nil {
				return err
			}
			oc.withUser = query
			if _, ok := fieldSeen[oauthclient.FieldUserID]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldUserID)
				fieldSeen[oauthclient.FieldUserID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[oauthclient.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldCreatedBy)
				fieldSeen[oauthclient.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[oauthclient.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldCreatedAt)
				fieldSeen[oauthclient.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[oauthclient.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldUpdatedBy)
				fieldSeen[oauthclient.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[oauthclient.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldUpdatedAt)
				fieldSeen[oauthclient.FieldUpdatedAt] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[oauthclient.FieldName]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldName)
				fieldSeen[oauthclient.FieldName] = struct{}{}
			}
		case "clientID":
			if _, ok := fieldSeen[oauthclient.FieldClientID]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldClientID)
				fieldSeen[oauthclient.FieldClientID] = struct{}{}
			}
		case "clientSecret":
			if _, ok := fieldSeen[oauthclient.FieldClientSecret]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldClientSecret)
				fieldSeen[oauthclient.FieldClientSecret] = struct{}{}
			}
		case "grantTypes":
			if _, ok := fieldSeen[oauthclient.FieldGrantTypes]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldGrantTypes)
				fieldSeen[oauthclient.FieldGrantTypes] = struct{}{}
			}
		case "userID":
			if _, ok := fieldSeen[oauthclient.FieldUserID]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldUserID)
				fieldSeen[oauthclient.FieldUserID] = struct{}{}
			}
		case "lastAuthAt":
			if _, ok := fieldSeen[oauthclient.FieldLastAuthAt]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldLastAuthAt)
				fieldSeen[oauthclient.FieldLastAuthAt] = struct{}{}
			}
		case "status":
			if _, ok := fieldSeen[oauthclient.FieldStatus]; !ok {
				selectedFields = append(selectedFields, oauthclient.FieldStatus)
				fieldSeen[oauthclient.FieldStatus] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		oc.Select(selectedFields...)
	}
	return nil
}

type oauthclientPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []OauthClientPaginateOption
}

func newOauthClientPaginateArgs(rv map[string]any) *oauthclientPaginateArgs {
	args := &oauthclientPaginateArgs{}
	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      = &OauthClientOrder{Field: &OauthClientOrderField{}, 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, WithOauthClientOrder(order))
			}
		case *OauthClientOrder:
			if v != nil {
				args.opts = append(args.opts, WithOauthClientOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*OauthClientWhereInput); ok {
		args.opts = append(args.opts, WithOauthClientFilter(v.Filter))
	}
	return args
}

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

func (o *OrgQuery) 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(org.Columns))
		selectedFields = []string{org.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "parent":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OrgClient{config: o.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, orgImplementors)...); err != nil {
				return err
			}
			o.withParent = query
			if _, ok := fieldSeen[org.FieldParentID]; !ok {
				selectedFields = append(selectedFields, org.FieldParentID)
				fieldSeen[org.FieldParentID] = struct{}{}
			}
		case "children":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OrgClient{config: o.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, orgImplementors)...); err != nil {
				return err
			}
			o.WithNamedChildren(alias, func(wq *OrgQuery) {
				*wq = *query
			})
		case "owner":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserClient{config: o.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, userImplementors)...); err != nil {
				return err
			}
			o.withOwner = query
			if _, ok := fieldSeen[org.FieldOwnerID]; !ok {
				selectedFields = append(selectedFields, org.FieldOwnerID)
				fieldSeen[org.FieldOwnerID] = struct{}{}
			}
		case "users":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserClient{config: o.config}).Query()
			)
			args := newUserPaginateArgs(fieldArgs(ctx, new(UserWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newUserPager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					o.loadTotal = append(o.loadTotal, func(ctx context.Context, nodes []*Org) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"org_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(org.UsersTable)
							s.Join(joinT).On(s.C(user.FieldID), joinT.C(org.UsersPrimaryKey[1]))
							s.Where(sql.InValues(joinT.C(org.UsersPrimaryKey[0]), ids...))
							s.Select(joinT.C(org.UsersPrimaryKey[0]), sql.Count("*"))
							s.GroupBy(joinT.C(org.UsersPrimaryKey[0]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[3] == nil {
								nodes[i].Edges.totalCount[3] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[3][alias] = n
						}
						return nil
					})
				} else {
					o.loadTotal = append(o.loadTotal, func(_ context.Context, nodes []*Org) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Users)
							if nodes[i].Edges.totalCount[3] == nil {
								nodes[i].Edges.totalCount[3] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[3][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, userImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, org.UsersPrimaryKey[0], limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			o.WithNamedUsers(alias, func(wq *UserQuery) {
				*wq = *query
			})
		case "permissions":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&PermissionClient{config: o.config}).Query()
			)
			args := newPermissionPaginateArgs(fieldArgs(ctx, new(PermissionWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newPermissionPager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					o.loadTotal = append(o.loadTotal, func(ctx context.Context, nodes []*Org) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"org_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(s.C(org.PermissionsColumn), ids...))
						})
						if err := query.GroupBy(org.PermissionsColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[4] == nil {
								nodes[i].Edges.totalCount[4] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[4][alias] = n
						}
						return nil
					})
				} else {
					o.loadTotal = append(o.loadTotal, func(_ context.Context, nodes []*Org) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Permissions)
							if nodes[i].Edges.totalCount[4] == nil {
								nodes[i].Edges.totalCount[4] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[4][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, permissionImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, org.PermissionsColumn, limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			o.WithNamedPermissions(alias, func(wq *PermissionQuery) {
				*wq = *query
			})
		case "policies":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OrgPolicyClient{config: o.config}).Query()
			)
			args := newOrgPolicyPaginateArgs(fieldArgs(ctx, new(OrgPolicyWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newOrgPolicyPager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					o.loadTotal = append(o.loadTotal, func(ctx context.Context, nodes []*Org) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"org_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(s.C(org.PoliciesColumn), ids...))
						})
						if err := query.GroupBy(org.PoliciesColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[5] == nil {
								nodes[i].Edges.totalCount[5] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[5][alias] = n
						}
						return nil
					})
				} else {
					o.loadTotal = append(o.loadTotal, func(_ context.Context, nodes []*Org) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Policies)
							if nodes[i].Edges.totalCount[5] == nil {
								nodes[i].Edges.totalCount[5] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[5][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, orgpolicyImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, org.PoliciesColumn, limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			o.WithNamedPolicies(alias, func(wq *OrgPolicyQuery) {
				*wq = *query
			})
		case "apps":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&AppClient{config: o.config}).Query()
			)
			args := newAppPaginateArgs(fieldArgs(ctx, new(AppWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newAppPager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					o.loadTotal = append(o.loadTotal, func(ctx context.Context, nodes []*Org) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"org_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							joinT := sql.Table(org.AppsTable)
							s.Join(joinT).On(s.C(app.FieldID), joinT.C(org.AppsPrimaryKey[1]))
							s.Where(sql.InValues(joinT.C(org.AppsPrimaryKey[0]), ids...))
							s.Select(joinT.C(org.AppsPrimaryKey[0]), sql.Count("*"))
							s.GroupBy(joinT.C(org.AppsPrimaryKey[0]))
						})
						if err := query.Select().Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[6] == nil {
								nodes[i].Edges.totalCount[6] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[6][alias] = n
						}
						return nil
					})
				} else {
					o.loadTotal = append(o.loadTotal, func(_ context.Context, nodes []*Org) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Apps)
							if nodes[i].Edges.totalCount[6] == nil {
								nodes[i].Edges.totalCount[6] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[6][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, appImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, org.AppsPrimaryKey[0], limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			o.WithNamedApps(alias, func(wq *AppQuery) {
				*wq = *query
			})
		case "createdBy":
			if _, ok := fieldSeen[org.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, org.FieldCreatedBy)
				fieldSeen[org.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[org.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, org.FieldCreatedAt)
				fieldSeen[org.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[org.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, org.FieldUpdatedBy)
				fieldSeen[org.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[org.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, org.FieldUpdatedAt)
				fieldSeen[org.FieldUpdatedAt] = struct{}{}
			}
		case "deletedAt":
			if _, ok := fieldSeen[org.FieldDeletedAt]; !ok {
				selectedFields = append(selectedFields, org.FieldDeletedAt)
				fieldSeen[org.FieldDeletedAt] = struct{}{}
			}
		case "ownerID":
			if _, ok := fieldSeen[org.FieldOwnerID]; !ok {
				selectedFields = append(selectedFields, org.FieldOwnerID)
				fieldSeen[org.FieldOwnerID] = struct{}{}
			}
		case "kind":
			if _, ok := fieldSeen[org.FieldKind]; !ok {
				selectedFields = append(selectedFields, org.FieldKind)
				fieldSeen[org.FieldKind] = struct{}{}
			}
		case "parentID":
			if _, ok := fieldSeen[org.FieldParentID]; !ok {
				selectedFields = append(selectedFields, org.FieldParentID)
				fieldSeen[org.FieldParentID] = struct{}{}
			}
		case "domain":
			if _, ok := fieldSeen[org.FieldDomain]; !ok {
				selectedFields = append(selectedFields, org.FieldDomain)
				fieldSeen[org.FieldDomain] = struct{}{}
			}
		case "code":
			if _, ok := fieldSeen[org.FieldCode]; !ok {
				selectedFields = append(selectedFields, org.FieldCode)
				fieldSeen[org.FieldCode] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[org.FieldName]; !ok {
				selectedFields = append(selectedFields, org.FieldName)
				fieldSeen[org.FieldName] = struct{}{}
			}
		case "profile":
			if _, ok := fieldSeen[org.FieldProfile]; !ok {
				selectedFields = append(selectedFields, org.FieldProfile)
				fieldSeen[org.FieldProfile] = struct{}{}
			}
		case "status":
			if _, ok := fieldSeen[org.FieldStatus]; !ok {
				selectedFields = append(selectedFields, org.FieldStatus)
				fieldSeen[org.FieldStatus] = struct{}{}
			}
		case "path":
			if _, ok := fieldSeen[org.FieldPath]; !ok {
				selectedFields = append(selectedFields, org.FieldPath)
				fieldSeen[org.FieldPath] = struct{}{}
			}
		case "displaySort":
			if _, ok := fieldSeen[org.FieldDisplaySort]; !ok {
				selectedFields = append(selectedFields, org.FieldDisplaySort)
				fieldSeen[org.FieldDisplaySort] = struct{}{}
			}
		case "countryCode":
			if _, ok := fieldSeen[org.FieldCountryCode]; !ok {
				selectedFields = append(selectedFields, org.FieldCountryCode)
				fieldSeen[org.FieldCountryCode] = struct{}{}
			}
		case "timezone":
			if _, ok := fieldSeen[org.FieldTimezone]; !ok {
				selectedFields = append(selectedFields, org.FieldTimezone)
				fieldSeen[org.FieldTimezone] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		o.Select(selectedFields...)
	}
	return nil
}

type orgPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []OrgPaginateOption
}

func newOrgPaginateArgs(rv map[string]any) *orgPaginateArgs {
	args := &orgPaginateArgs{}
	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      = &OrgOrder{Field: &OrgOrderField{}, 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, WithOrgOrder(order))
			}
		case *OrgOrder:
			if v != nil {
				args.opts = append(args.opts, WithOrgOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*OrgWhereInput); ok {
		args.opts = append(args.opts, WithOrgFilter(v.Filter))
	}
	return args
}

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

func (op *OrgPolicyQuery) 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(orgpolicy.Columns))
		selectedFields = []string{orgpolicy.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "org":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OrgClient{config: op.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, orgImplementors)...); err != nil {
				return err
			}
			op.withOrg = query
			if _, ok := fieldSeen[orgpolicy.FieldOrgID]; !ok {
				selectedFields = append(selectedFields, orgpolicy.FieldOrgID)
				fieldSeen[orgpolicy.FieldOrgID] = struct{}{}
			}
		case "permissions":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&PermissionClient{config: op.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, permissionImplementors)...); err != nil {
				return err
			}
			op.WithNamedPermissions(alias, func(wq *PermissionQuery) {
				*wq = *query
			})
		case "createdBy":
			if _, ok := fieldSeen[orgpolicy.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, orgpolicy.FieldCreatedBy)
				fieldSeen[orgpolicy.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[orgpolicy.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, orgpolicy.FieldCreatedAt)
				fieldSeen[orgpolicy.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[orgpolicy.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, orgpolicy.FieldUpdatedBy)
				fieldSeen[orgpolicy.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[orgpolicy.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, orgpolicy.FieldUpdatedAt)
				fieldSeen[orgpolicy.FieldUpdatedAt] = struct{}{}
			}
		case "orgID":
			if _, ok := fieldSeen[orgpolicy.FieldOrgID]; !ok {
				selectedFields = append(selectedFields, orgpolicy.FieldOrgID)
				fieldSeen[orgpolicy.FieldOrgID] = struct{}{}
			}
		case "appPolicyID":
			if _, ok := fieldSeen[orgpolicy.FieldAppPolicyID]; !ok {
				selectedFields = append(selectedFields, orgpolicy.FieldAppPolicyID)
				fieldSeen[orgpolicy.FieldAppPolicyID] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[orgpolicy.FieldName]; !ok {
				selectedFields = append(selectedFields, orgpolicy.FieldName)
				fieldSeen[orgpolicy.FieldName] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[orgpolicy.FieldComments]; !ok {
				selectedFields = append(selectedFields, orgpolicy.FieldComments)
				fieldSeen[orgpolicy.FieldComments] = struct{}{}
			}
		case "rules":
			if _, ok := fieldSeen[orgpolicy.FieldRules]; !ok {
				selectedFields = append(selectedFields, orgpolicy.FieldRules)
				fieldSeen[orgpolicy.FieldRules] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		op.Select(selectedFields...)
	}
	return nil
}

type orgpolicyPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []OrgPolicyPaginateOption
}

func newOrgPolicyPaginateArgs(rv map[string]any) *orgpolicyPaginateArgs {
	args := &orgpolicyPaginateArgs{}
	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      = &OrgPolicyOrder{Field: &OrgPolicyOrderField{}, 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, WithOrgPolicyOrder(order))
			}
		case *OrgPolicyOrder:
			if v != nil {
				args.opts = append(args.opts, WithOrgPolicyOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*OrgPolicyWhereInput); ok {
		args.opts = append(args.opts, WithOrgPolicyFilter(v.Filter))
	}
	return args
}

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

func (or *OrgRoleQuery) 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(orgrole.Columns))
		selectedFields = []string{orgrole.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "createdBy":
			if _, ok := fieldSeen[orgrole.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, orgrole.FieldCreatedBy)
				fieldSeen[orgrole.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[orgrole.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, orgrole.FieldCreatedAt)
				fieldSeen[orgrole.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[orgrole.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, orgrole.FieldUpdatedBy)
				fieldSeen[orgrole.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[orgrole.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, orgrole.FieldUpdatedAt)
				fieldSeen[orgrole.FieldUpdatedAt] = struct{}{}
			}
		case "orgID":
			if _, ok := fieldSeen[orgrole.FieldOrgID]; !ok {
				selectedFields = append(selectedFields, orgrole.FieldOrgID)
				fieldSeen[orgrole.FieldOrgID] = struct{}{}
			}
		case "kind":
			if _, ok := fieldSeen[orgrole.FieldKind]; !ok {
				selectedFields = append(selectedFields, orgrole.FieldKind)
				fieldSeen[orgrole.FieldKind] = struct{}{}
			}
		case "name":
			if _, ok := fieldSeen[orgrole.FieldName]; !ok {
				selectedFields = append(selectedFields, orgrole.FieldName)
				fieldSeen[orgrole.FieldName] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[orgrole.FieldComments]; !ok {
				selectedFields = append(selectedFields, orgrole.FieldComments)
				fieldSeen[orgrole.FieldComments] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		or.Select(selectedFields...)
	}
	return nil
}

type orgrolePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []OrgRolePaginateOption
}

func newOrgRolePaginateArgs(rv map[string]any) *orgrolePaginateArgs {
	args := &orgrolePaginateArgs{}
	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      = &OrgRoleOrder{Field: &OrgRoleOrderField{}, 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, WithOrgRoleOrder(order))
			}
		case *OrgRoleOrder:
			if v != nil {
				args.opts = append(args.opts, WithOrgRoleOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*OrgRoleWhereInput); ok {
		args.opts = append(args.opts, WithOrgRoleFilter(v.Filter))
	}
	return args
}

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

func (oup *OrgUserPreferenceQuery) 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(orguserpreference.Columns))
		selectedFields = []string{orguserpreference.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "user":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserClient{config: oup.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, userImplementors)...); err != nil {
				return err
			}
			oup.withUser = query
			if _, ok := fieldSeen[orguserpreference.FieldUserID]; !ok {
				selectedFields = append(selectedFields, orguserpreference.FieldUserID)
				fieldSeen[orguserpreference.FieldUserID] = struct{}{}
			}
		case "org":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OrgClient{config: oup.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, orgImplementors)...); err != nil {
				return err
			}
			oup.withOrg = query
			if _, ok := fieldSeen[orguserpreference.FieldOrgID]; !ok {
				selectedFields = append(selectedFields, orguserpreference.FieldOrgID)
				fieldSeen[orguserpreference.FieldOrgID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[orguserpreference.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, orguserpreference.FieldCreatedBy)
				fieldSeen[orguserpreference.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[orguserpreference.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, orguserpreference.FieldCreatedAt)
				fieldSeen[orguserpreference.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[orguserpreference.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, orguserpreference.FieldUpdatedBy)
				fieldSeen[orguserpreference.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[orguserpreference.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, orguserpreference.FieldUpdatedAt)
				fieldSeen[orguserpreference.FieldUpdatedAt] = struct{}{}
			}
		case "userID":
			if _, ok := fieldSeen[orguserpreference.FieldUserID]; !ok {
				selectedFields = append(selectedFields, orguserpreference.FieldUserID)
				fieldSeen[orguserpreference.FieldUserID] = struct{}{}
			}
		case "orgID":
			if _, ok := fieldSeen[orguserpreference.FieldOrgID]; !ok {
				selectedFields = append(selectedFields, orguserpreference.FieldOrgID)
				fieldSeen[orguserpreference.FieldOrgID] = struct{}{}
			}
		case "menuFavorite":
			if _, ok := fieldSeen[orguserpreference.FieldMenuFavorite]; !ok {
				selectedFields = append(selectedFields, orguserpreference.FieldMenuFavorite)
				fieldSeen[orguserpreference.FieldMenuFavorite] = struct{}{}
			}
		case "menuRecent":
			if _, ok := fieldSeen[orguserpreference.FieldMenuRecent]; !ok {
				selectedFields = append(selectedFields, orguserpreference.FieldMenuRecent)
				fieldSeen[orguserpreference.FieldMenuRecent] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		oup.Select(selectedFields...)
	}
	return nil
}

type orguserpreferencePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []OrgUserPreferencePaginateOption
}

func newOrgUserPreferencePaginateArgs(rv map[string]any) *orguserpreferencePaginateArgs {
	args := &orguserpreferencePaginateArgs{}
	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      = &OrgUserPreferenceOrder{Field: &OrgUserPreferenceOrderField{}, 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, WithOrgUserPreferenceOrder(order))
			}
		case *OrgUserPreferenceOrder:
			if v != nil {
				args.opts = append(args.opts, WithOrgUserPreferenceOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*OrgUserPreferenceWhereInput); ok {
		args.opts = append(args.opts, WithOrgUserPreferenceFilter(v.Filter))
	}
	return args
}

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

func (pe *PermissionQuery) 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(permission.Columns))
		selectedFields = []string{permission.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "org":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OrgClient{config: pe.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, orgImplementors)...); err != nil {
				return err
			}
			pe.withOrg = query
			if _, ok := fieldSeen[permission.FieldOrgID]; !ok {
				selectedFields = append(selectedFields, permission.FieldOrgID)
				fieldSeen[permission.FieldOrgID] = struct{}{}
			}
		case "user":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserClient{config: pe.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, userImplementors)...); err != nil {
				return err
			}
			pe.withUser = query
			if _, ok := fieldSeen[permission.FieldUserID]; !ok {
				selectedFields = append(selectedFields, permission.FieldUserID)
				fieldSeen[permission.FieldUserID] = struct{}{}
			}
		case "role":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OrgRoleClient{config: pe.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, orgroleImplementors)...); err != nil {
				return err
			}
			pe.withRole = query
			if _, ok := fieldSeen[permission.FieldRoleID]; !ok {
				selectedFields = append(selectedFields, permission.FieldRoleID)
				fieldSeen[permission.FieldRoleID] = struct{}{}
			}
		case "orgPolicy":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OrgPolicyClient{config: pe.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, orgpolicyImplementors)...); err != nil {
				return err
			}
			pe.withOrgPolicy = query
			if _, ok := fieldSeen[permission.FieldOrgPolicyID]; !ok {
				selectedFields = append(selectedFields, permission.FieldOrgPolicyID)
				fieldSeen[permission.FieldOrgPolicyID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[permission.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, permission.FieldCreatedBy)
				fieldSeen[permission.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[permission.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, permission.FieldCreatedAt)
				fieldSeen[permission.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[permission.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, permission.FieldUpdatedBy)
				fieldSeen[permission.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[permission.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, permission.FieldUpdatedAt)
				fieldSeen[permission.FieldUpdatedAt] = struct{}{}
			}
		case "orgID":
			if _, ok := fieldSeen[permission.FieldOrgID]; !ok {
				selectedFields = append(selectedFields, permission.FieldOrgID)
				fieldSeen[permission.FieldOrgID] = struct{}{}
			}
		case "principalKind":
			if _, ok := fieldSeen[permission.FieldPrincipalKind]; !ok {
				selectedFields = append(selectedFields, permission.FieldPrincipalKind)
				fieldSeen[permission.FieldPrincipalKind] = struct{}{}
			}
		case "userID":
			if _, ok := fieldSeen[permission.FieldUserID]; !ok {
				selectedFields = append(selectedFields, permission.FieldUserID)
				fieldSeen[permission.FieldUserID] = struct{}{}
			}
		case "roleID":
			if _, ok := fieldSeen[permission.FieldRoleID]; !ok {
				selectedFields = append(selectedFields, permission.FieldRoleID)
				fieldSeen[permission.FieldRoleID] = struct{}{}
			}
		case "orgPolicyID":
			if _, ok := fieldSeen[permission.FieldOrgPolicyID]; !ok {
				selectedFields = append(selectedFields, permission.FieldOrgPolicyID)
				fieldSeen[permission.FieldOrgPolicyID] = struct{}{}
			}
		case "startAt":
			if _, ok := fieldSeen[permission.FieldStartAt]; !ok {
				selectedFields = append(selectedFields, permission.FieldStartAt)
				fieldSeen[permission.FieldStartAt] = struct{}{}
			}
		case "endAt":
			if _, ok := fieldSeen[permission.FieldEndAt]; !ok {
				selectedFields = append(selectedFields, permission.FieldEndAt)
				fieldSeen[permission.FieldEndAt] = struct{}{}
			}
		case "status":
			if _, ok := fieldSeen[permission.FieldStatus]; !ok {
				selectedFields = append(selectedFields, permission.FieldStatus)
				fieldSeen[permission.FieldStatus] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		pe.Select(selectedFields...)
	}
	return nil
}

type permissionPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []PermissionPaginateOption
}

func newPermissionPaginateArgs(rv map[string]any) *permissionPaginateArgs {
	args := &permissionPaginateArgs{}
	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      = &PermissionOrder{Field: &PermissionOrderField{}, 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, WithPermissionOrder(order))
			}
		case *PermissionOrder:
			if v != nil {
				args.opts = append(args.opts, WithPermissionOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*PermissionWhereInput); ok {
		args.opts = append(args.opts, WithPermissionFilter(v.Filter))
	}
	return args
}

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

func (u *UserQuery) 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(user.Columns))
		selectedFields = []string{user.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "identities":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserIdentityClient{config: u.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, useridentityImplementors)...); err != nil {
				return err
			}
			u.WithNamedIdentities(alias, func(wq *UserIdentityQuery) {
				*wq = *query
			})
		case "loginProfile":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserLoginProfileClient{config: u.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, userloginprofileImplementors)...); err != nil {
				return err
			}
			u.withLoginProfile = query
		case "devices":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserDeviceClient{config: u.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, userdeviceImplementors)...); err != nil {
				return err
			}
			u.WithNamedDevices(alias, func(wq *UserDeviceQuery) {
				*wq = *query
			})
		case "permissions":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&PermissionClient{config: u.config}).Query()
			)
			args := newPermissionPaginateArgs(fieldArgs(ctx, new(PermissionWhereInput), path...))
			if err := validateFirstLast(args.first, args.last); err != nil {
				return fmt.Errorf("validate first and last in path %q: %w", path, err)
			}
			pager, err := newPermissionPager(args.opts, args.last != nil)
			if err != nil {
				return fmt.Errorf("create new pager in path %q: %w", path, err)
			}
			if query, err = pager.applyFilter(query); err != nil {
				return err
			}
			ignoredEdges := !hasCollectedField(ctx, append(path, edgesField)...)
			if hasCollectedField(ctx, append(path, totalCountField)...) || hasCollectedField(ctx, append(path, pageInfoField)...) {
				hasPagination := args.after != nil || args.first != nil || args.before != nil || args.last != nil
				if hasPagination || ignoredEdges {
					query := query.Clone()
					u.loadTotal = append(u.loadTotal, func(ctx context.Context, nodes []*User) error {
						ids := make([]driver.Value, len(nodes))
						for i := range nodes {
							ids[i] = nodes[i].ID
						}
						var v []struct {
							NodeID int `sql:"user_id"`
							Count  int `sql:"count"`
						}
						query.Where(func(s *sql.Selector) {
							s.Where(sql.InValues(s.C(user.PermissionsColumn), ids...))
						})
						if err := query.GroupBy(user.PermissionsColumn).Aggregate(Count()).Scan(ctx, &v); err != nil {
							return err
						}
						m := make(map[int]int, len(v))
						for i := range v {
							m[v[i].NodeID] = v[i].Count
						}
						for i := range nodes {
							n := m[nodes[i].ID]
							if nodes[i].Edges.totalCount[3] == nil {
								nodes[i].Edges.totalCount[3] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[3][alias] = n
						}
						return nil
					})
				} else {
					u.loadTotal = append(u.loadTotal, func(_ context.Context, nodes []*User) error {
						for i := range nodes {
							n := len(nodes[i].Edges.Permissions)
							if nodes[i].Edges.totalCount[3] == nil {
								nodes[i].Edges.totalCount[3] = make(map[string]int)
							}
							nodes[i].Edges.totalCount[3][alias] = n
						}
						return nil
					})
				}
			}
			if ignoredEdges || (args.first != nil && *args.first == 0) || (args.last != nil && *args.last == 0) {
				continue
			}
			if query, err = pager.applyCursors(query, args.after, args.before); err != nil {
				return err
			}
			path = append(path, edgesField, nodeField)
			if field := collectedField(ctx, path...); field != nil {
				if err := query.collectField(ctx, opCtx, *field, path, mayAddCondition(satisfies, permissionImplementors)...); err != nil {
					return err
				}
			}
			if limit := paginateLimit(args.first, args.last); limit > 0 {
				modify := limitRows(ctx, user.PermissionsColumn, limit, args.first, args.last, pager.orderExpr(query))
				query.modifiers = append(query.modifiers, modify)
			} else {
				query = pager.applyOrder(query)
			}
			u.WithNamedPermissions(alias, func(wq *PermissionQuery) {
				*wq = *query
			})
		case "oauthClients":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&OauthClientClient{config: u.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, oauthclientImplementors)...); err != nil {
				return err
			}
			u.WithNamedOauthClients(alias, func(wq *OauthClientQuery) {
				*wq = *query
			})
		case "createdBy":
			if _, ok := fieldSeen[user.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, user.FieldCreatedBy)
				fieldSeen[user.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[user.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, user.FieldCreatedAt)
				fieldSeen[user.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[user.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, user.FieldUpdatedBy)
				fieldSeen[user.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[user.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, user.FieldUpdatedAt)
				fieldSeen[user.FieldUpdatedAt] = struct{}{}
			}
		case "deletedAt":
			if _, ok := fieldSeen[user.FieldDeletedAt]; !ok {
				selectedFields = append(selectedFields, user.FieldDeletedAt)
				fieldSeen[user.FieldDeletedAt] = struct{}{}
			}
		case "principalName":
			if _, ok := fieldSeen[user.FieldPrincipalName]; !ok {
				selectedFields = append(selectedFields, user.FieldPrincipalName)
				fieldSeen[user.FieldPrincipalName] = struct{}{}
			}
		case "displayName":
			if _, ok := fieldSeen[user.FieldDisplayName]; !ok {
				selectedFields = append(selectedFields, user.FieldDisplayName)
				fieldSeen[user.FieldDisplayName] = struct{}{}
			}
		case "email":
			if _, ok := fieldSeen[user.FieldEmail]; !ok {
				selectedFields = append(selectedFields, user.FieldEmail)
				fieldSeen[user.FieldEmail] = struct{}{}
			}
		case "mobile":
			if _, ok := fieldSeen[user.FieldMobile]; !ok {
				selectedFields = append(selectedFields, user.FieldMobile)
				fieldSeen[user.FieldMobile] = struct{}{}
			}
		case "userType":
			if _, ok := fieldSeen[user.FieldUserType]; !ok {
				selectedFields = append(selectedFields, user.FieldUserType)
				fieldSeen[user.FieldUserType] = struct{}{}
			}
		case "creationType":
			if _, ok := fieldSeen[user.FieldCreationType]; !ok {
				selectedFields = append(selectedFields, user.FieldCreationType)
				fieldSeen[user.FieldCreationType] = struct{}{}
			}
		case "registerIP":
			if _, ok := fieldSeen[user.FieldRegisterIP]; !ok {
				selectedFields = append(selectedFields, user.FieldRegisterIP)
				fieldSeen[user.FieldRegisterIP] = struct{}{}
			}
		case "status":
			if _, ok := fieldSeen[user.FieldStatus]; !ok {
				selectedFields = append(selectedFields, user.FieldStatus)
				fieldSeen[user.FieldStatus] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[user.FieldComments]; !ok {
				selectedFields = append(selectedFields, user.FieldComments)
				fieldSeen[user.FieldComments] = struct{}{}
			}
		case "avatarFileID":
			if _, ok := fieldSeen[user.FieldAvatarFileID]; !ok {
				selectedFields = append(selectedFields, user.FieldAvatarFileID)
				fieldSeen[user.FieldAvatarFileID] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		u.Select(selectedFields...)
	}
	return nil
}

type userPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []UserPaginateOption
}

func newUserPaginateArgs(rv map[string]any) *userPaginateArgs {
	args := &userPaginateArgs{}
	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      = &UserOrder{Field: &UserOrderField{}, 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, WithUserOrder(order))
			}
		case *UserOrder:
			if v != nil {
				args.opts = append(args.opts, WithUserOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*UserWhereInput); ok {
		args.opts = append(args.opts, WithUserFilter(v.Filter))
	}
	return args
}

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

func (ud *UserDeviceQuery) 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(userdevice.Columns))
		selectedFields = []string{userdevice.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "user":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserClient{config: ud.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, userImplementors)...); err != nil {
				return err
			}
			ud.withUser = query
			if _, ok := fieldSeen[userdevice.FieldUserID]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldUserID)
				fieldSeen[userdevice.FieldUserID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[userdevice.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldCreatedBy)
				fieldSeen[userdevice.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[userdevice.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldCreatedAt)
				fieldSeen[userdevice.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[userdevice.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldUpdatedBy)
				fieldSeen[userdevice.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[userdevice.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldUpdatedAt)
				fieldSeen[userdevice.FieldUpdatedAt] = struct{}{}
			}
		case "userID":
			if _, ok := fieldSeen[userdevice.FieldUserID]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldUserID)
				fieldSeen[userdevice.FieldUserID] = struct{}{}
			}
		case "deviceUID":
			if _, ok := fieldSeen[userdevice.FieldDeviceUID]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldDeviceUID)
				fieldSeen[userdevice.FieldDeviceUID] = struct{}{}
			}
		case "deviceName":
			if _, ok := fieldSeen[userdevice.FieldDeviceName]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldDeviceName)
				fieldSeen[userdevice.FieldDeviceName] = struct{}{}
			}
		case "systemName":
			if _, ok := fieldSeen[userdevice.FieldSystemName]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldSystemName)
				fieldSeen[userdevice.FieldSystemName] = struct{}{}
			}
		case "systemVersion":
			if _, ok := fieldSeen[userdevice.FieldSystemVersion]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldSystemVersion)
				fieldSeen[userdevice.FieldSystemVersion] = struct{}{}
			}
		case "appVersion":
			if _, ok := fieldSeen[userdevice.FieldAppVersion]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldAppVersion)
				fieldSeen[userdevice.FieldAppVersion] = struct{}{}
			}
		case "deviceModel":
			if _, ok := fieldSeen[userdevice.FieldDeviceModel]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldDeviceModel)
				fieldSeen[userdevice.FieldDeviceModel] = struct{}{}
			}
		case "status":
			if _, ok := fieldSeen[userdevice.FieldStatus]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldStatus)
				fieldSeen[userdevice.FieldStatus] = struct{}{}
			}
		case "comments":
			if _, ok := fieldSeen[userdevice.FieldComments]; !ok {
				selectedFields = append(selectedFields, userdevice.FieldComments)
				fieldSeen[userdevice.FieldComments] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ud.Select(selectedFields...)
	}
	return nil
}

type userdevicePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []UserDevicePaginateOption
}

func newUserDevicePaginateArgs(rv map[string]any) *userdevicePaginateArgs {
	args := &userdevicePaginateArgs{}
	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      = &UserDeviceOrder{Field: &UserDeviceOrderField{}, 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, WithUserDeviceOrder(order))
			}
		case *UserDeviceOrder:
			if v != nil {
				args.opts = append(args.opts, WithUserDeviceOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*UserDeviceWhereInput); ok {
		args.opts = append(args.opts, WithUserDeviceFilter(v.Filter))
	}
	return args
}

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

func (ui *UserIdentityQuery) 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(useridentity.Columns))
		selectedFields = []string{useridentity.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "user":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserClient{config: ui.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, userImplementors)...); err != nil {
				return err
			}
			ui.withUser = query
			if _, ok := fieldSeen[useridentity.FieldUserID]; !ok {
				selectedFields = append(selectedFields, useridentity.FieldUserID)
				fieldSeen[useridentity.FieldUserID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[useridentity.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, useridentity.FieldCreatedBy)
				fieldSeen[useridentity.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[useridentity.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, useridentity.FieldCreatedAt)
				fieldSeen[useridentity.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[useridentity.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, useridentity.FieldUpdatedBy)
				fieldSeen[useridentity.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[useridentity.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, useridentity.FieldUpdatedAt)
				fieldSeen[useridentity.FieldUpdatedAt] = struct{}{}
			}
		case "userID":
			if _, ok := fieldSeen[useridentity.FieldUserID]; !ok {
				selectedFields = append(selectedFields, useridentity.FieldUserID)
				fieldSeen[useridentity.FieldUserID] = struct{}{}
			}
		case "kind":
			if _, ok := fieldSeen[useridentity.FieldKind]; !ok {
				selectedFields = append(selectedFields, useridentity.FieldKind)
				fieldSeen[useridentity.FieldKind] = struct{}{}
			}
		case "code":
			if _, ok := fieldSeen[useridentity.FieldCode]; !ok {
				selectedFields = append(selectedFields, useridentity.FieldCode)
				fieldSeen[useridentity.FieldCode] = struct{}{}
			}
		case "codeExtend":
			if _, ok := fieldSeen[useridentity.FieldCodeExtend]; !ok {
				selectedFields = append(selectedFields, useridentity.FieldCodeExtend)
				fieldSeen[useridentity.FieldCodeExtend] = struct{}{}
			}
		case "status":
			if _, ok := fieldSeen[useridentity.FieldStatus]; !ok {
				selectedFields = append(selectedFields, useridentity.FieldStatus)
				fieldSeen[useridentity.FieldStatus] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ui.Select(selectedFields...)
	}
	return nil
}

type useridentityPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []UserIdentityPaginateOption
}

func newUserIdentityPaginateArgs(rv map[string]any) *useridentityPaginateArgs {
	args := &useridentityPaginateArgs{}
	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      = &UserIdentityOrder{Field: &UserIdentityOrderField{}, 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, WithUserIdentityOrder(order))
			}
		case *UserIdentityOrder:
			if v != nil {
				args.opts = append(args.opts, WithUserIdentityOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*UserIdentityWhereInput); ok {
		args.opts = append(args.opts, WithUserIdentityFilter(v.Filter))
	}
	return args
}

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

func (ulp *UserLoginProfileQuery) 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(userloginprofile.Columns))
		selectedFields = []string{userloginprofile.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "user":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserClient{config: ulp.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, userImplementors)...); err != nil {
				return err
			}
			ulp.withUser = query
			if _, ok := fieldSeen[userloginprofile.FieldUserID]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldUserID)
				fieldSeen[userloginprofile.FieldUserID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[userloginprofile.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldCreatedBy)
				fieldSeen[userloginprofile.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[userloginprofile.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldCreatedAt)
				fieldSeen[userloginprofile.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[userloginprofile.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldUpdatedBy)
				fieldSeen[userloginprofile.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[userloginprofile.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldUpdatedAt)
				fieldSeen[userloginprofile.FieldUpdatedAt] = struct{}{}
			}
		case "userID":
			if _, ok := fieldSeen[userloginprofile.FieldUserID]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldUserID)
				fieldSeen[userloginprofile.FieldUserID] = struct{}{}
			}
		case "lastLoginIP":
			if _, ok := fieldSeen[userloginprofile.FieldLastLoginIP]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldLastLoginIP)
				fieldSeen[userloginprofile.FieldLastLoginIP] = struct{}{}
			}
		case "lastLoginAt":
			if _, ok := fieldSeen[userloginprofile.FieldLastLoginAt]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldLastLoginAt)
				fieldSeen[userloginprofile.FieldLastLoginAt] = struct{}{}
			}
		case "canLogin":
			if _, ok := fieldSeen[userloginprofile.FieldCanLogin]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldCanLogin)
				fieldSeen[userloginprofile.FieldCanLogin] = struct{}{}
			}
		case "setKind":
			if _, ok := fieldSeen[userloginprofile.FieldSetKind]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldSetKind)
				fieldSeen[userloginprofile.FieldSetKind] = struct{}{}
			}
		case "passwordReset":
			if _, ok := fieldSeen[userloginprofile.FieldPasswordReset]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldPasswordReset)
				fieldSeen[userloginprofile.FieldPasswordReset] = struct{}{}
			}
		case "verifyDevice":
			if _, ok := fieldSeen[userloginprofile.FieldVerifyDevice]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldVerifyDevice)
				fieldSeen[userloginprofile.FieldVerifyDevice] = struct{}{}
			}
		case "mfaEnabled":
			if _, ok := fieldSeen[userloginprofile.FieldMfaEnabled]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldMfaEnabled)
				fieldSeen[userloginprofile.FieldMfaEnabled] = struct{}{}
			}
		case "mfaStatus":
			if _, ok := fieldSeen[userloginprofile.FieldMfaStatus]; !ok {
				selectedFields = append(selectedFields, userloginprofile.FieldMfaStatus)
				fieldSeen[userloginprofile.FieldMfaStatus] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		ulp.Select(selectedFields...)
	}
	return nil
}

type userloginprofilePaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []UserLoginProfilePaginateOption
}

func newUserLoginProfilePaginateArgs(rv map[string]any) *userloginprofilePaginateArgs {
	args := &userloginprofilePaginateArgs{}
	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      = &UserLoginProfileOrder{Field: &UserLoginProfileOrderField{}, 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, WithUserLoginProfileOrder(order))
			}
		case *UserLoginProfileOrder:
			if v != nil {
				args.opts = append(args.opts, WithUserLoginProfileOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*UserLoginProfileWhereInput); ok {
		args.opts = append(args.opts, WithUserLoginProfileFilter(v.Filter))
	}
	return args
}

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

func (up *UserPasswordQuery) 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(userpassword.Columns))
		selectedFields = []string{userpassword.FieldID}
	)
	for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) {
		switch field.Name {
		case "user":
			var (
				alias = field.Alias
				path  = append(path, alias)
				query = (&UserClient{config: up.config}).Query()
			)
			if err := query.collectField(ctx, opCtx, field, path, mayAddCondition(satisfies, userImplementors)...); err != nil {
				return err
			}
			up.withUser = query
			if _, ok := fieldSeen[userpassword.FieldUserID]; !ok {
				selectedFields = append(selectedFields, userpassword.FieldUserID)
				fieldSeen[userpassword.FieldUserID] = struct{}{}
			}
		case "createdBy":
			if _, ok := fieldSeen[userpassword.FieldCreatedBy]; !ok {
				selectedFields = append(selectedFields, userpassword.FieldCreatedBy)
				fieldSeen[userpassword.FieldCreatedBy] = struct{}{}
			}
		case "createdAt":
			if _, ok := fieldSeen[userpassword.FieldCreatedAt]; !ok {
				selectedFields = append(selectedFields, userpassword.FieldCreatedAt)
				fieldSeen[userpassword.FieldCreatedAt] = struct{}{}
			}
		case "updatedBy":
			if _, ok := fieldSeen[userpassword.FieldUpdatedBy]; !ok {
				selectedFields = append(selectedFields, userpassword.FieldUpdatedBy)
				fieldSeen[userpassword.FieldUpdatedBy] = struct{}{}
			}
		case "updatedAt":
			if _, ok := fieldSeen[userpassword.FieldUpdatedAt]; !ok {
				selectedFields = append(selectedFields, userpassword.FieldUpdatedAt)
				fieldSeen[userpassword.FieldUpdatedAt] = struct{}{}
			}
		case "userID":
			if _, ok := fieldSeen[userpassword.FieldUserID]; !ok {
				selectedFields = append(selectedFields, userpassword.FieldUserID)
				fieldSeen[userpassword.FieldUserID] = struct{}{}
			}
		case "scene":
			if _, ok := fieldSeen[userpassword.FieldScene]; !ok {
				selectedFields = append(selectedFields, userpassword.FieldScene)
				fieldSeen[userpassword.FieldScene] = struct{}{}
			}
		case "status":
			if _, ok := fieldSeen[userpassword.FieldStatus]; !ok {
				selectedFields = append(selectedFields, userpassword.FieldStatus)
				fieldSeen[userpassword.FieldStatus] = struct{}{}
			}
		case "id":
		case "__typename":
		default:
			unknownSeen = true
		}
	}
	if !unknownSeen {
		up.Select(selectedFields...)
	}
	return nil
}

type userpasswordPaginateArgs struct {
	first, last   *int
	after, before *Cursor
	opts          []UserPasswordPaginateOption
}

func newUserPasswordPaginateArgs(rv map[string]any) *userpasswordPaginateArgs {
	args := &userpasswordPaginateArgs{}
	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      = &UserPasswordOrder{Field: &UserPasswordOrderField{}, 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, WithUserPasswordOrder(order))
			}
		case *UserPasswordOrder:
			if v != nil {
				args.opts = append(args.opts, WithUserPasswordOrder(v))
			}
		}
	}
	if v, ok := rv[whereField].(*UserPasswordWhereInput); ok {
		args.opts = append(args.opts, WithUserPasswordFilter(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(ctx context.Context, partitionBy string, limit int, first, last *int, orderBy ...sql.Querier) func(s *sql.Selector) {
	offset := 0
	if sp, ok := pagination.SimplePaginationFromContext(ctx); ok {
		if first != nil {
			offset = (sp.PageIndex - sp.CurrentIndex - 1) * *first
		}
		if last != nil {
			offset = (sp.CurrentIndex - sp.PageIndex - 1) * *last
		}
	}
	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())
		if offset != 0 {
			*s = *d.Select(s.UnqualifiedColumns()...).
				From(t).
				Where(sql.GT(t.C("row_number"), offset)).Limit(limit).
				Prefix(with)
		} else {
			*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 {
Cond:
	for _, c := range typeCond {
		for _, s := range satisfies {
			if c == s {
				continue Cond
			}
		}
		satisfies = append(satisfies, c)
	}
	return satisfies
}