gql_pagination.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"
	"io"
	"strconv"

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

// Common entgql types.
type (
	Cursor         = entgql.Cursor[int]
	PageInfo       = entgql.PageInfo[int]
	OrderDirection = entgql.OrderDirection
)

func orderFunc(o OrderDirection, field string) func(*sql.Selector) {
	if o == entgql.OrderDirectionDesc {
		return Desc(field)
	}
	return Asc(field)
}

const errInvalidPagination = "INVALID_PAGINATION"

func validateFirstLast(first, last *int) (err *gqlerror.Error) {
	switch {
	case first != nil && last != nil:
		err = &gqlerror.Error{
			Message: "Passing both `first` and `last` to paginate a connection is not supported.",
		}
	case first != nil && *first < 0:
		err = &gqlerror.Error{
			Message: "`first` on a connection cannot be less than zero.",
		}
		errcode.Set(err, errInvalidPagination)
	case last != nil && *last < 0:
		err = &gqlerror.Error{
			Message: "`last` on a connection cannot be less than zero.",
		}
		errcode.Set(err, errInvalidPagination)
	}
	return err
}

func collectedField(ctx context.Context, path ...string) *graphql.CollectedField {
	fc := graphql.GetFieldContext(ctx)
	if fc == nil {
		return nil
	}
	field := fc.Field
	oc := graphql.GetOperationContext(ctx)
walk:
	for _, name := range path {
		for _, f := range graphql.CollectFields(oc, field.Selections, nil) {
			if f.Alias == name {
				field = f
				continue walk
			}
		}
		return nil
	}
	return &field
}

func hasCollectedField(ctx context.Context, path ...string) bool {
	if graphql.GetFieldContext(ctx) == nil {
		return true
	}
	return collectedField(ctx, path...) != nil
}

const (
	edgesField      = "edges"
	nodeField       = "node"
	pageInfoField   = "pageInfo"
	totalCountField = "totalCount"
)

func paginateLimit(first, last *int) int {
	var limit int
	if first != nil {
		limit = *first + 1
	} else if last != nil {
		limit = *last + 1
	}
	return limit
}

// AbilityBonusEdge is the edge representation of AbilityBonus.
type AbilityBonusEdge struct {
	Node   *AbilityBonus `json:"node"`
	Cursor Cursor        `json:"cursor"`
}

// AbilityBonusConnection is the connection containing edges to AbilityBonus.
type AbilityBonusConnection struct {
	Edges      []*AbilityBonusEdge `json:"edges"`
	PageInfo   PageInfo            `json:"pageInfo"`
	TotalCount int                 `json:"totalCount"`
}

func (c *AbilityBonusConnection) build(nodes []*AbilityBonus, pager *abilitybonusPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *AbilityBonus
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *AbilityBonus {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *AbilityBonus {
			return nodes[i]
		}
	}
	c.Edges = make([]*AbilityBonusEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &AbilityBonusEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// AbilityBonusPaginateOption enables pagination customization.
type AbilityBonusPaginateOption func(*abilitybonusPager) error

// WithAbilityBonusOrder configures pagination ordering.
func WithAbilityBonusOrder(order *AbilityBonusOrder) AbilityBonusPaginateOption {
	if order == nil {
		order = DefaultAbilityBonusOrder
	}
	o := *order
	return func(pager *abilitybonusPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultAbilityBonusOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithAbilityBonusFilter configures pagination filter.
func WithAbilityBonusFilter(filter func(*AbilityBonusQuery) (*AbilityBonusQuery, error)) AbilityBonusPaginateOption {
	return func(pager *abilitybonusPager) error {
		if filter == nil {
			return errors.New("AbilityBonusQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type abilitybonusPager struct {
	reverse bool
	order   *AbilityBonusOrder
	filter  func(*AbilityBonusQuery) (*AbilityBonusQuery, error)
}

func newAbilityBonusPager(opts []AbilityBonusPaginateOption, reverse bool) (*abilitybonusPager, error) {
	pager := &abilitybonusPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultAbilityBonusOrder
	}
	return pager, nil
}

func (p *abilitybonusPager) applyFilter(query *AbilityBonusQuery) (*AbilityBonusQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *abilitybonusPager) toCursor(ab *AbilityBonus) Cursor {
	return p.order.Field.toCursor(ab)
}

func (p *abilitybonusPager) applyCursors(query *AbilityBonusQuery, after, before *Cursor) (*AbilityBonusQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultAbilityBonusOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *abilitybonusPager) applyOrder(query *AbilityBonusQuery) *AbilityBonusQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultAbilityBonusOrder.Field {
		query = query.Order(DefaultAbilityBonusOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *abilitybonusPager) orderExpr(query *AbilityBonusQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultAbilityBonusOrder.Field {
			b.Comma().Ident(DefaultAbilityBonusOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to AbilityBonus.
func (ab *AbilityBonusQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...AbilityBonusPaginateOption,
) (*AbilityBonusConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newAbilityBonusPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if ab, err = pager.applyFilter(ab); err != nil {
		return nil, err
	}
	conn := &AbilityBonusConnection{Edges: []*AbilityBonusEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = ab.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if ab, err = pager.applyCursors(ab, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		ab.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := ab.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	ab = pager.applyOrder(ab)
	nodes, err := ab.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// AbilityBonusOrderField defines the ordering field of AbilityBonus.
type AbilityBonusOrderField struct {
	// Value extracts the ordering value from the given AbilityBonus.
	Value    func(*AbilityBonus) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) abilitybonus.OrderOption
	toCursor func(*AbilityBonus) Cursor
}

// AbilityBonusOrder defines the ordering of AbilityBonus.
type AbilityBonusOrder struct {
	Direction OrderDirection          `json:"direction"`
	Field     *AbilityBonusOrderField `json:"field"`
}

// DefaultAbilityBonusOrder is the default ordering of AbilityBonus.
var DefaultAbilityBonusOrder = &AbilityBonusOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &AbilityBonusOrderField{
		Value: func(ab *AbilityBonus) (ent.Value, error) {
			return ab.ID, nil
		},
		column: abilitybonus.FieldID,
		toTerm: abilitybonus.ByID,
		toCursor: func(ab *AbilityBonus) Cursor {
			return Cursor{ID: ab.ID}
		},
	},
}

// ToEdge converts AbilityBonus into AbilityBonusEdge.
func (ab *AbilityBonus) ToEdge(order *AbilityBonusOrder) *AbilityBonusEdge {
	if order == nil {
		order = DefaultAbilityBonusOrder
	}
	return &AbilityBonusEdge{
		Node:   ab,
		Cursor: order.Field.toCursor(ab),
	}
}

// AbilityScoreEdge is the edge representation of AbilityScore.
type AbilityScoreEdge struct {
	Node   *AbilityScore `json:"node"`
	Cursor Cursor        `json:"cursor"`
}

// AbilityScoreConnection is the connection containing edges to AbilityScore.
type AbilityScoreConnection struct {
	Edges      []*AbilityScoreEdge `json:"edges"`
	PageInfo   PageInfo            `json:"pageInfo"`
	TotalCount int                 `json:"totalCount"`
}

func (c *AbilityScoreConnection) build(nodes []*AbilityScore, pager *abilityscorePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *AbilityScore
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *AbilityScore {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *AbilityScore {
			return nodes[i]
		}
	}
	c.Edges = make([]*AbilityScoreEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &AbilityScoreEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// AbilityScorePaginateOption enables pagination customization.
type AbilityScorePaginateOption func(*abilityscorePager) error

// WithAbilityScoreOrder configures pagination ordering.
func WithAbilityScoreOrder(order *AbilityScoreOrder) AbilityScorePaginateOption {
	if order == nil {
		order = DefaultAbilityScoreOrder
	}
	o := *order
	return func(pager *abilityscorePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultAbilityScoreOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithAbilityScoreFilter configures pagination filter.
func WithAbilityScoreFilter(filter func(*AbilityScoreQuery) (*AbilityScoreQuery, error)) AbilityScorePaginateOption {
	return func(pager *abilityscorePager) error {
		if filter == nil {
			return errors.New("AbilityScoreQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type abilityscorePager struct {
	reverse bool
	order   *AbilityScoreOrder
	filter  func(*AbilityScoreQuery) (*AbilityScoreQuery, error)
}

func newAbilityScorePager(opts []AbilityScorePaginateOption, reverse bool) (*abilityscorePager, error) {
	pager := &abilityscorePager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultAbilityScoreOrder
	}
	return pager, nil
}

func (p *abilityscorePager) applyFilter(query *AbilityScoreQuery) (*AbilityScoreQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *abilityscorePager) toCursor(as *AbilityScore) Cursor {
	return p.order.Field.toCursor(as)
}

func (p *abilityscorePager) applyCursors(query *AbilityScoreQuery, after, before *Cursor) (*AbilityScoreQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultAbilityScoreOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *abilityscorePager) applyOrder(query *AbilityScoreQuery) *AbilityScoreQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultAbilityScoreOrder.Field {
		query = query.Order(DefaultAbilityScoreOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *abilityscorePager) orderExpr(query *AbilityScoreQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultAbilityScoreOrder.Field {
			b.Comma().Ident(DefaultAbilityScoreOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to AbilityScore.
func (as *AbilityScoreQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...AbilityScorePaginateOption,
) (*AbilityScoreConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newAbilityScorePager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if as, err = pager.applyFilter(as); err != nil {
		return nil, err
	}
	conn := &AbilityScoreConnection{Edges: []*AbilityScoreEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = as.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if as, err = pager.applyCursors(as, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		as.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := as.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	as = pager.applyOrder(as)
	nodes, err := as.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// AbilityScoreOrderFieldIndx orders AbilityScore by indx.
	AbilityScoreOrderFieldIndx = &AbilityScoreOrderField{
		Value: func(as *AbilityScore) (ent.Value, error) {
			return as.Indx, nil
		},
		column: abilityscore.FieldIndx,
		toTerm: abilityscore.ByIndx,
		toCursor: func(as *AbilityScore) Cursor {
			return Cursor{
				ID:    as.ID,
				Value: as.Indx,
			}
		},
	}
	// AbilityScoreOrderFieldName orders AbilityScore by name.
	AbilityScoreOrderFieldName = &AbilityScoreOrderField{
		Value: func(as *AbilityScore) (ent.Value, error) {
			return as.Name, nil
		},
		column: abilityscore.FieldName,
		toTerm: abilityscore.ByName,
		toCursor: func(as *AbilityScore) Cursor {
			return Cursor{
				ID:    as.ID,
				Value: as.Name,
			}
		},
	}
	// AbilityScoreOrderFieldFullName orders AbilityScore by full_name.
	AbilityScoreOrderFieldFullName = &AbilityScoreOrderField{
		Value: func(as *AbilityScore) (ent.Value, error) {
			return as.FullName, nil
		},
		column: abilityscore.FieldFullName,
		toTerm: abilityscore.ByFullName,
		toCursor: func(as *AbilityScore) Cursor {
			return Cursor{
				ID:    as.ID,
				Value: as.FullName,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f AbilityScoreOrderField) String() string {
	var str string
	switch f.column {
	case AbilityScoreOrderFieldIndx.column:
		str = "INDX"
	case AbilityScoreOrderFieldName.column:
		str = "NAME"
	case AbilityScoreOrderFieldFullName.column:
		str = "FULL_NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f AbilityScoreOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *AbilityScoreOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("AbilityScoreOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *AbilityScoreOrderFieldIndx
	case "NAME":
		*f = *AbilityScoreOrderFieldName
	case "FULL_NAME":
		*f = *AbilityScoreOrderFieldFullName
	default:
		return fmt.Errorf("%s is not a valid AbilityScoreOrderField", str)
	}
	return nil
}

// AbilityScoreOrderField defines the ordering field of AbilityScore.
type AbilityScoreOrderField struct {
	// Value extracts the ordering value from the given AbilityScore.
	Value    func(*AbilityScore) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) abilityscore.OrderOption
	toCursor func(*AbilityScore) Cursor
}

// AbilityScoreOrder defines the ordering of AbilityScore.
type AbilityScoreOrder struct {
	Direction OrderDirection          `json:"direction"`
	Field     *AbilityScoreOrderField `json:"field"`
}

// DefaultAbilityScoreOrder is the default ordering of AbilityScore.
var DefaultAbilityScoreOrder = &AbilityScoreOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &AbilityScoreOrderField{
		Value: func(as *AbilityScore) (ent.Value, error) {
			return as.ID, nil
		},
		column: abilityscore.FieldID,
		toTerm: abilityscore.ByID,
		toCursor: func(as *AbilityScore) Cursor {
			return Cursor{ID: as.ID}
		},
	},
}

// ToEdge converts AbilityScore into AbilityScoreEdge.
func (as *AbilityScore) ToEdge(order *AbilityScoreOrder) *AbilityScoreEdge {
	if order == nil {
		order = DefaultAbilityScoreOrder
	}
	return &AbilityScoreEdge{
		Node:   as,
		Cursor: order.Field.toCursor(as),
	}
}

// ArmorEdge is the edge representation of Armor.
type ArmorEdge struct {
	Node   *Armor `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// ArmorConnection is the connection containing edges to Armor.
type ArmorConnection struct {
	Edges      []*ArmorEdge `json:"edges"`
	PageInfo   PageInfo     `json:"pageInfo"`
	TotalCount int          `json:"totalCount"`
}

func (c *ArmorConnection) build(nodes []*Armor, pager *armorPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Armor
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Armor {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Armor {
			return nodes[i]
		}
	}
	c.Edges = make([]*ArmorEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &ArmorEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// ArmorPaginateOption enables pagination customization.
type ArmorPaginateOption func(*armorPager) error

// WithArmorOrder configures pagination ordering.
func WithArmorOrder(order *ArmorOrder) ArmorPaginateOption {
	if order == nil {
		order = DefaultArmorOrder
	}
	o := *order
	return func(pager *armorPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultArmorOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithArmorFilter configures pagination filter.
func WithArmorFilter(filter func(*ArmorQuery) (*ArmorQuery, error)) ArmorPaginateOption {
	return func(pager *armorPager) error {
		if filter == nil {
			return errors.New("ArmorQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type armorPager struct {
	reverse bool
	order   *ArmorOrder
	filter  func(*ArmorQuery) (*ArmorQuery, error)
}

func newArmorPager(opts []ArmorPaginateOption, reverse bool) (*armorPager, error) {
	pager := &armorPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultArmorOrder
	}
	return pager, nil
}

func (p *armorPager) applyFilter(query *ArmorQuery) (*ArmorQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *armorPager) toCursor(a *Armor) Cursor {
	return p.order.Field.toCursor(a)
}

func (p *armorPager) applyCursors(query *ArmorQuery, after, before *Cursor) (*ArmorQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultArmorOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *armorPager) applyOrder(query *ArmorQuery) *ArmorQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultArmorOrder.Field {
		query = query.Order(DefaultArmorOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *armorPager) orderExpr(query *ArmorQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultArmorOrder.Field {
			b.Comma().Ident(DefaultArmorOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Armor.
func (a *ArmorQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...ArmorPaginateOption,
) (*ArmorConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newArmorPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if a, err = pager.applyFilter(a); err != nil {
		return nil, err
	}
	conn := &ArmorConnection{Edges: []*ArmorEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = a.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if a, err = pager.applyCursors(a, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		a.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := a.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	a = pager.applyOrder(a)
	nodes, err := a.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// ArmorOrderFieldIndx orders Armor by indx.
	ArmorOrderFieldIndx = &ArmorOrderField{
		Value: func(a *Armor) (ent.Value, error) {
			return a.Indx, nil
		},
		column: armor.FieldIndx,
		toTerm: armor.ByIndx,
		toCursor: func(a *Armor) Cursor {
			return Cursor{
				ID:    a.ID,
				Value: a.Indx,
			}
		},
	}
	// ArmorOrderFieldName orders Armor by name.
	ArmorOrderFieldName = &ArmorOrderField{
		Value: func(a *Armor) (ent.Value, error) {
			return a.Name, nil
		},
		column: armor.FieldName,
		toTerm: armor.ByName,
		toCursor: func(a *Armor) Cursor {
			return Cursor{
				ID:    a.ID,
				Value: a.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f ArmorOrderField) String() string {
	var str string
	switch f.column {
	case ArmorOrderFieldIndx.column:
		str = "INDX"
	case ArmorOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f ArmorOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *ArmorOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("ArmorOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *ArmorOrderFieldIndx
	case "NAME":
		*f = *ArmorOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid ArmorOrderField", str)
	}
	return nil
}

// ArmorOrderField defines the ordering field of Armor.
type ArmorOrderField struct {
	// Value extracts the ordering value from the given Armor.
	Value    func(*Armor) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) armor.OrderOption
	toCursor func(*Armor) Cursor
}

// ArmorOrder defines the ordering of Armor.
type ArmorOrder struct {
	Direction OrderDirection   `json:"direction"`
	Field     *ArmorOrderField `json:"field"`
}

// DefaultArmorOrder is the default ordering of Armor.
var DefaultArmorOrder = &ArmorOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &ArmorOrderField{
		Value: func(a *Armor) (ent.Value, error) {
			return a.ID, nil
		},
		column: armor.FieldID,
		toTerm: armor.ByID,
		toCursor: func(a *Armor) Cursor {
			return Cursor{ID: a.ID}
		},
	},
}

// ToEdge converts Armor into ArmorEdge.
func (a *Armor) ToEdge(order *ArmorOrder) *ArmorEdge {
	if order == nil {
		order = DefaultArmorOrder
	}
	return &ArmorEdge{
		Node:   a,
		Cursor: order.Field.toCursor(a),
	}
}

// ArmorClassEdge is the edge representation of ArmorClass.
type ArmorClassEdge struct {
	Node   *ArmorClass `json:"node"`
	Cursor Cursor      `json:"cursor"`
}

// ArmorClassConnection is the connection containing edges to ArmorClass.
type ArmorClassConnection struct {
	Edges      []*ArmorClassEdge `json:"edges"`
	PageInfo   PageInfo          `json:"pageInfo"`
	TotalCount int               `json:"totalCount"`
}

func (c *ArmorClassConnection) build(nodes []*ArmorClass, pager *armorclassPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *ArmorClass
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *ArmorClass {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *ArmorClass {
			return nodes[i]
		}
	}
	c.Edges = make([]*ArmorClassEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &ArmorClassEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// ArmorClassPaginateOption enables pagination customization.
type ArmorClassPaginateOption func(*armorclassPager) error

// WithArmorClassOrder configures pagination ordering.
func WithArmorClassOrder(order *ArmorClassOrder) ArmorClassPaginateOption {
	if order == nil {
		order = DefaultArmorClassOrder
	}
	o := *order
	return func(pager *armorclassPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultArmorClassOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithArmorClassFilter configures pagination filter.
func WithArmorClassFilter(filter func(*ArmorClassQuery) (*ArmorClassQuery, error)) ArmorClassPaginateOption {
	return func(pager *armorclassPager) error {
		if filter == nil {
			return errors.New("ArmorClassQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type armorclassPager struct {
	reverse bool
	order   *ArmorClassOrder
	filter  func(*ArmorClassQuery) (*ArmorClassQuery, error)
}

func newArmorClassPager(opts []ArmorClassPaginateOption, reverse bool) (*armorclassPager, error) {
	pager := &armorclassPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultArmorClassOrder
	}
	return pager, nil
}

func (p *armorclassPager) applyFilter(query *ArmorClassQuery) (*ArmorClassQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *armorclassPager) toCursor(ac *ArmorClass) Cursor {
	return p.order.Field.toCursor(ac)
}

func (p *armorclassPager) applyCursors(query *ArmorClassQuery, after, before *Cursor) (*ArmorClassQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultArmorClassOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *armorclassPager) applyOrder(query *ArmorClassQuery) *ArmorClassQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultArmorClassOrder.Field {
		query = query.Order(DefaultArmorClassOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *armorclassPager) orderExpr(query *ArmorClassQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultArmorClassOrder.Field {
			b.Comma().Ident(DefaultArmorClassOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to ArmorClass.
func (ac *ArmorClassQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...ArmorClassPaginateOption,
) (*ArmorClassConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newArmorClassPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if ac, err = pager.applyFilter(ac); err != nil {
		return nil, err
	}
	conn := &ArmorClassConnection{Edges: []*ArmorClassEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = ac.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if ac, err = pager.applyCursors(ac, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		ac.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := ac.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	ac = pager.applyOrder(ac)
	nodes, err := ac.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// ArmorClassOrderField defines the ordering field of ArmorClass.
type ArmorClassOrderField struct {
	// Value extracts the ordering value from the given ArmorClass.
	Value    func(*ArmorClass) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) armorclass.OrderOption
	toCursor func(*ArmorClass) Cursor
}

// ArmorClassOrder defines the ordering of ArmorClass.
type ArmorClassOrder struct {
	Direction OrderDirection        `json:"direction"`
	Field     *ArmorClassOrderField `json:"field"`
}

// DefaultArmorClassOrder is the default ordering of ArmorClass.
var DefaultArmorClassOrder = &ArmorClassOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &ArmorClassOrderField{
		Value: func(ac *ArmorClass) (ent.Value, error) {
			return ac.ID, nil
		},
		column: armorclass.FieldID,
		toTerm: armorclass.ByID,
		toCursor: func(ac *ArmorClass) Cursor {
			return Cursor{ID: ac.ID}
		},
	},
}

// ToEdge converts ArmorClass into ArmorClassEdge.
func (ac *ArmorClass) ToEdge(order *ArmorClassOrder) *ArmorClassEdge {
	if order == nil {
		order = DefaultArmorClassOrder
	}
	return &ArmorClassEdge{
		Node:   ac,
		Cursor: order.Field.toCursor(ac),
	}
}

// ClassEdge is the edge representation of Class.
type ClassEdge struct {
	Node   *Class `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// ClassConnection is the connection containing edges to Class.
type ClassConnection struct {
	Edges      []*ClassEdge `json:"edges"`
	PageInfo   PageInfo     `json:"pageInfo"`
	TotalCount int          `json:"totalCount"`
}

func (c *ClassConnection) build(nodes []*Class, pager *classPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Class
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Class {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Class {
			return nodes[i]
		}
	}
	c.Edges = make([]*ClassEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &ClassEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// ClassPaginateOption enables pagination customization.
type ClassPaginateOption func(*classPager) error

// WithClassOrder configures pagination ordering.
func WithClassOrder(order *ClassOrder) ClassPaginateOption {
	if order == nil {
		order = DefaultClassOrder
	}
	o := *order
	return func(pager *classPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultClassOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithClassFilter configures pagination filter.
func WithClassFilter(filter func(*ClassQuery) (*ClassQuery, error)) ClassPaginateOption {
	return func(pager *classPager) error {
		if filter == nil {
			return errors.New("ClassQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type classPager struct {
	reverse bool
	order   *ClassOrder
	filter  func(*ClassQuery) (*ClassQuery, error)
}

func newClassPager(opts []ClassPaginateOption, reverse bool) (*classPager, error) {
	pager := &classPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultClassOrder
	}
	return pager, nil
}

func (p *classPager) applyFilter(query *ClassQuery) (*ClassQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *classPager) toCursor(c *Class) Cursor {
	return p.order.Field.toCursor(c)
}

func (p *classPager) applyCursors(query *ClassQuery, after, before *Cursor) (*ClassQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultClassOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *classPager) applyOrder(query *ClassQuery) *ClassQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultClassOrder.Field {
		query = query.Order(DefaultClassOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *classPager) orderExpr(query *ClassQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultClassOrder.Field {
			b.Comma().Ident(DefaultClassOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Class.
func (c *ClassQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...ClassPaginateOption,
) (*ClassConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newClassPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if c, err = pager.applyFilter(c); err != nil {
		return nil, err
	}
	conn := &ClassConnection{Edges: []*ClassEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = c.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if c, err = pager.applyCursors(c, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		c.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := c.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	c = pager.applyOrder(c)
	nodes, err := c.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// ClassOrderFieldIndx orders Class by indx.
	ClassOrderFieldIndx = &ClassOrderField{
		Value: func(c *Class) (ent.Value, error) {
			return c.Indx, nil
		},
		column: class.FieldIndx,
		toTerm: class.ByIndx,
		toCursor: func(c *Class) Cursor {
			return Cursor{
				ID:    c.ID,
				Value: c.Indx,
			}
		},
	}
	// ClassOrderFieldName orders Class by name.
	ClassOrderFieldName = &ClassOrderField{
		Value: func(c *Class) (ent.Value, error) {
			return c.Name, nil
		},
		column: class.FieldName,
		toTerm: class.ByName,
		toCursor: func(c *Class) Cursor {
			return Cursor{
				ID:    c.ID,
				Value: c.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f ClassOrderField) String() string {
	var str string
	switch f.column {
	case ClassOrderFieldIndx.column:
		str = "INDX"
	case ClassOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f ClassOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *ClassOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("ClassOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *ClassOrderFieldIndx
	case "NAME":
		*f = *ClassOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid ClassOrderField", str)
	}
	return nil
}

// ClassOrderField defines the ordering field of Class.
type ClassOrderField struct {
	// Value extracts the ordering value from the given Class.
	Value    func(*Class) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) class.OrderOption
	toCursor func(*Class) Cursor
}

// ClassOrder defines the ordering of Class.
type ClassOrder struct {
	Direction OrderDirection   `json:"direction"`
	Field     *ClassOrderField `json:"field"`
}

// DefaultClassOrder is the default ordering of Class.
var DefaultClassOrder = &ClassOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &ClassOrderField{
		Value: func(c *Class) (ent.Value, error) {
			return c.ID, nil
		},
		column: class.FieldID,
		toTerm: class.ByID,
		toCursor: func(c *Class) Cursor {
			return Cursor{ID: c.ID}
		},
	},
}

// ToEdge converts Class into ClassEdge.
func (c *Class) ToEdge(order *ClassOrder) *ClassEdge {
	if order == nil {
		order = DefaultClassOrder
	}
	return &ClassEdge{
		Node:   c,
		Cursor: order.Field.toCursor(c),
	}
}

// CoinEdge is the edge representation of Coin.
type CoinEdge struct {
	Node   *Coin  `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// CoinConnection is the connection containing edges to Coin.
type CoinConnection struct {
	Edges      []*CoinEdge `json:"edges"`
	PageInfo   PageInfo    `json:"pageInfo"`
	TotalCount int         `json:"totalCount"`
}

func (c *CoinConnection) build(nodes []*Coin, pager *coinPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Coin
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Coin {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Coin {
			return nodes[i]
		}
	}
	c.Edges = make([]*CoinEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &CoinEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// CoinPaginateOption enables pagination customization.
type CoinPaginateOption func(*coinPager) error

// WithCoinOrder configures pagination ordering.
func WithCoinOrder(order *CoinOrder) CoinPaginateOption {
	if order == nil {
		order = DefaultCoinOrder
	}
	o := *order
	return func(pager *coinPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultCoinOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithCoinFilter configures pagination filter.
func WithCoinFilter(filter func(*CoinQuery) (*CoinQuery, error)) CoinPaginateOption {
	return func(pager *coinPager) error {
		if filter == nil {
			return errors.New("CoinQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type coinPager struct {
	reverse bool
	order   *CoinOrder
	filter  func(*CoinQuery) (*CoinQuery, error)
}

func newCoinPager(opts []CoinPaginateOption, reverse bool) (*coinPager, error) {
	pager := &coinPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultCoinOrder
	}
	return pager, nil
}

func (p *coinPager) applyFilter(query *CoinQuery) (*CoinQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *coinPager) toCursor(c *Coin) Cursor {
	return p.order.Field.toCursor(c)
}

func (p *coinPager) applyCursors(query *CoinQuery, after, before *Cursor) (*CoinQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultCoinOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *coinPager) applyOrder(query *CoinQuery) *CoinQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultCoinOrder.Field {
		query = query.Order(DefaultCoinOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *coinPager) orderExpr(query *CoinQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultCoinOrder.Field {
			b.Comma().Ident(DefaultCoinOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Coin.
func (c *CoinQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...CoinPaginateOption,
) (*CoinConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newCoinPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if c, err = pager.applyFilter(c); err != nil {
		return nil, err
	}
	conn := &CoinConnection{Edges: []*CoinEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = c.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if c, err = pager.applyCursors(c, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		c.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := c.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	c = pager.applyOrder(c)
	nodes, err := c.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// CoinOrderField defines the ordering field of Coin.
type CoinOrderField struct {
	// Value extracts the ordering value from the given Coin.
	Value    func(*Coin) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) coin.OrderOption
	toCursor func(*Coin) Cursor
}

// CoinOrder defines the ordering of Coin.
type CoinOrder struct {
	Direction OrderDirection  `json:"direction"`
	Field     *CoinOrderField `json:"field"`
}

// DefaultCoinOrder is the default ordering of Coin.
var DefaultCoinOrder = &CoinOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &CoinOrderField{
		Value: func(c *Coin) (ent.Value, error) {
			return c.ID, nil
		},
		column: coin.FieldID,
		toTerm: coin.ByID,
		toCursor: func(c *Coin) Cursor {
			return Cursor{ID: c.ID}
		},
	},
}

// ToEdge converts Coin into CoinEdge.
func (c *Coin) ToEdge(order *CoinOrder) *CoinEdge {
	if order == nil {
		order = DefaultCoinOrder
	}
	return &CoinEdge{
		Node:   c,
		Cursor: order.Field.toCursor(c),
	}
}

// DamageTypeEdge is the edge representation of DamageType.
type DamageTypeEdge struct {
	Node   *DamageType `json:"node"`
	Cursor Cursor      `json:"cursor"`
}

// DamageTypeConnection is the connection containing edges to DamageType.
type DamageTypeConnection struct {
	Edges      []*DamageTypeEdge `json:"edges"`
	PageInfo   PageInfo          `json:"pageInfo"`
	TotalCount int               `json:"totalCount"`
}

func (c *DamageTypeConnection) build(nodes []*DamageType, pager *damagetypePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *DamageType
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *DamageType {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *DamageType {
			return nodes[i]
		}
	}
	c.Edges = make([]*DamageTypeEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &DamageTypeEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// DamageTypePaginateOption enables pagination customization.
type DamageTypePaginateOption func(*damagetypePager) error

// WithDamageTypeOrder configures pagination ordering.
func WithDamageTypeOrder(order *DamageTypeOrder) DamageTypePaginateOption {
	if order == nil {
		order = DefaultDamageTypeOrder
	}
	o := *order
	return func(pager *damagetypePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultDamageTypeOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithDamageTypeFilter configures pagination filter.
func WithDamageTypeFilter(filter func(*DamageTypeQuery) (*DamageTypeQuery, error)) DamageTypePaginateOption {
	return func(pager *damagetypePager) error {
		if filter == nil {
			return errors.New("DamageTypeQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type damagetypePager struct {
	reverse bool
	order   *DamageTypeOrder
	filter  func(*DamageTypeQuery) (*DamageTypeQuery, error)
}

func newDamageTypePager(opts []DamageTypePaginateOption, reverse bool) (*damagetypePager, error) {
	pager := &damagetypePager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultDamageTypeOrder
	}
	return pager, nil
}

func (p *damagetypePager) applyFilter(query *DamageTypeQuery) (*DamageTypeQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *damagetypePager) toCursor(dt *DamageType) Cursor {
	return p.order.Field.toCursor(dt)
}

func (p *damagetypePager) applyCursors(query *DamageTypeQuery, after, before *Cursor) (*DamageTypeQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultDamageTypeOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *damagetypePager) applyOrder(query *DamageTypeQuery) *DamageTypeQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultDamageTypeOrder.Field {
		query = query.Order(DefaultDamageTypeOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *damagetypePager) orderExpr(query *DamageTypeQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultDamageTypeOrder.Field {
			b.Comma().Ident(DefaultDamageTypeOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to DamageType.
func (dt *DamageTypeQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...DamageTypePaginateOption,
) (*DamageTypeConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newDamageTypePager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if dt, err = pager.applyFilter(dt); err != nil {
		return nil, err
	}
	conn := &DamageTypeConnection{Edges: []*DamageTypeEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = dt.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if dt, err = pager.applyCursors(dt, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		dt.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := dt.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	dt = pager.applyOrder(dt)
	nodes, err := dt.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// DamageTypeOrderFieldIndx orders DamageType by indx.
	DamageTypeOrderFieldIndx = &DamageTypeOrderField{
		Value: func(dt *DamageType) (ent.Value, error) {
			return dt.Indx, nil
		},
		column: damagetype.FieldIndx,
		toTerm: damagetype.ByIndx,
		toCursor: func(dt *DamageType) Cursor {
			return Cursor{
				ID:    dt.ID,
				Value: dt.Indx,
			}
		},
	}
	// DamageTypeOrderFieldName orders DamageType by name.
	DamageTypeOrderFieldName = &DamageTypeOrderField{
		Value: func(dt *DamageType) (ent.Value, error) {
			return dt.Name, nil
		},
		column: damagetype.FieldName,
		toTerm: damagetype.ByName,
		toCursor: func(dt *DamageType) Cursor {
			return Cursor{
				ID:    dt.ID,
				Value: dt.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f DamageTypeOrderField) String() string {
	var str string
	switch f.column {
	case DamageTypeOrderFieldIndx.column:
		str = "INDX"
	case DamageTypeOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f DamageTypeOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *DamageTypeOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("DamageTypeOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *DamageTypeOrderFieldIndx
	case "NAME":
		*f = *DamageTypeOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid DamageTypeOrderField", str)
	}
	return nil
}

// DamageTypeOrderField defines the ordering field of DamageType.
type DamageTypeOrderField struct {
	// Value extracts the ordering value from the given DamageType.
	Value    func(*DamageType) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) damagetype.OrderOption
	toCursor func(*DamageType) Cursor
}

// DamageTypeOrder defines the ordering of DamageType.
type DamageTypeOrder struct {
	Direction OrderDirection        `json:"direction"`
	Field     *DamageTypeOrderField `json:"field"`
}

// DefaultDamageTypeOrder is the default ordering of DamageType.
var DefaultDamageTypeOrder = &DamageTypeOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &DamageTypeOrderField{
		Value: func(dt *DamageType) (ent.Value, error) {
			return dt.ID, nil
		},
		column: damagetype.FieldID,
		toTerm: damagetype.ByID,
		toCursor: func(dt *DamageType) Cursor {
			return Cursor{ID: dt.ID}
		},
	},
}

// ToEdge converts DamageType into DamageTypeEdge.
func (dt *DamageType) ToEdge(order *DamageTypeOrder) *DamageTypeEdge {
	if order == nil {
		order = DefaultDamageTypeOrder
	}
	return &DamageTypeEdge{
		Node:   dt,
		Cursor: order.Field.toCursor(dt),
	}
}

// EquipmentEdge is the edge representation of Equipment.
type EquipmentEdge struct {
	Node   *Equipment `json:"node"`
	Cursor Cursor     `json:"cursor"`
}

// EquipmentConnection is the connection containing edges to Equipment.
type EquipmentConnection struct {
	Edges      []*EquipmentEdge `json:"edges"`
	PageInfo   PageInfo         `json:"pageInfo"`
	TotalCount int              `json:"totalCount"`
}

func (c *EquipmentConnection) build(nodes []*Equipment, pager *equipmentPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Equipment
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Equipment {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Equipment {
			return nodes[i]
		}
	}
	c.Edges = make([]*EquipmentEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &EquipmentEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// EquipmentPaginateOption enables pagination customization.
type EquipmentPaginateOption func(*equipmentPager) error

// WithEquipmentOrder configures pagination ordering.
func WithEquipmentOrder(order *EquipmentOrder) EquipmentPaginateOption {
	if order == nil {
		order = DefaultEquipmentOrder
	}
	o := *order
	return func(pager *equipmentPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultEquipmentOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithEquipmentFilter configures pagination filter.
func WithEquipmentFilter(filter func(*EquipmentQuery) (*EquipmentQuery, error)) EquipmentPaginateOption {
	return func(pager *equipmentPager) error {
		if filter == nil {
			return errors.New("EquipmentQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type equipmentPager struct {
	reverse bool
	order   *EquipmentOrder
	filter  func(*EquipmentQuery) (*EquipmentQuery, error)
}

func newEquipmentPager(opts []EquipmentPaginateOption, reverse bool) (*equipmentPager, error) {
	pager := &equipmentPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultEquipmentOrder
	}
	return pager, nil
}

func (p *equipmentPager) applyFilter(query *EquipmentQuery) (*EquipmentQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *equipmentPager) toCursor(e *Equipment) Cursor {
	return p.order.Field.toCursor(e)
}

func (p *equipmentPager) applyCursors(query *EquipmentQuery, after, before *Cursor) (*EquipmentQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultEquipmentOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *equipmentPager) applyOrder(query *EquipmentQuery) *EquipmentQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultEquipmentOrder.Field {
		query = query.Order(DefaultEquipmentOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *equipmentPager) orderExpr(query *EquipmentQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultEquipmentOrder.Field {
			b.Comma().Ident(DefaultEquipmentOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Equipment.
func (e *EquipmentQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...EquipmentPaginateOption,
) (*EquipmentConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newEquipmentPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if e, err = pager.applyFilter(e); err != nil {
		return nil, err
	}
	conn := &EquipmentConnection{Edges: []*EquipmentEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = e.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if e, err = pager.applyCursors(e, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		e.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := e.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	e = pager.applyOrder(e)
	nodes, err := e.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// EquipmentOrderFieldIndx orders Equipment by indx.
	EquipmentOrderFieldIndx = &EquipmentOrderField{
		Value: func(e *Equipment) (ent.Value, error) {
			return e.Indx, nil
		},
		column: equipment.FieldIndx,
		toTerm: equipment.ByIndx,
		toCursor: func(e *Equipment) Cursor {
			return Cursor{
				ID:    e.ID,
				Value: e.Indx,
			}
		},
	}
	// EquipmentOrderFieldName orders Equipment by name.
	EquipmentOrderFieldName = &EquipmentOrderField{
		Value: func(e *Equipment) (ent.Value, error) {
			return e.Name, nil
		},
		column: equipment.FieldName,
		toTerm: equipment.ByName,
		toCursor: func(e *Equipment) Cursor {
			return Cursor{
				ID:    e.ID,
				Value: e.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f EquipmentOrderField) String() string {
	var str string
	switch f.column {
	case EquipmentOrderFieldIndx.column:
		str = "INDX"
	case EquipmentOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f EquipmentOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *EquipmentOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("EquipmentOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *EquipmentOrderFieldIndx
	case "NAME":
		*f = *EquipmentOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid EquipmentOrderField", str)
	}
	return nil
}

// EquipmentOrderField defines the ordering field of Equipment.
type EquipmentOrderField struct {
	// Value extracts the ordering value from the given Equipment.
	Value    func(*Equipment) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) equipment.OrderOption
	toCursor func(*Equipment) Cursor
}

// EquipmentOrder defines the ordering of Equipment.
type EquipmentOrder struct {
	Direction OrderDirection       `json:"direction"`
	Field     *EquipmentOrderField `json:"field"`
}

// DefaultEquipmentOrder is the default ordering of Equipment.
var DefaultEquipmentOrder = &EquipmentOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &EquipmentOrderField{
		Value: func(e *Equipment) (ent.Value, error) {
			return e.ID, nil
		},
		column: equipment.FieldID,
		toTerm: equipment.ByID,
		toCursor: func(e *Equipment) Cursor {
			return Cursor{ID: e.ID}
		},
	},
}

// ToEdge converts Equipment into EquipmentEdge.
func (e *Equipment) ToEdge(order *EquipmentOrder) *EquipmentEdge {
	if order == nil {
		order = DefaultEquipmentOrder
	}
	return &EquipmentEdge{
		Node:   e,
		Cursor: order.Field.toCursor(e),
	}
}

// EquipmentCategoryEdge is the edge representation of EquipmentCategory.
type EquipmentCategoryEdge struct {
	Node   *EquipmentCategory `json:"node"`
	Cursor Cursor             `json:"cursor"`
}

// EquipmentCategoryConnection is the connection containing edges to EquipmentCategory.
type EquipmentCategoryConnection struct {
	Edges      []*EquipmentCategoryEdge `json:"edges"`
	PageInfo   PageInfo                 `json:"pageInfo"`
	TotalCount int                      `json:"totalCount"`
}

func (c *EquipmentCategoryConnection) build(nodes []*EquipmentCategory, pager *equipmentcategoryPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *EquipmentCategory
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *EquipmentCategory {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *EquipmentCategory {
			return nodes[i]
		}
	}
	c.Edges = make([]*EquipmentCategoryEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &EquipmentCategoryEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// EquipmentCategoryPaginateOption enables pagination customization.
type EquipmentCategoryPaginateOption func(*equipmentcategoryPager) error

// WithEquipmentCategoryOrder configures pagination ordering.
func WithEquipmentCategoryOrder(order *EquipmentCategoryOrder) EquipmentCategoryPaginateOption {
	if order == nil {
		order = DefaultEquipmentCategoryOrder
	}
	o := *order
	return func(pager *equipmentcategoryPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultEquipmentCategoryOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithEquipmentCategoryFilter configures pagination filter.
func WithEquipmentCategoryFilter(filter func(*EquipmentCategoryQuery) (*EquipmentCategoryQuery, error)) EquipmentCategoryPaginateOption {
	return func(pager *equipmentcategoryPager) error {
		if filter == nil {
			return errors.New("EquipmentCategoryQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type equipmentcategoryPager struct {
	reverse bool
	order   *EquipmentCategoryOrder
	filter  func(*EquipmentCategoryQuery) (*EquipmentCategoryQuery, error)
}

func newEquipmentCategoryPager(opts []EquipmentCategoryPaginateOption, reverse bool) (*equipmentcategoryPager, error) {
	pager := &equipmentcategoryPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultEquipmentCategoryOrder
	}
	return pager, nil
}

func (p *equipmentcategoryPager) applyFilter(query *EquipmentCategoryQuery) (*EquipmentCategoryQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *equipmentcategoryPager) toCursor(ec *EquipmentCategory) Cursor {
	return p.order.Field.toCursor(ec)
}

func (p *equipmentcategoryPager) applyCursors(query *EquipmentCategoryQuery, after, before *Cursor) (*EquipmentCategoryQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultEquipmentCategoryOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *equipmentcategoryPager) applyOrder(query *EquipmentCategoryQuery) *EquipmentCategoryQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultEquipmentCategoryOrder.Field {
		query = query.Order(DefaultEquipmentCategoryOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *equipmentcategoryPager) orderExpr(query *EquipmentCategoryQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultEquipmentCategoryOrder.Field {
			b.Comma().Ident(DefaultEquipmentCategoryOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to EquipmentCategory.
func (ec *EquipmentCategoryQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...EquipmentCategoryPaginateOption,
) (*EquipmentCategoryConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newEquipmentCategoryPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if ec, err = pager.applyFilter(ec); err != nil {
		return nil, err
	}
	conn := &EquipmentCategoryConnection{Edges: []*EquipmentCategoryEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = ec.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if ec, err = pager.applyCursors(ec, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		ec.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := ec.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	ec = pager.applyOrder(ec)
	nodes, err := ec.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// EquipmentCategoryOrderField defines the ordering field of EquipmentCategory.
type EquipmentCategoryOrderField struct {
	// Value extracts the ordering value from the given EquipmentCategory.
	Value    func(*EquipmentCategory) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) equipmentcategory.OrderOption
	toCursor func(*EquipmentCategory) Cursor
}

// EquipmentCategoryOrder defines the ordering of EquipmentCategory.
type EquipmentCategoryOrder struct {
	Direction OrderDirection               `json:"direction"`
	Field     *EquipmentCategoryOrderField `json:"field"`
}

// DefaultEquipmentCategoryOrder is the default ordering of EquipmentCategory.
var DefaultEquipmentCategoryOrder = &EquipmentCategoryOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &EquipmentCategoryOrderField{
		Value: func(ec *EquipmentCategory) (ent.Value, error) {
			return ec.ID, nil
		},
		column: equipmentcategory.FieldID,
		toTerm: equipmentcategory.ByID,
		toCursor: func(ec *EquipmentCategory) Cursor {
			return Cursor{ID: ec.ID}
		},
	},
}

// ToEdge converts EquipmentCategory into EquipmentCategoryEdge.
func (ec *EquipmentCategory) ToEdge(order *EquipmentCategoryOrder) *EquipmentCategoryEdge {
	if order == nil {
		order = DefaultEquipmentCategoryOrder
	}
	return &EquipmentCategoryEdge{
		Node:   ec,
		Cursor: order.Field.toCursor(ec),
	}
}

// EquipmentChoiceEdge is the edge representation of EquipmentChoice.
type EquipmentChoiceEdge struct {
	Node   *EquipmentChoice `json:"node"`
	Cursor Cursor           `json:"cursor"`
}

// EquipmentChoiceConnection is the connection containing edges to EquipmentChoice.
type EquipmentChoiceConnection struct {
	Edges      []*EquipmentChoiceEdge `json:"edges"`
	PageInfo   PageInfo               `json:"pageInfo"`
	TotalCount int                    `json:"totalCount"`
}

func (c *EquipmentChoiceConnection) build(nodes []*EquipmentChoice, pager *equipmentchoicePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *EquipmentChoice
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *EquipmentChoice {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *EquipmentChoice {
			return nodes[i]
		}
	}
	c.Edges = make([]*EquipmentChoiceEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &EquipmentChoiceEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// EquipmentChoicePaginateOption enables pagination customization.
type EquipmentChoicePaginateOption func(*equipmentchoicePager) error

// WithEquipmentChoiceOrder configures pagination ordering.
func WithEquipmentChoiceOrder(order *EquipmentChoiceOrder) EquipmentChoicePaginateOption {
	if order == nil {
		order = DefaultEquipmentChoiceOrder
	}
	o := *order
	return func(pager *equipmentchoicePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultEquipmentChoiceOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithEquipmentChoiceFilter configures pagination filter.
func WithEquipmentChoiceFilter(filter func(*EquipmentChoiceQuery) (*EquipmentChoiceQuery, error)) EquipmentChoicePaginateOption {
	return func(pager *equipmentchoicePager) error {
		if filter == nil {
			return errors.New("EquipmentChoiceQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type equipmentchoicePager struct {
	reverse bool
	order   *EquipmentChoiceOrder
	filter  func(*EquipmentChoiceQuery) (*EquipmentChoiceQuery, error)
}

func newEquipmentChoicePager(opts []EquipmentChoicePaginateOption, reverse bool) (*equipmentchoicePager, error) {
	pager := &equipmentchoicePager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultEquipmentChoiceOrder
	}
	return pager, nil
}

func (p *equipmentchoicePager) applyFilter(query *EquipmentChoiceQuery) (*EquipmentChoiceQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *equipmentchoicePager) toCursor(ec *EquipmentChoice) Cursor {
	return p.order.Field.toCursor(ec)
}

func (p *equipmentchoicePager) applyCursors(query *EquipmentChoiceQuery, after, before *Cursor) (*EquipmentChoiceQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultEquipmentChoiceOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *equipmentchoicePager) applyOrder(query *EquipmentChoiceQuery) *EquipmentChoiceQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultEquipmentChoiceOrder.Field {
		query = query.Order(DefaultEquipmentChoiceOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *equipmentchoicePager) orderExpr(query *EquipmentChoiceQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultEquipmentChoiceOrder.Field {
			b.Comma().Ident(DefaultEquipmentChoiceOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to EquipmentChoice.
func (ec *EquipmentChoiceQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...EquipmentChoicePaginateOption,
) (*EquipmentChoiceConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newEquipmentChoicePager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if ec, err = pager.applyFilter(ec); err != nil {
		return nil, err
	}
	conn := &EquipmentChoiceConnection{Edges: []*EquipmentChoiceEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = ec.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if ec, err = pager.applyCursors(ec, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		ec.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := ec.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	ec = pager.applyOrder(ec)
	nodes, err := ec.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// EquipmentChoiceOrderField defines the ordering field of EquipmentChoice.
type EquipmentChoiceOrderField struct {
	// Value extracts the ordering value from the given EquipmentChoice.
	Value    func(*EquipmentChoice) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) equipmentchoice.OrderOption
	toCursor func(*EquipmentChoice) Cursor
}

// EquipmentChoiceOrder defines the ordering of EquipmentChoice.
type EquipmentChoiceOrder struct {
	Direction OrderDirection             `json:"direction"`
	Field     *EquipmentChoiceOrderField `json:"field"`
}

// DefaultEquipmentChoiceOrder is the default ordering of EquipmentChoice.
var DefaultEquipmentChoiceOrder = &EquipmentChoiceOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &EquipmentChoiceOrderField{
		Value: func(ec *EquipmentChoice) (ent.Value, error) {
			return ec.ID, nil
		},
		column: equipmentchoice.FieldID,
		toTerm: equipmentchoice.ByID,
		toCursor: func(ec *EquipmentChoice) Cursor {
			return Cursor{ID: ec.ID}
		},
	},
}

// ToEdge converts EquipmentChoice into EquipmentChoiceEdge.
func (ec *EquipmentChoice) ToEdge(order *EquipmentChoiceOrder) *EquipmentChoiceEdge {
	if order == nil {
		order = DefaultEquipmentChoiceOrder
	}
	return &EquipmentChoiceEdge{
		Node:   ec,
		Cursor: order.Field.toCursor(ec),
	}
}

// EquipmentCostEdge is the edge representation of EquipmentCost.
type EquipmentCostEdge struct {
	Node   *EquipmentCost `json:"node"`
	Cursor Cursor         `json:"cursor"`
}

// EquipmentCostConnection is the connection containing edges to EquipmentCost.
type EquipmentCostConnection struct {
	Edges      []*EquipmentCostEdge `json:"edges"`
	PageInfo   PageInfo             `json:"pageInfo"`
	TotalCount int                  `json:"totalCount"`
}

func (c *EquipmentCostConnection) build(nodes []*EquipmentCost, pager *equipmentcostPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *EquipmentCost
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *EquipmentCost {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *EquipmentCost {
			return nodes[i]
		}
	}
	c.Edges = make([]*EquipmentCostEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &EquipmentCostEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// EquipmentCostPaginateOption enables pagination customization.
type EquipmentCostPaginateOption func(*equipmentcostPager) error

// WithEquipmentCostOrder configures pagination ordering.
func WithEquipmentCostOrder(order *EquipmentCostOrder) EquipmentCostPaginateOption {
	if order == nil {
		order = DefaultEquipmentCostOrder
	}
	o := *order
	return func(pager *equipmentcostPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultEquipmentCostOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithEquipmentCostFilter configures pagination filter.
func WithEquipmentCostFilter(filter func(*EquipmentCostQuery) (*EquipmentCostQuery, error)) EquipmentCostPaginateOption {
	return func(pager *equipmentcostPager) error {
		if filter == nil {
			return errors.New("EquipmentCostQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type equipmentcostPager struct {
	reverse bool
	order   *EquipmentCostOrder
	filter  func(*EquipmentCostQuery) (*EquipmentCostQuery, error)
}

func newEquipmentCostPager(opts []EquipmentCostPaginateOption, reverse bool) (*equipmentcostPager, error) {
	pager := &equipmentcostPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultEquipmentCostOrder
	}
	return pager, nil
}

func (p *equipmentcostPager) applyFilter(query *EquipmentCostQuery) (*EquipmentCostQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *equipmentcostPager) toCursor(ec *EquipmentCost) Cursor {
	return p.order.Field.toCursor(ec)
}

func (p *equipmentcostPager) applyCursors(query *EquipmentCostQuery, after, before *Cursor) (*EquipmentCostQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultEquipmentCostOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *equipmentcostPager) applyOrder(query *EquipmentCostQuery) *EquipmentCostQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultEquipmentCostOrder.Field {
		query = query.Order(DefaultEquipmentCostOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *equipmentcostPager) orderExpr(query *EquipmentCostQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultEquipmentCostOrder.Field {
			b.Comma().Ident(DefaultEquipmentCostOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to EquipmentCost.
func (ec *EquipmentCostQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...EquipmentCostPaginateOption,
) (*EquipmentCostConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newEquipmentCostPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if ec, err = pager.applyFilter(ec); err != nil {
		return nil, err
	}
	conn := &EquipmentCostConnection{Edges: []*EquipmentCostEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = ec.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if ec, err = pager.applyCursors(ec, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		ec.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := ec.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	ec = pager.applyOrder(ec)
	nodes, err := ec.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// EquipmentCostOrderField defines the ordering field of EquipmentCost.
type EquipmentCostOrderField struct {
	// Value extracts the ordering value from the given EquipmentCost.
	Value    func(*EquipmentCost) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) equipmentcost.OrderOption
	toCursor func(*EquipmentCost) Cursor
}

// EquipmentCostOrder defines the ordering of EquipmentCost.
type EquipmentCostOrder struct {
	Direction OrderDirection           `json:"direction"`
	Field     *EquipmentCostOrderField `json:"field"`
}

// DefaultEquipmentCostOrder is the default ordering of EquipmentCost.
var DefaultEquipmentCostOrder = &EquipmentCostOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &EquipmentCostOrderField{
		Value: func(ec *EquipmentCost) (ent.Value, error) {
			return ec.ID, nil
		},
		column: equipmentcost.FieldID,
		toTerm: equipmentcost.ByID,
		toCursor: func(ec *EquipmentCost) Cursor {
			return Cursor{ID: ec.ID}
		},
	},
}

// ToEdge converts EquipmentCost into EquipmentCostEdge.
func (ec *EquipmentCost) ToEdge(order *EquipmentCostOrder) *EquipmentCostEdge {
	if order == nil {
		order = DefaultEquipmentCostOrder
	}
	return &EquipmentCostEdge{
		Node:   ec,
		Cursor: order.Field.toCursor(ec),
	}
}

// GearEdge is the edge representation of Gear.
type GearEdge struct {
	Node   *Gear  `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// GearConnection is the connection containing edges to Gear.
type GearConnection struct {
	Edges      []*GearEdge `json:"edges"`
	PageInfo   PageInfo    `json:"pageInfo"`
	TotalCount int         `json:"totalCount"`
}

func (c *GearConnection) build(nodes []*Gear, pager *gearPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Gear
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Gear {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Gear {
			return nodes[i]
		}
	}
	c.Edges = make([]*GearEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &GearEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// GearPaginateOption enables pagination customization.
type GearPaginateOption func(*gearPager) error

// WithGearOrder configures pagination ordering.
func WithGearOrder(order *GearOrder) GearPaginateOption {
	if order == nil {
		order = DefaultGearOrder
	}
	o := *order
	return func(pager *gearPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultGearOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithGearFilter configures pagination filter.
func WithGearFilter(filter func(*GearQuery) (*GearQuery, error)) GearPaginateOption {
	return func(pager *gearPager) error {
		if filter == nil {
			return errors.New("GearQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type gearPager struct {
	reverse bool
	order   *GearOrder
	filter  func(*GearQuery) (*GearQuery, error)
}

func newGearPager(opts []GearPaginateOption, reverse bool) (*gearPager, error) {
	pager := &gearPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultGearOrder
	}
	return pager, nil
}

func (p *gearPager) applyFilter(query *GearQuery) (*GearQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *gearPager) toCursor(ge *Gear) Cursor {
	return p.order.Field.toCursor(ge)
}

func (p *gearPager) applyCursors(query *GearQuery, after, before *Cursor) (*GearQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultGearOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *gearPager) applyOrder(query *GearQuery) *GearQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultGearOrder.Field {
		query = query.Order(DefaultGearOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *gearPager) orderExpr(query *GearQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultGearOrder.Field {
			b.Comma().Ident(DefaultGearOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Gear.
func (ge *GearQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...GearPaginateOption,
) (*GearConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newGearPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if ge, err = pager.applyFilter(ge); err != nil {
		return nil, err
	}
	conn := &GearConnection{Edges: []*GearEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = ge.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if ge, err = pager.applyCursors(ge, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		ge.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := ge.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	ge = pager.applyOrder(ge)
	nodes, err := ge.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// GearOrderFieldIndx orders Gear by indx.
	GearOrderFieldIndx = &GearOrderField{
		Value: func(ge *Gear) (ent.Value, error) {
			return ge.Indx, nil
		},
		column: gear.FieldIndx,
		toTerm: gear.ByIndx,
		toCursor: func(ge *Gear) Cursor {
			return Cursor{
				ID:    ge.ID,
				Value: ge.Indx,
			}
		},
	}
	// GearOrderFieldName orders Gear by name.
	GearOrderFieldName = &GearOrderField{
		Value: func(ge *Gear) (ent.Value, error) {
			return ge.Name, nil
		},
		column: gear.FieldName,
		toTerm: gear.ByName,
		toCursor: func(ge *Gear) Cursor {
			return Cursor{
				ID:    ge.ID,
				Value: ge.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f GearOrderField) String() string {
	var str string
	switch f.column {
	case GearOrderFieldIndx.column:
		str = "INDX"
	case GearOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f GearOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *GearOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("GearOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *GearOrderFieldIndx
	case "NAME":
		*f = *GearOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid GearOrderField", str)
	}
	return nil
}

// GearOrderField defines the ordering field of Gear.
type GearOrderField struct {
	// Value extracts the ordering value from the given Gear.
	Value    func(*Gear) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) gear.OrderOption
	toCursor func(*Gear) Cursor
}

// GearOrder defines the ordering of Gear.
type GearOrder struct {
	Direction OrderDirection  `json:"direction"`
	Field     *GearOrderField `json:"field"`
}

// DefaultGearOrder is the default ordering of Gear.
var DefaultGearOrder = &GearOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &GearOrderField{
		Value: func(ge *Gear) (ent.Value, error) {
			return ge.ID, nil
		},
		column: gear.FieldID,
		toTerm: gear.ByID,
		toCursor: func(ge *Gear) Cursor {
			return Cursor{ID: ge.ID}
		},
	},
}

// ToEdge converts Gear into GearEdge.
func (ge *Gear) ToEdge(order *GearOrder) *GearEdge {
	if order == nil {
		order = DefaultGearOrder
	}
	return &GearEdge{
		Node:   ge,
		Cursor: order.Field.toCursor(ge),
	}
}

// LanguageEdge is the edge representation of Language.
type LanguageEdge struct {
	Node   *Language `json:"node"`
	Cursor Cursor    `json:"cursor"`
}

// LanguageConnection is the connection containing edges to Language.
type LanguageConnection struct {
	Edges      []*LanguageEdge `json:"edges"`
	PageInfo   PageInfo        `json:"pageInfo"`
	TotalCount int             `json:"totalCount"`
}

func (c *LanguageConnection) build(nodes []*Language, pager *languagePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Language
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Language {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Language {
			return nodes[i]
		}
	}
	c.Edges = make([]*LanguageEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &LanguageEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// LanguagePaginateOption enables pagination customization.
type LanguagePaginateOption func(*languagePager) error

// WithLanguageOrder configures pagination ordering.
func WithLanguageOrder(order *LanguageOrder) LanguagePaginateOption {
	if order == nil {
		order = DefaultLanguageOrder
	}
	o := *order
	return func(pager *languagePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultLanguageOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithLanguageFilter configures pagination filter.
func WithLanguageFilter(filter func(*LanguageQuery) (*LanguageQuery, error)) LanguagePaginateOption {
	return func(pager *languagePager) error {
		if filter == nil {
			return errors.New("LanguageQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type languagePager struct {
	reverse bool
	order   *LanguageOrder
	filter  func(*LanguageQuery) (*LanguageQuery, error)
}

func newLanguagePager(opts []LanguagePaginateOption, reverse bool) (*languagePager, error) {
	pager := &languagePager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultLanguageOrder
	}
	return pager, nil
}

func (p *languagePager) applyFilter(query *LanguageQuery) (*LanguageQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *languagePager) toCursor(l *Language) Cursor {
	return p.order.Field.toCursor(l)
}

func (p *languagePager) applyCursors(query *LanguageQuery, after, before *Cursor) (*LanguageQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultLanguageOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *languagePager) applyOrder(query *LanguageQuery) *LanguageQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultLanguageOrder.Field {
		query = query.Order(DefaultLanguageOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *languagePager) orderExpr(query *LanguageQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultLanguageOrder.Field {
			b.Comma().Ident(DefaultLanguageOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Language.
func (l *LanguageQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...LanguagePaginateOption,
) (*LanguageConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newLanguagePager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if l, err = pager.applyFilter(l); err != nil {
		return nil, err
	}
	conn := &LanguageConnection{Edges: []*LanguageEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = l.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if l, err = pager.applyCursors(l, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		l.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := l.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	l = pager.applyOrder(l)
	nodes, err := l.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// LanguageOrderFieldIndx orders Language by indx.
	LanguageOrderFieldIndx = &LanguageOrderField{
		Value: func(l *Language) (ent.Value, error) {
			return l.Indx, nil
		},
		column: language.FieldIndx,
		toTerm: language.ByIndx,
		toCursor: func(l *Language) Cursor {
			return Cursor{
				ID:    l.ID,
				Value: l.Indx,
			}
		},
	}
	// LanguageOrderFieldName orders Language by name.
	LanguageOrderFieldName = &LanguageOrderField{
		Value: func(l *Language) (ent.Value, error) {
			return l.Name, nil
		},
		column: language.FieldName,
		toTerm: language.ByName,
		toCursor: func(l *Language) Cursor {
			return Cursor{
				ID:    l.ID,
				Value: l.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f LanguageOrderField) String() string {
	var str string
	switch f.column {
	case LanguageOrderFieldIndx.column:
		str = "INDX"
	case LanguageOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f LanguageOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *LanguageOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("LanguageOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *LanguageOrderFieldIndx
	case "NAME":
		*f = *LanguageOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid LanguageOrderField", str)
	}
	return nil
}

// LanguageOrderField defines the ordering field of Language.
type LanguageOrderField struct {
	// Value extracts the ordering value from the given Language.
	Value    func(*Language) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) language.OrderOption
	toCursor func(*Language) Cursor
}

// LanguageOrder defines the ordering of Language.
type LanguageOrder struct {
	Direction OrderDirection      `json:"direction"`
	Field     *LanguageOrderField `json:"field"`
}

// DefaultLanguageOrder is the default ordering of Language.
var DefaultLanguageOrder = &LanguageOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &LanguageOrderField{
		Value: func(l *Language) (ent.Value, error) {
			return l.ID, nil
		},
		column: language.FieldID,
		toTerm: language.ByID,
		toCursor: func(l *Language) Cursor {
			return Cursor{ID: l.ID}
		},
	},
}

// ToEdge converts Language into LanguageEdge.
func (l *Language) ToEdge(order *LanguageOrder) *LanguageEdge {
	if order == nil {
		order = DefaultLanguageOrder
	}
	return &LanguageEdge{
		Node:   l,
		Cursor: order.Field.toCursor(l),
	}
}

// MagicSchoolEdge is the edge representation of MagicSchool.
type MagicSchoolEdge struct {
	Node   *MagicSchool `json:"node"`
	Cursor Cursor       `json:"cursor"`
}

// MagicSchoolConnection is the connection containing edges to MagicSchool.
type MagicSchoolConnection struct {
	Edges      []*MagicSchoolEdge `json:"edges"`
	PageInfo   PageInfo           `json:"pageInfo"`
	TotalCount int                `json:"totalCount"`
}

func (c *MagicSchoolConnection) build(nodes []*MagicSchool, pager *magicschoolPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *MagicSchool
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *MagicSchool {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *MagicSchool {
			return nodes[i]
		}
	}
	c.Edges = make([]*MagicSchoolEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &MagicSchoolEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// MagicSchoolPaginateOption enables pagination customization.
type MagicSchoolPaginateOption func(*magicschoolPager) error

// WithMagicSchoolOrder configures pagination ordering.
func WithMagicSchoolOrder(order *MagicSchoolOrder) MagicSchoolPaginateOption {
	if order == nil {
		order = DefaultMagicSchoolOrder
	}
	o := *order
	return func(pager *magicschoolPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultMagicSchoolOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithMagicSchoolFilter configures pagination filter.
func WithMagicSchoolFilter(filter func(*MagicSchoolQuery) (*MagicSchoolQuery, error)) MagicSchoolPaginateOption {
	return func(pager *magicschoolPager) error {
		if filter == nil {
			return errors.New("MagicSchoolQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type magicschoolPager struct {
	reverse bool
	order   *MagicSchoolOrder
	filter  func(*MagicSchoolQuery) (*MagicSchoolQuery, error)
}

func newMagicSchoolPager(opts []MagicSchoolPaginateOption, reverse bool) (*magicschoolPager, error) {
	pager := &magicschoolPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultMagicSchoolOrder
	}
	return pager, nil
}

func (p *magicschoolPager) applyFilter(query *MagicSchoolQuery) (*MagicSchoolQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *magicschoolPager) toCursor(ms *MagicSchool) Cursor {
	return p.order.Field.toCursor(ms)
}

func (p *magicschoolPager) applyCursors(query *MagicSchoolQuery, after, before *Cursor) (*MagicSchoolQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultMagicSchoolOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *magicschoolPager) applyOrder(query *MagicSchoolQuery) *MagicSchoolQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultMagicSchoolOrder.Field {
		query = query.Order(DefaultMagicSchoolOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *magicschoolPager) orderExpr(query *MagicSchoolQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultMagicSchoolOrder.Field {
			b.Comma().Ident(DefaultMagicSchoolOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to MagicSchool.
func (ms *MagicSchoolQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...MagicSchoolPaginateOption,
) (*MagicSchoolConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newMagicSchoolPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if ms, err = pager.applyFilter(ms); err != nil {
		return nil, err
	}
	conn := &MagicSchoolConnection{Edges: []*MagicSchoolEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = ms.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if ms, err = pager.applyCursors(ms, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		ms.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := ms.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	ms = pager.applyOrder(ms)
	nodes, err := ms.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// MagicSchoolOrderFieldIndx orders MagicSchool by indx.
	MagicSchoolOrderFieldIndx = &MagicSchoolOrderField{
		Value: func(ms *MagicSchool) (ent.Value, error) {
			return ms.Indx, nil
		},
		column: magicschool.FieldIndx,
		toTerm: magicschool.ByIndx,
		toCursor: func(ms *MagicSchool) Cursor {
			return Cursor{
				ID:    ms.ID,
				Value: ms.Indx,
			}
		},
	}
	// MagicSchoolOrderFieldName orders MagicSchool by name.
	MagicSchoolOrderFieldName = &MagicSchoolOrderField{
		Value: func(ms *MagicSchool) (ent.Value, error) {
			return ms.Name, nil
		},
		column: magicschool.FieldName,
		toTerm: magicschool.ByName,
		toCursor: func(ms *MagicSchool) Cursor {
			return Cursor{
				ID:    ms.ID,
				Value: ms.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f MagicSchoolOrderField) String() string {
	var str string
	switch f.column {
	case MagicSchoolOrderFieldIndx.column:
		str = "INDX"
	case MagicSchoolOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f MagicSchoolOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *MagicSchoolOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("MagicSchoolOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *MagicSchoolOrderFieldIndx
	case "NAME":
		*f = *MagicSchoolOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid MagicSchoolOrderField", str)
	}
	return nil
}

// MagicSchoolOrderField defines the ordering field of MagicSchool.
type MagicSchoolOrderField struct {
	// Value extracts the ordering value from the given MagicSchool.
	Value    func(*MagicSchool) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) magicschool.OrderOption
	toCursor func(*MagicSchool) Cursor
}

// MagicSchoolOrder defines the ordering of MagicSchool.
type MagicSchoolOrder struct {
	Direction OrderDirection         `json:"direction"`
	Field     *MagicSchoolOrderField `json:"field"`
}

// DefaultMagicSchoolOrder is the default ordering of MagicSchool.
var DefaultMagicSchoolOrder = &MagicSchoolOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &MagicSchoolOrderField{
		Value: func(ms *MagicSchool) (ent.Value, error) {
			return ms.ID, nil
		},
		column: magicschool.FieldID,
		toTerm: magicschool.ByID,
		toCursor: func(ms *MagicSchool) Cursor {
			return Cursor{ID: ms.ID}
		},
	},
}

// ToEdge converts MagicSchool into MagicSchoolEdge.
func (ms *MagicSchool) ToEdge(order *MagicSchoolOrder) *MagicSchoolEdge {
	if order == nil {
		order = DefaultMagicSchoolOrder
	}
	return &MagicSchoolEdge{
		Node:   ms,
		Cursor: order.Field.toCursor(ms),
	}
}

// ProficiencyEdge is the edge representation of Proficiency.
type ProficiencyEdge struct {
	Node   *Proficiency `json:"node"`
	Cursor Cursor       `json:"cursor"`
}

// ProficiencyConnection is the connection containing edges to Proficiency.
type ProficiencyConnection struct {
	Edges      []*ProficiencyEdge `json:"edges"`
	PageInfo   PageInfo           `json:"pageInfo"`
	TotalCount int                `json:"totalCount"`
}

func (c *ProficiencyConnection) build(nodes []*Proficiency, pager *proficiencyPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Proficiency
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Proficiency {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Proficiency {
			return nodes[i]
		}
	}
	c.Edges = make([]*ProficiencyEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &ProficiencyEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// ProficiencyPaginateOption enables pagination customization.
type ProficiencyPaginateOption func(*proficiencyPager) error

// WithProficiencyOrder configures pagination ordering.
func WithProficiencyOrder(order *ProficiencyOrder) ProficiencyPaginateOption {
	if order == nil {
		order = DefaultProficiencyOrder
	}
	o := *order
	return func(pager *proficiencyPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultProficiencyOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithProficiencyFilter configures pagination filter.
func WithProficiencyFilter(filter func(*ProficiencyQuery) (*ProficiencyQuery, error)) ProficiencyPaginateOption {
	return func(pager *proficiencyPager) error {
		if filter == nil {
			return errors.New("ProficiencyQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type proficiencyPager struct {
	reverse bool
	order   *ProficiencyOrder
	filter  func(*ProficiencyQuery) (*ProficiencyQuery, error)
}

func newProficiencyPager(opts []ProficiencyPaginateOption, reverse bool) (*proficiencyPager, error) {
	pager := &proficiencyPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultProficiencyOrder
	}
	return pager, nil
}

func (p *proficiencyPager) applyFilter(query *ProficiencyQuery) (*ProficiencyQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *proficiencyPager) toCursor(pr *Proficiency) Cursor {
	return p.order.Field.toCursor(pr)
}

func (p *proficiencyPager) applyCursors(query *ProficiencyQuery, after, before *Cursor) (*ProficiencyQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultProficiencyOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *proficiencyPager) applyOrder(query *ProficiencyQuery) *ProficiencyQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultProficiencyOrder.Field {
		query = query.Order(DefaultProficiencyOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *proficiencyPager) orderExpr(query *ProficiencyQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultProficiencyOrder.Field {
			b.Comma().Ident(DefaultProficiencyOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Proficiency.
func (pr *ProficiencyQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...ProficiencyPaginateOption,
) (*ProficiencyConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newProficiencyPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if pr, err = pager.applyFilter(pr); err != nil {
		return nil, err
	}
	conn := &ProficiencyConnection{Edges: []*ProficiencyEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = pr.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if pr, err = pager.applyCursors(pr, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		pr.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := pr.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	pr = pager.applyOrder(pr)
	nodes, err := pr.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// ProficiencyOrderFieldIndx orders Proficiency by indx.
	ProficiencyOrderFieldIndx = &ProficiencyOrderField{
		Value: func(pr *Proficiency) (ent.Value, error) {
			return pr.Indx, nil
		},
		column: proficiency.FieldIndx,
		toTerm: proficiency.ByIndx,
		toCursor: func(pr *Proficiency) Cursor {
			return Cursor{
				ID:    pr.ID,
				Value: pr.Indx,
			}
		},
	}
	// ProficiencyOrderFieldName orders Proficiency by name.
	ProficiencyOrderFieldName = &ProficiencyOrderField{
		Value: func(pr *Proficiency) (ent.Value, error) {
			return pr.Name, nil
		},
		column: proficiency.FieldName,
		toTerm: proficiency.ByName,
		toCursor: func(pr *Proficiency) Cursor {
			return Cursor{
				ID:    pr.ID,
				Value: pr.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f ProficiencyOrderField) String() string {
	var str string
	switch f.column {
	case ProficiencyOrderFieldIndx.column:
		str = "INDX"
	case ProficiencyOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f ProficiencyOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *ProficiencyOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("ProficiencyOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *ProficiencyOrderFieldIndx
	case "NAME":
		*f = *ProficiencyOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid ProficiencyOrderField", str)
	}
	return nil
}

// ProficiencyOrderField defines the ordering field of Proficiency.
type ProficiencyOrderField struct {
	// Value extracts the ordering value from the given Proficiency.
	Value    func(*Proficiency) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) proficiency.OrderOption
	toCursor func(*Proficiency) Cursor
}

// ProficiencyOrder defines the ordering of Proficiency.
type ProficiencyOrder struct {
	Direction OrderDirection         `json:"direction"`
	Field     *ProficiencyOrderField `json:"field"`
}

// DefaultProficiencyOrder is the default ordering of Proficiency.
var DefaultProficiencyOrder = &ProficiencyOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &ProficiencyOrderField{
		Value: func(pr *Proficiency) (ent.Value, error) {
			return pr.ID, nil
		},
		column: proficiency.FieldID,
		toTerm: proficiency.ByID,
		toCursor: func(pr *Proficiency) Cursor {
			return Cursor{ID: pr.ID}
		},
	},
}

// ToEdge converts Proficiency into ProficiencyEdge.
func (pr *Proficiency) ToEdge(order *ProficiencyOrder) *ProficiencyEdge {
	if order == nil {
		order = DefaultProficiencyOrder
	}
	return &ProficiencyEdge{
		Node:   pr,
		Cursor: order.Field.toCursor(pr),
	}
}

// ProficiencyChoiceEdge is the edge representation of ProficiencyChoice.
type ProficiencyChoiceEdge struct {
	Node   *ProficiencyChoice `json:"node"`
	Cursor Cursor             `json:"cursor"`
}

// ProficiencyChoiceConnection is the connection containing edges to ProficiencyChoice.
type ProficiencyChoiceConnection struct {
	Edges      []*ProficiencyChoiceEdge `json:"edges"`
	PageInfo   PageInfo                 `json:"pageInfo"`
	TotalCount int                      `json:"totalCount"`
}

func (c *ProficiencyChoiceConnection) build(nodes []*ProficiencyChoice, pager *proficiencychoicePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *ProficiencyChoice
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *ProficiencyChoice {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *ProficiencyChoice {
			return nodes[i]
		}
	}
	c.Edges = make([]*ProficiencyChoiceEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &ProficiencyChoiceEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// ProficiencyChoicePaginateOption enables pagination customization.
type ProficiencyChoicePaginateOption func(*proficiencychoicePager) error

// WithProficiencyChoiceOrder configures pagination ordering.
func WithProficiencyChoiceOrder(order *ProficiencyChoiceOrder) ProficiencyChoicePaginateOption {
	if order == nil {
		order = DefaultProficiencyChoiceOrder
	}
	o := *order
	return func(pager *proficiencychoicePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultProficiencyChoiceOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithProficiencyChoiceFilter configures pagination filter.
func WithProficiencyChoiceFilter(filter func(*ProficiencyChoiceQuery) (*ProficiencyChoiceQuery, error)) ProficiencyChoicePaginateOption {
	return func(pager *proficiencychoicePager) error {
		if filter == nil {
			return errors.New("ProficiencyChoiceQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type proficiencychoicePager struct {
	reverse bool
	order   *ProficiencyChoiceOrder
	filter  func(*ProficiencyChoiceQuery) (*ProficiencyChoiceQuery, error)
}

func newProficiencyChoicePager(opts []ProficiencyChoicePaginateOption, reverse bool) (*proficiencychoicePager, error) {
	pager := &proficiencychoicePager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultProficiencyChoiceOrder
	}
	return pager, nil
}

func (p *proficiencychoicePager) applyFilter(query *ProficiencyChoiceQuery) (*ProficiencyChoiceQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *proficiencychoicePager) toCursor(pc *ProficiencyChoice) Cursor {
	return p.order.Field.toCursor(pc)
}

func (p *proficiencychoicePager) applyCursors(query *ProficiencyChoiceQuery, after, before *Cursor) (*ProficiencyChoiceQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultProficiencyChoiceOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *proficiencychoicePager) applyOrder(query *ProficiencyChoiceQuery) *ProficiencyChoiceQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultProficiencyChoiceOrder.Field {
		query = query.Order(DefaultProficiencyChoiceOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *proficiencychoicePager) orderExpr(query *ProficiencyChoiceQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultProficiencyChoiceOrder.Field {
			b.Comma().Ident(DefaultProficiencyChoiceOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to ProficiencyChoice.
func (pc *ProficiencyChoiceQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...ProficiencyChoicePaginateOption,
) (*ProficiencyChoiceConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newProficiencyChoicePager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if pc, err = pager.applyFilter(pc); err != nil {
		return nil, err
	}
	conn := &ProficiencyChoiceConnection{Edges: []*ProficiencyChoiceEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = pc.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if pc, err = pager.applyCursors(pc, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		pc.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := pc.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	pc = pager.applyOrder(pc)
	nodes, err := pc.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// ProficiencyChoiceOrderField defines the ordering field of ProficiencyChoice.
type ProficiencyChoiceOrderField struct {
	// Value extracts the ordering value from the given ProficiencyChoice.
	Value    func(*ProficiencyChoice) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) proficiencychoice.OrderOption
	toCursor func(*ProficiencyChoice) Cursor
}

// ProficiencyChoiceOrder defines the ordering of ProficiencyChoice.
type ProficiencyChoiceOrder struct {
	Direction OrderDirection               `json:"direction"`
	Field     *ProficiencyChoiceOrderField `json:"field"`
}

// DefaultProficiencyChoiceOrder is the default ordering of ProficiencyChoice.
var DefaultProficiencyChoiceOrder = &ProficiencyChoiceOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &ProficiencyChoiceOrderField{
		Value: func(pc *ProficiencyChoice) (ent.Value, error) {
			return pc.ID, nil
		},
		column: proficiencychoice.FieldID,
		toTerm: proficiencychoice.ByID,
		toCursor: func(pc *ProficiencyChoice) Cursor {
			return Cursor{ID: pc.ID}
		},
	},
}

// ToEdge converts ProficiencyChoice into ProficiencyChoiceEdge.
func (pc *ProficiencyChoice) ToEdge(order *ProficiencyChoiceOrder) *ProficiencyChoiceEdge {
	if order == nil {
		order = DefaultProficiencyChoiceOrder
	}
	return &ProficiencyChoiceEdge{
		Node:   pc,
		Cursor: order.Field.toCursor(pc),
	}
}

// RaceEdge is the edge representation of Race.
type RaceEdge struct {
	Node   *Race  `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// RaceConnection is the connection containing edges to Race.
type RaceConnection struct {
	Edges      []*RaceEdge `json:"edges"`
	PageInfo   PageInfo    `json:"pageInfo"`
	TotalCount int         `json:"totalCount"`
}

func (c *RaceConnection) build(nodes []*Race, pager *racePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Race
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Race {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Race {
			return nodes[i]
		}
	}
	c.Edges = make([]*RaceEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &RaceEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// RacePaginateOption enables pagination customization.
type RacePaginateOption func(*racePager) error

// WithRaceOrder configures pagination ordering.
func WithRaceOrder(order *RaceOrder) RacePaginateOption {
	if order == nil {
		order = DefaultRaceOrder
	}
	o := *order
	return func(pager *racePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultRaceOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithRaceFilter configures pagination filter.
func WithRaceFilter(filter func(*RaceQuery) (*RaceQuery, error)) RacePaginateOption {
	return func(pager *racePager) error {
		if filter == nil {
			return errors.New("RaceQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type racePager struct {
	reverse bool
	order   *RaceOrder
	filter  func(*RaceQuery) (*RaceQuery, error)
}

func newRacePager(opts []RacePaginateOption, reverse bool) (*racePager, error) {
	pager := &racePager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultRaceOrder
	}
	return pager, nil
}

func (p *racePager) applyFilter(query *RaceQuery) (*RaceQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *racePager) toCursor(r *Race) Cursor {
	return p.order.Field.toCursor(r)
}

func (p *racePager) applyCursors(query *RaceQuery, after, before *Cursor) (*RaceQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultRaceOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *racePager) applyOrder(query *RaceQuery) *RaceQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultRaceOrder.Field {
		query = query.Order(DefaultRaceOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *racePager) orderExpr(query *RaceQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultRaceOrder.Field {
			b.Comma().Ident(DefaultRaceOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Race.
func (r *RaceQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...RacePaginateOption,
) (*RaceConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newRacePager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if r, err = pager.applyFilter(r); err != nil {
		return nil, err
	}
	conn := &RaceConnection{Edges: []*RaceEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = r.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if r, err = pager.applyCursors(r, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		r.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := r.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	r = pager.applyOrder(r)
	nodes, err := r.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// RaceOrderFieldIndx orders Race by indx.
	RaceOrderFieldIndx = &RaceOrderField{
		Value: func(r *Race) (ent.Value, error) {
			return r.Indx, nil
		},
		column: race.FieldIndx,
		toTerm: race.ByIndx,
		toCursor: func(r *Race) Cursor {
			return Cursor{
				ID:    r.ID,
				Value: r.Indx,
			}
		},
	}
	// RaceOrderFieldName orders Race by name.
	RaceOrderFieldName = &RaceOrderField{
		Value: func(r *Race) (ent.Value, error) {
			return r.Name, nil
		},
		column: race.FieldName,
		toTerm: race.ByName,
		toCursor: func(r *Race) Cursor {
			return Cursor{
				ID:    r.ID,
				Value: r.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f RaceOrderField) String() string {
	var str string
	switch f.column {
	case RaceOrderFieldIndx.column:
		str = "INDX"
	case RaceOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f RaceOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *RaceOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("RaceOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *RaceOrderFieldIndx
	case "NAME":
		*f = *RaceOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid RaceOrderField", str)
	}
	return nil
}

// RaceOrderField defines the ordering field of Race.
type RaceOrderField struct {
	// Value extracts the ordering value from the given Race.
	Value    func(*Race) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) race.OrderOption
	toCursor func(*Race) Cursor
}

// RaceOrder defines the ordering of Race.
type RaceOrder struct {
	Direction OrderDirection  `json:"direction"`
	Field     *RaceOrderField `json:"field"`
}

// DefaultRaceOrder is the default ordering of Race.
var DefaultRaceOrder = &RaceOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &RaceOrderField{
		Value: func(r *Race) (ent.Value, error) {
			return r.ID, nil
		},
		column: race.FieldID,
		toTerm: race.ByID,
		toCursor: func(r *Race) Cursor {
			return Cursor{ID: r.ID}
		},
	},
}

// ToEdge converts Race into RaceEdge.
func (r *Race) ToEdge(order *RaceOrder) *RaceEdge {
	if order == nil {
		order = DefaultRaceOrder
	}
	return &RaceEdge{
		Node:   r,
		Cursor: order.Field.toCursor(r),
	}
}

// RuleEdge is the edge representation of Rule.
type RuleEdge struct {
	Node   *Rule  `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// RuleConnection is the connection containing edges to Rule.
type RuleConnection struct {
	Edges      []*RuleEdge `json:"edges"`
	PageInfo   PageInfo    `json:"pageInfo"`
	TotalCount int         `json:"totalCount"`
}

func (c *RuleConnection) build(nodes []*Rule, pager *rulePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Rule
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Rule {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Rule {
			return nodes[i]
		}
	}
	c.Edges = make([]*RuleEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &RuleEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// RulePaginateOption enables pagination customization.
type RulePaginateOption func(*rulePager) error

// WithRuleOrder configures pagination ordering.
func WithRuleOrder(order *RuleOrder) RulePaginateOption {
	if order == nil {
		order = DefaultRuleOrder
	}
	o := *order
	return func(pager *rulePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultRuleOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithRuleFilter configures pagination filter.
func WithRuleFilter(filter func(*RuleQuery) (*RuleQuery, error)) RulePaginateOption {
	return func(pager *rulePager) error {
		if filter == nil {
			return errors.New("RuleQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type rulePager struct {
	reverse bool
	order   *RuleOrder
	filter  func(*RuleQuery) (*RuleQuery, error)
}

func newRulePager(opts []RulePaginateOption, reverse bool) (*rulePager, error) {
	pager := &rulePager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultRuleOrder
	}
	return pager, nil
}

func (p *rulePager) applyFilter(query *RuleQuery) (*RuleQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *rulePager) toCursor(r *Rule) Cursor {
	return p.order.Field.toCursor(r)
}

func (p *rulePager) applyCursors(query *RuleQuery, after, before *Cursor) (*RuleQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultRuleOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *rulePager) applyOrder(query *RuleQuery) *RuleQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultRuleOrder.Field {
		query = query.Order(DefaultRuleOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *rulePager) orderExpr(query *RuleQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultRuleOrder.Field {
			b.Comma().Ident(DefaultRuleOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Rule.
func (r *RuleQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...RulePaginateOption,
) (*RuleConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newRulePager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if r, err = pager.applyFilter(r); err != nil {
		return nil, err
	}
	conn := &RuleConnection{Edges: []*RuleEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = r.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if r, err = pager.applyCursors(r, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		r.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := r.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	r = pager.applyOrder(r)
	nodes, err := r.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// RuleOrderFieldIndx orders Rule by indx.
	RuleOrderFieldIndx = &RuleOrderField{
		Value: func(r *Rule) (ent.Value, error) {
			return r.Indx, nil
		},
		column: rule.FieldIndx,
		toTerm: rule.ByIndx,
		toCursor: func(r *Rule) Cursor {
			return Cursor{
				ID:    r.ID,
				Value: r.Indx,
			}
		},
	}
	// RuleOrderFieldName orders Rule by name.
	RuleOrderFieldName = &RuleOrderField{
		Value: func(r *Rule) (ent.Value, error) {
			return r.Name, nil
		},
		column: rule.FieldName,
		toTerm: rule.ByName,
		toCursor: func(r *Rule) Cursor {
			return Cursor{
				ID:    r.ID,
				Value: r.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f RuleOrderField) String() string {
	var str string
	switch f.column {
	case RuleOrderFieldIndx.column:
		str = "INDX"
	case RuleOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f RuleOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *RuleOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("RuleOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *RuleOrderFieldIndx
	case "NAME":
		*f = *RuleOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid RuleOrderField", str)
	}
	return nil
}

// RuleOrderField defines the ordering field of Rule.
type RuleOrderField struct {
	// Value extracts the ordering value from the given Rule.
	Value    func(*Rule) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) rule.OrderOption
	toCursor func(*Rule) Cursor
}

// RuleOrder defines the ordering of Rule.
type RuleOrder struct {
	Direction OrderDirection  `json:"direction"`
	Field     *RuleOrderField `json:"field"`
}

// DefaultRuleOrder is the default ordering of Rule.
var DefaultRuleOrder = &RuleOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &RuleOrderField{
		Value: func(r *Rule) (ent.Value, error) {
			return r.ID, nil
		},
		column: rule.FieldID,
		toTerm: rule.ByID,
		toCursor: func(r *Rule) Cursor {
			return Cursor{ID: r.ID}
		},
	},
}

// ToEdge converts Rule into RuleEdge.
func (r *Rule) ToEdge(order *RuleOrder) *RuleEdge {
	if order == nil {
		order = DefaultRuleOrder
	}
	return &RuleEdge{
		Node:   r,
		Cursor: order.Field.toCursor(r),
	}
}

// RuleSectionEdge is the edge representation of RuleSection.
type RuleSectionEdge struct {
	Node   *RuleSection `json:"node"`
	Cursor Cursor       `json:"cursor"`
}

// RuleSectionConnection is the connection containing edges to RuleSection.
type RuleSectionConnection struct {
	Edges      []*RuleSectionEdge `json:"edges"`
	PageInfo   PageInfo           `json:"pageInfo"`
	TotalCount int                `json:"totalCount"`
}

func (c *RuleSectionConnection) build(nodes []*RuleSection, pager *rulesectionPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *RuleSection
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *RuleSection {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *RuleSection {
			return nodes[i]
		}
	}
	c.Edges = make([]*RuleSectionEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &RuleSectionEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// RuleSectionPaginateOption enables pagination customization.
type RuleSectionPaginateOption func(*rulesectionPager) error

// WithRuleSectionOrder configures pagination ordering.
func WithRuleSectionOrder(order *RuleSectionOrder) RuleSectionPaginateOption {
	if order == nil {
		order = DefaultRuleSectionOrder
	}
	o := *order
	return func(pager *rulesectionPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultRuleSectionOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithRuleSectionFilter configures pagination filter.
func WithRuleSectionFilter(filter func(*RuleSectionQuery) (*RuleSectionQuery, error)) RuleSectionPaginateOption {
	return func(pager *rulesectionPager) error {
		if filter == nil {
			return errors.New("RuleSectionQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type rulesectionPager struct {
	reverse bool
	order   *RuleSectionOrder
	filter  func(*RuleSectionQuery) (*RuleSectionQuery, error)
}

func newRuleSectionPager(opts []RuleSectionPaginateOption, reverse bool) (*rulesectionPager, error) {
	pager := &rulesectionPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultRuleSectionOrder
	}
	return pager, nil
}

func (p *rulesectionPager) applyFilter(query *RuleSectionQuery) (*RuleSectionQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *rulesectionPager) toCursor(rs *RuleSection) Cursor {
	return p.order.Field.toCursor(rs)
}

func (p *rulesectionPager) applyCursors(query *RuleSectionQuery, after, before *Cursor) (*RuleSectionQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultRuleSectionOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *rulesectionPager) applyOrder(query *RuleSectionQuery) *RuleSectionQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultRuleSectionOrder.Field {
		query = query.Order(DefaultRuleSectionOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *rulesectionPager) orderExpr(query *RuleSectionQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultRuleSectionOrder.Field {
			b.Comma().Ident(DefaultRuleSectionOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to RuleSection.
func (rs *RuleSectionQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...RuleSectionPaginateOption,
) (*RuleSectionConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newRuleSectionPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if rs, err = pager.applyFilter(rs); err != nil {
		return nil, err
	}
	conn := &RuleSectionConnection{Edges: []*RuleSectionEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = rs.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if rs, err = pager.applyCursors(rs, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		rs.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := rs.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	rs = pager.applyOrder(rs)
	nodes, err := rs.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// RuleSectionOrderFieldIndx orders RuleSection by indx.
	RuleSectionOrderFieldIndx = &RuleSectionOrderField{
		Value: func(rs *RuleSection) (ent.Value, error) {
			return rs.Indx, nil
		},
		column: rulesection.FieldIndx,
		toTerm: rulesection.ByIndx,
		toCursor: func(rs *RuleSection) Cursor {
			return Cursor{
				ID:    rs.ID,
				Value: rs.Indx,
			}
		},
	}
	// RuleSectionOrderFieldName orders RuleSection by name.
	RuleSectionOrderFieldName = &RuleSectionOrderField{
		Value: func(rs *RuleSection) (ent.Value, error) {
			return rs.Name, nil
		},
		column: rulesection.FieldName,
		toTerm: rulesection.ByName,
		toCursor: func(rs *RuleSection) Cursor {
			return Cursor{
				ID:    rs.ID,
				Value: rs.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f RuleSectionOrderField) String() string {
	var str string
	switch f.column {
	case RuleSectionOrderFieldIndx.column:
		str = "INDX"
	case RuleSectionOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f RuleSectionOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *RuleSectionOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("RuleSectionOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *RuleSectionOrderFieldIndx
	case "NAME":
		*f = *RuleSectionOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid RuleSectionOrderField", str)
	}
	return nil
}

// RuleSectionOrderField defines the ordering field of RuleSection.
type RuleSectionOrderField struct {
	// Value extracts the ordering value from the given RuleSection.
	Value    func(*RuleSection) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) rulesection.OrderOption
	toCursor func(*RuleSection) Cursor
}

// RuleSectionOrder defines the ordering of RuleSection.
type RuleSectionOrder struct {
	Direction OrderDirection         `json:"direction"`
	Field     *RuleSectionOrderField `json:"field"`
}

// DefaultRuleSectionOrder is the default ordering of RuleSection.
var DefaultRuleSectionOrder = &RuleSectionOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &RuleSectionOrderField{
		Value: func(rs *RuleSection) (ent.Value, error) {
			return rs.ID, nil
		},
		column: rulesection.FieldID,
		toTerm: rulesection.ByID,
		toCursor: func(rs *RuleSection) Cursor {
			return Cursor{ID: rs.ID}
		},
	},
}

// ToEdge converts RuleSection into RuleSectionEdge.
func (rs *RuleSection) ToEdge(order *RuleSectionOrder) *RuleSectionEdge {
	if order == nil {
		order = DefaultRuleSectionOrder
	}
	return &RuleSectionEdge{
		Node:   rs,
		Cursor: order.Field.toCursor(rs),
	}
}

// SkillEdge is the edge representation of Skill.
type SkillEdge struct {
	Node   *Skill `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// SkillConnection is the connection containing edges to Skill.
type SkillConnection struct {
	Edges      []*SkillEdge `json:"edges"`
	PageInfo   PageInfo     `json:"pageInfo"`
	TotalCount int          `json:"totalCount"`
}

func (c *SkillConnection) build(nodes []*Skill, pager *skillPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Skill
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Skill {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Skill {
			return nodes[i]
		}
	}
	c.Edges = make([]*SkillEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &SkillEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// SkillPaginateOption enables pagination customization.
type SkillPaginateOption func(*skillPager) error

// WithSkillOrder configures pagination ordering.
func WithSkillOrder(order *SkillOrder) SkillPaginateOption {
	if order == nil {
		order = DefaultSkillOrder
	}
	o := *order
	return func(pager *skillPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultSkillOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithSkillFilter configures pagination filter.
func WithSkillFilter(filter func(*SkillQuery) (*SkillQuery, error)) SkillPaginateOption {
	return func(pager *skillPager) error {
		if filter == nil {
			return errors.New("SkillQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type skillPager struct {
	reverse bool
	order   *SkillOrder
	filter  func(*SkillQuery) (*SkillQuery, error)
}

func newSkillPager(opts []SkillPaginateOption, reverse bool) (*skillPager, error) {
	pager := &skillPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultSkillOrder
	}
	return pager, nil
}

func (p *skillPager) applyFilter(query *SkillQuery) (*SkillQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *skillPager) toCursor(s *Skill) Cursor {
	return p.order.Field.toCursor(s)
}

func (p *skillPager) applyCursors(query *SkillQuery, after, before *Cursor) (*SkillQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultSkillOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *skillPager) applyOrder(query *SkillQuery) *SkillQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultSkillOrder.Field {
		query = query.Order(DefaultSkillOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *skillPager) orderExpr(query *SkillQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultSkillOrder.Field {
			b.Comma().Ident(DefaultSkillOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Skill.
func (s *SkillQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...SkillPaginateOption,
) (*SkillConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newSkillPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if s, err = pager.applyFilter(s); err != nil {
		return nil, err
	}
	conn := &SkillConnection{Edges: []*SkillEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = s.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if s, err = pager.applyCursors(s, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		s.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := s.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	s = pager.applyOrder(s)
	nodes, err := s.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// SkillOrderFieldIndx orders Skill by indx.
	SkillOrderFieldIndx = &SkillOrderField{
		Value: func(s *Skill) (ent.Value, error) {
			return s.Indx, nil
		},
		column: skill.FieldIndx,
		toTerm: skill.ByIndx,
		toCursor: func(s *Skill) Cursor {
			return Cursor{
				ID:    s.ID,
				Value: s.Indx,
			}
		},
	}
	// SkillOrderFieldName orders Skill by name.
	SkillOrderFieldName = &SkillOrderField{
		Value: func(s *Skill) (ent.Value, error) {
			return s.Name, nil
		},
		column: skill.FieldName,
		toTerm: skill.ByName,
		toCursor: func(s *Skill) Cursor {
			return Cursor{
				ID:    s.ID,
				Value: s.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f SkillOrderField) String() string {
	var str string
	switch f.column {
	case SkillOrderFieldIndx.column:
		str = "INDX"
	case SkillOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f SkillOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *SkillOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("SkillOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *SkillOrderFieldIndx
	case "NAME":
		*f = *SkillOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid SkillOrderField", str)
	}
	return nil
}

// SkillOrderField defines the ordering field of Skill.
type SkillOrderField struct {
	// Value extracts the ordering value from the given Skill.
	Value    func(*Skill) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) skill.OrderOption
	toCursor func(*Skill) Cursor
}

// SkillOrder defines the ordering of Skill.
type SkillOrder struct {
	Direction OrderDirection   `json:"direction"`
	Field     *SkillOrderField `json:"field"`
}

// DefaultSkillOrder is the default ordering of Skill.
var DefaultSkillOrder = &SkillOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &SkillOrderField{
		Value: func(s *Skill) (ent.Value, error) {
			return s.ID, nil
		},
		column: skill.FieldID,
		toTerm: skill.ByID,
		toCursor: func(s *Skill) Cursor {
			return Cursor{ID: s.ID}
		},
	},
}

// ToEdge converts Skill into SkillEdge.
func (s *Skill) ToEdge(order *SkillOrder) *SkillEdge {
	if order == nil {
		order = DefaultSkillOrder
	}
	return &SkillEdge{
		Node:   s,
		Cursor: order.Field.toCursor(s),
	}
}

// SubraceEdge is the edge representation of Subrace.
type SubraceEdge struct {
	Node   *Subrace `json:"node"`
	Cursor Cursor   `json:"cursor"`
}

// SubraceConnection is the connection containing edges to Subrace.
type SubraceConnection struct {
	Edges      []*SubraceEdge `json:"edges"`
	PageInfo   PageInfo       `json:"pageInfo"`
	TotalCount int            `json:"totalCount"`
}

func (c *SubraceConnection) build(nodes []*Subrace, pager *subracePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Subrace
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Subrace {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Subrace {
			return nodes[i]
		}
	}
	c.Edges = make([]*SubraceEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &SubraceEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// SubracePaginateOption enables pagination customization.
type SubracePaginateOption func(*subracePager) error

// WithSubraceOrder configures pagination ordering.
func WithSubraceOrder(order *SubraceOrder) SubracePaginateOption {
	if order == nil {
		order = DefaultSubraceOrder
	}
	o := *order
	return func(pager *subracePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultSubraceOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithSubraceFilter configures pagination filter.
func WithSubraceFilter(filter func(*SubraceQuery) (*SubraceQuery, error)) SubracePaginateOption {
	return func(pager *subracePager) error {
		if filter == nil {
			return errors.New("SubraceQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type subracePager struct {
	reverse bool
	order   *SubraceOrder
	filter  func(*SubraceQuery) (*SubraceQuery, error)
}

func newSubracePager(opts []SubracePaginateOption, reverse bool) (*subracePager, error) {
	pager := &subracePager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultSubraceOrder
	}
	return pager, nil
}

func (p *subracePager) applyFilter(query *SubraceQuery) (*SubraceQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *subracePager) toCursor(s *Subrace) Cursor {
	return p.order.Field.toCursor(s)
}

func (p *subracePager) applyCursors(query *SubraceQuery, after, before *Cursor) (*SubraceQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultSubraceOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *subracePager) applyOrder(query *SubraceQuery) *SubraceQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultSubraceOrder.Field {
		query = query.Order(DefaultSubraceOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *subracePager) orderExpr(query *SubraceQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultSubraceOrder.Field {
			b.Comma().Ident(DefaultSubraceOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Subrace.
func (s *SubraceQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...SubracePaginateOption,
) (*SubraceConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newSubracePager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if s, err = pager.applyFilter(s); err != nil {
		return nil, err
	}
	conn := &SubraceConnection{Edges: []*SubraceEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = s.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if s, err = pager.applyCursors(s, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		s.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := s.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	s = pager.applyOrder(s)
	nodes, err := s.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// SubraceOrderFieldIndx orders Subrace by indx.
	SubraceOrderFieldIndx = &SubraceOrderField{
		Value: func(s *Subrace) (ent.Value, error) {
			return s.Indx, nil
		},
		column: subrace.FieldIndx,
		toTerm: subrace.ByIndx,
		toCursor: func(s *Subrace) Cursor {
			return Cursor{
				ID:    s.ID,
				Value: s.Indx,
			}
		},
	}
	// SubraceOrderFieldName orders Subrace by name.
	SubraceOrderFieldName = &SubraceOrderField{
		Value: func(s *Subrace) (ent.Value, error) {
			return s.Name, nil
		},
		column: subrace.FieldName,
		toTerm: subrace.ByName,
		toCursor: func(s *Subrace) Cursor {
			return Cursor{
				ID:    s.ID,
				Value: s.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f SubraceOrderField) String() string {
	var str string
	switch f.column {
	case SubraceOrderFieldIndx.column:
		str = "INDX"
	case SubraceOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f SubraceOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *SubraceOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("SubraceOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *SubraceOrderFieldIndx
	case "NAME":
		*f = *SubraceOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid SubraceOrderField", str)
	}
	return nil
}

// SubraceOrderField defines the ordering field of Subrace.
type SubraceOrderField struct {
	// Value extracts the ordering value from the given Subrace.
	Value    func(*Subrace) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) subrace.OrderOption
	toCursor func(*Subrace) Cursor
}

// SubraceOrder defines the ordering of Subrace.
type SubraceOrder struct {
	Direction OrderDirection     `json:"direction"`
	Field     *SubraceOrderField `json:"field"`
}

// DefaultSubraceOrder is the default ordering of Subrace.
var DefaultSubraceOrder = &SubraceOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &SubraceOrderField{
		Value: func(s *Subrace) (ent.Value, error) {
			return s.ID, nil
		},
		column: subrace.FieldID,
		toTerm: subrace.ByID,
		toCursor: func(s *Subrace) Cursor {
			return Cursor{ID: s.ID}
		},
	},
}

// ToEdge converts Subrace into SubraceEdge.
func (s *Subrace) ToEdge(order *SubraceOrder) *SubraceEdge {
	if order == nil {
		order = DefaultSubraceOrder
	}
	return &SubraceEdge{
		Node:   s,
		Cursor: order.Field.toCursor(s),
	}
}

// ToolEdge is the edge representation of Tool.
type ToolEdge struct {
	Node   *Tool  `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// ToolConnection is the connection containing edges to Tool.
type ToolConnection struct {
	Edges      []*ToolEdge `json:"edges"`
	PageInfo   PageInfo    `json:"pageInfo"`
	TotalCount int         `json:"totalCount"`
}

func (c *ToolConnection) build(nodes []*Tool, pager *toolPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Tool
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Tool {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Tool {
			return nodes[i]
		}
	}
	c.Edges = make([]*ToolEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &ToolEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// ToolPaginateOption enables pagination customization.
type ToolPaginateOption func(*toolPager) error

// WithToolOrder configures pagination ordering.
func WithToolOrder(order *ToolOrder) ToolPaginateOption {
	if order == nil {
		order = DefaultToolOrder
	}
	o := *order
	return func(pager *toolPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultToolOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithToolFilter configures pagination filter.
func WithToolFilter(filter func(*ToolQuery) (*ToolQuery, error)) ToolPaginateOption {
	return func(pager *toolPager) error {
		if filter == nil {
			return errors.New("ToolQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type toolPager struct {
	reverse bool
	order   *ToolOrder
	filter  func(*ToolQuery) (*ToolQuery, error)
}

func newToolPager(opts []ToolPaginateOption, reverse bool) (*toolPager, error) {
	pager := &toolPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultToolOrder
	}
	return pager, nil
}

func (p *toolPager) applyFilter(query *ToolQuery) (*ToolQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *toolPager) toCursor(t *Tool) Cursor {
	return p.order.Field.toCursor(t)
}

func (p *toolPager) applyCursors(query *ToolQuery, after, before *Cursor) (*ToolQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultToolOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *toolPager) applyOrder(query *ToolQuery) *ToolQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultToolOrder.Field {
		query = query.Order(DefaultToolOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *toolPager) orderExpr(query *ToolQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultToolOrder.Field {
			b.Comma().Ident(DefaultToolOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Tool.
func (t *ToolQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...ToolPaginateOption,
) (*ToolConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newToolPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if t, err = pager.applyFilter(t); err != nil {
		return nil, err
	}
	conn := &ToolConnection{Edges: []*ToolEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = t.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if t, err = pager.applyCursors(t, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		t.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := t.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	t = pager.applyOrder(t)
	nodes, err := t.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// ToolOrderFieldIndx orders Tool by indx.
	ToolOrderFieldIndx = &ToolOrderField{
		Value: func(t *Tool) (ent.Value, error) {
			return t.Indx, nil
		},
		column: tool.FieldIndx,
		toTerm: tool.ByIndx,
		toCursor: func(t *Tool) Cursor {
			return Cursor{
				ID:    t.ID,
				Value: t.Indx,
			}
		},
	}
	// ToolOrderFieldName orders Tool by name.
	ToolOrderFieldName = &ToolOrderField{
		Value: func(t *Tool) (ent.Value, error) {
			return t.Name, nil
		},
		column: tool.FieldName,
		toTerm: tool.ByName,
		toCursor: func(t *Tool) Cursor {
			return Cursor{
				ID:    t.ID,
				Value: t.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f ToolOrderField) String() string {
	var str string
	switch f.column {
	case ToolOrderFieldIndx.column:
		str = "INDX"
	case ToolOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f ToolOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *ToolOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("ToolOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *ToolOrderFieldIndx
	case "NAME":
		*f = *ToolOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid ToolOrderField", str)
	}
	return nil
}

// ToolOrderField defines the ordering field of Tool.
type ToolOrderField struct {
	// Value extracts the ordering value from the given Tool.
	Value    func(*Tool) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) tool.OrderOption
	toCursor func(*Tool) Cursor
}

// ToolOrder defines the ordering of Tool.
type ToolOrder struct {
	Direction OrderDirection  `json:"direction"`
	Field     *ToolOrderField `json:"field"`
}

// DefaultToolOrder is the default ordering of Tool.
var DefaultToolOrder = &ToolOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &ToolOrderField{
		Value: func(t *Tool) (ent.Value, error) {
			return t.ID, nil
		},
		column: tool.FieldID,
		toTerm: tool.ByID,
		toCursor: func(t *Tool) Cursor {
			return Cursor{ID: t.ID}
		},
	},
}

// ToEdge converts Tool into ToolEdge.
func (t *Tool) ToEdge(order *ToolOrder) *ToolEdge {
	if order == nil {
		order = DefaultToolOrder
	}
	return &ToolEdge{
		Node:   t,
		Cursor: order.Field.toCursor(t),
	}
}

// TraitEdge is the edge representation of Trait.
type TraitEdge struct {
	Node   *Trait `json:"node"`
	Cursor Cursor `json:"cursor"`
}

// TraitConnection is the connection containing edges to Trait.
type TraitConnection struct {
	Edges      []*TraitEdge `json:"edges"`
	PageInfo   PageInfo     `json:"pageInfo"`
	TotalCount int          `json:"totalCount"`
}

func (c *TraitConnection) build(nodes []*Trait, pager *traitPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Trait
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Trait {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Trait {
			return nodes[i]
		}
	}
	c.Edges = make([]*TraitEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &TraitEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// TraitPaginateOption enables pagination customization.
type TraitPaginateOption func(*traitPager) error

// WithTraitOrder configures pagination ordering.
func WithTraitOrder(order *TraitOrder) TraitPaginateOption {
	if order == nil {
		order = DefaultTraitOrder
	}
	o := *order
	return func(pager *traitPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultTraitOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithTraitFilter configures pagination filter.
func WithTraitFilter(filter func(*TraitQuery) (*TraitQuery, error)) TraitPaginateOption {
	return func(pager *traitPager) error {
		if filter == nil {
			return errors.New("TraitQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type traitPager struct {
	reverse bool
	order   *TraitOrder
	filter  func(*TraitQuery) (*TraitQuery, error)
}

func newTraitPager(opts []TraitPaginateOption, reverse bool) (*traitPager, error) {
	pager := &traitPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultTraitOrder
	}
	return pager, nil
}

func (p *traitPager) applyFilter(query *TraitQuery) (*TraitQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *traitPager) toCursor(t *Trait) Cursor {
	return p.order.Field.toCursor(t)
}

func (p *traitPager) applyCursors(query *TraitQuery, after, before *Cursor) (*TraitQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultTraitOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *traitPager) applyOrder(query *TraitQuery) *TraitQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultTraitOrder.Field {
		query = query.Order(DefaultTraitOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *traitPager) orderExpr(query *TraitQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultTraitOrder.Field {
			b.Comma().Ident(DefaultTraitOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Trait.
func (t *TraitQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...TraitPaginateOption,
) (*TraitConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newTraitPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if t, err = pager.applyFilter(t); err != nil {
		return nil, err
	}
	conn := &TraitConnection{Edges: []*TraitEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = t.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if t, err = pager.applyCursors(t, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		t.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := t.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	t = pager.applyOrder(t)
	nodes, err := t.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// TraitOrderFieldIndx orders Trait by indx.
	TraitOrderFieldIndx = &TraitOrderField{
		Value: func(t *Trait) (ent.Value, error) {
			return t.Indx, nil
		},
		column: trait.FieldIndx,
		toTerm: trait.ByIndx,
		toCursor: func(t *Trait) Cursor {
			return Cursor{
				ID:    t.ID,
				Value: t.Indx,
			}
		},
	}
	// TraitOrderFieldName orders Trait by name.
	TraitOrderFieldName = &TraitOrderField{
		Value: func(t *Trait) (ent.Value, error) {
			return t.Name, nil
		},
		column: trait.FieldName,
		toTerm: trait.ByName,
		toCursor: func(t *Trait) Cursor {
			return Cursor{
				ID:    t.ID,
				Value: t.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f TraitOrderField) String() string {
	var str string
	switch f.column {
	case TraitOrderFieldIndx.column:
		str = "INDX"
	case TraitOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f TraitOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *TraitOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("TraitOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *TraitOrderFieldIndx
	case "NAME":
		*f = *TraitOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid TraitOrderField", str)
	}
	return nil
}

// TraitOrderField defines the ordering field of Trait.
type TraitOrderField struct {
	// Value extracts the ordering value from the given Trait.
	Value    func(*Trait) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) trait.OrderOption
	toCursor func(*Trait) Cursor
}

// TraitOrder defines the ordering of Trait.
type TraitOrder struct {
	Direction OrderDirection   `json:"direction"`
	Field     *TraitOrderField `json:"field"`
}

// DefaultTraitOrder is the default ordering of Trait.
var DefaultTraitOrder = &TraitOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &TraitOrderField{
		Value: func(t *Trait) (ent.Value, error) {
			return t.ID, nil
		},
		column: trait.FieldID,
		toTerm: trait.ByID,
		toCursor: func(t *Trait) Cursor {
			return Cursor{ID: t.ID}
		},
	},
}

// ToEdge converts Trait into TraitEdge.
func (t *Trait) ToEdge(order *TraitOrder) *TraitEdge {
	if order == nil {
		order = DefaultTraitOrder
	}
	return &TraitEdge{
		Node:   t,
		Cursor: order.Field.toCursor(t),
	}
}

// VehicleEdge is the edge representation of Vehicle.
type VehicleEdge struct {
	Node   *Vehicle `json:"node"`
	Cursor Cursor   `json:"cursor"`
}

// VehicleConnection is the connection containing edges to Vehicle.
type VehicleConnection struct {
	Edges      []*VehicleEdge `json:"edges"`
	PageInfo   PageInfo       `json:"pageInfo"`
	TotalCount int            `json:"totalCount"`
}

func (c *VehicleConnection) build(nodes []*Vehicle, pager *vehiclePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Vehicle
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Vehicle {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Vehicle {
			return nodes[i]
		}
	}
	c.Edges = make([]*VehicleEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &VehicleEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// VehiclePaginateOption enables pagination customization.
type VehiclePaginateOption func(*vehiclePager) error

// WithVehicleOrder configures pagination ordering.
func WithVehicleOrder(order *VehicleOrder) VehiclePaginateOption {
	if order == nil {
		order = DefaultVehicleOrder
	}
	o := *order
	return func(pager *vehiclePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultVehicleOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithVehicleFilter configures pagination filter.
func WithVehicleFilter(filter func(*VehicleQuery) (*VehicleQuery, error)) VehiclePaginateOption {
	return func(pager *vehiclePager) error {
		if filter == nil {
			return errors.New("VehicleQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type vehiclePager struct {
	reverse bool
	order   *VehicleOrder
	filter  func(*VehicleQuery) (*VehicleQuery, error)
}

func newVehiclePager(opts []VehiclePaginateOption, reverse bool) (*vehiclePager, error) {
	pager := &vehiclePager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultVehicleOrder
	}
	return pager, nil
}

func (p *vehiclePager) applyFilter(query *VehicleQuery) (*VehicleQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *vehiclePager) toCursor(v *Vehicle) Cursor {
	return p.order.Field.toCursor(v)
}

func (p *vehiclePager) applyCursors(query *VehicleQuery, after, before *Cursor) (*VehicleQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultVehicleOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *vehiclePager) applyOrder(query *VehicleQuery) *VehicleQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultVehicleOrder.Field {
		query = query.Order(DefaultVehicleOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *vehiclePager) orderExpr(query *VehicleQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultVehicleOrder.Field {
			b.Comma().Ident(DefaultVehicleOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Vehicle.
func (v *VehicleQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...VehiclePaginateOption,
) (*VehicleConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newVehiclePager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if v, err = pager.applyFilter(v); err != nil {
		return nil, err
	}
	conn := &VehicleConnection{Edges: []*VehicleEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = v.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if v, err = pager.applyCursors(v, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		v.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := v.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	v = pager.applyOrder(v)
	nodes, err := v.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// VehicleOrderFieldIndx orders Vehicle by indx.
	VehicleOrderFieldIndx = &VehicleOrderField{
		Value: func(v *Vehicle) (ent.Value, error) {
			return v.Indx, nil
		},
		column: vehicle.FieldIndx,
		toTerm: vehicle.ByIndx,
		toCursor: func(v *Vehicle) Cursor {
			return Cursor{
				ID:    v.ID,
				Value: v.Indx,
			}
		},
	}
	// VehicleOrderFieldName orders Vehicle by name.
	VehicleOrderFieldName = &VehicleOrderField{
		Value: func(v *Vehicle) (ent.Value, error) {
			return v.Name, nil
		},
		column: vehicle.FieldName,
		toTerm: vehicle.ByName,
		toCursor: func(v *Vehicle) Cursor {
			return Cursor{
				ID:    v.ID,
				Value: v.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f VehicleOrderField) String() string {
	var str string
	switch f.column {
	case VehicleOrderFieldIndx.column:
		str = "INDX"
	case VehicleOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f VehicleOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *VehicleOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("VehicleOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *VehicleOrderFieldIndx
	case "NAME":
		*f = *VehicleOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid VehicleOrderField", str)
	}
	return nil
}

// VehicleOrderField defines the ordering field of Vehicle.
type VehicleOrderField struct {
	// Value extracts the ordering value from the given Vehicle.
	Value    func(*Vehicle) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) vehicle.OrderOption
	toCursor func(*Vehicle) Cursor
}

// VehicleOrder defines the ordering of Vehicle.
type VehicleOrder struct {
	Direction OrderDirection     `json:"direction"`
	Field     *VehicleOrderField `json:"field"`
}

// DefaultVehicleOrder is the default ordering of Vehicle.
var DefaultVehicleOrder = &VehicleOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &VehicleOrderField{
		Value: func(v *Vehicle) (ent.Value, error) {
			return v.ID, nil
		},
		column: vehicle.FieldID,
		toTerm: vehicle.ByID,
		toCursor: func(v *Vehicle) Cursor {
			return Cursor{ID: v.ID}
		},
	},
}

// ToEdge converts Vehicle into VehicleEdge.
func (v *Vehicle) ToEdge(order *VehicleOrder) *VehicleEdge {
	if order == nil {
		order = DefaultVehicleOrder
	}
	return &VehicleEdge{
		Node:   v,
		Cursor: order.Field.toCursor(v),
	}
}

// WeaponEdge is the edge representation of Weapon.
type WeaponEdge struct {
	Node   *Weapon `json:"node"`
	Cursor Cursor  `json:"cursor"`
}

// WeaponConnection is the connection containing edges to Weapon.
type WeaponConnection struct {
	Edges      []*WeaponEdge `json:"edges"`
	PageInfo   PageInfo      `json:"pageInfo"`
	TotalCount int           `json:"totalCount"`
}

func (c *WeaponConnection) build(nodes []*Weapon, pager *weaponPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *Weapon
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *Weapon {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *Weapon {
			return nodes[i]
		}
	}
	c.Edges = make([]*WeaponEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &WeaponEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// WeaponPaginateOption enables pagination customization.
type WeaponPaginateOption func(*weaponPager) error

// WithWeaponOrder configures pagination ordering.
func WithWeaponOrder(order *WeaponOrder) WeaponPaginateOption {
	if order == nil {
		order = DefaultWeaponOrder
	}
	o := *order
	return func(pager *weaponPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultWeaponOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithWeaponFilter configures pagination filter.
func WithWeaponFilter(filter func(*WeaponQuery) (*WeaponQuery, error)) WeaponPaginateOption {
	return func(pager *weaponPager) error {
		if filter == nil {
			return errors.New("WeaponQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type weaponPager struct {
	reverse bool
	order   *WeaponOrder
	filter  func(*WeaponQuery) (*WeaponQuery, error)
}

func newWeaponPager(opts []WeaponPaginateOption, reverse bool) (*weaponPager, error) {
	pager := &weaponPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultWeaponOrder
	}
	return pager, nil
}

func (p *weaponPager) applyFilter(query *WeaponQuery) (*WeaponQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *weaponPager) toCursor(w *Weapon) Cursor {
	return p.order.Field.toCursor(w)
}

func (p *weaponPager) applyCursors(query *WeaponQuery, after, before *Cursor) (*WeaponQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultWeaponOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *weaponPager) applyOrder(query *WeaponQuery) *WeaponQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultWeaponOrder.Field {
		query = query.Order(DefaultWeaponOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *weaponPager) orderExpr(query *WeaponQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultWeaponOrder.Field {
			b.Comma().Ident(DefaultWeaponOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to Weapon.
func (w *WeaponQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...WeaponPaginateOption,
) (*WeaponConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newWeaponPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if w, err = pager.applyFilter(w); err != nil {
		return nil, err
	}
	conn := &WeaponConnection{Edges: []*WeaponEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = w.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if w, err = pager.applyCursors(w, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		w.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := w.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	w = pager.applyOrder(w)
	nodes, err := w.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// WeaponOrderFieldIndx orders Weapon by indx.
	WeaponOrderFieldIndx = &WeaponOrderField{
		Value: func(w *Weapon) (ent.Value, error) {
			return w.Indx, nil
		},
		column: weapon.FieldIndx,
		toTerm: weapon.ByIndx,
		toCursor: func(w *Weapon) Cursor {
			return Cursor{
				ID:    w.ID,
				Value: w.Indx,
			}
		},
	}
	// WeaponOrderFieldName orders Weapon by name.
	WeaponOrderFieldName = &WeaponOrderField{
		Value: func(w *Weapon) (ent.Value, error) {
			return w.Name, nil
		},
		column: weapon.FieldName,
		toTerm: weapon.ByName,
		toCursor: func(w *Weapon) Cursor {
			return Cursor{
				ID:    w.ID,
				Value: w.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f WeaponOrderField) String() string {
	var str string
	switch f.column {
	case WeaponOrderFieldIndx.column:
		str = "INDX"
	case WeaponOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f WeaponOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *WeaponOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("WeaponOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *WeaponOrderFieldIndx
	case "NAME":
		*f = *WeaponOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid WeaponOrderField", str)
	}
	return nil
}

// WeaponOrderField defines the ordering field of Weapon.
type WeaponOrderField struct {
	// Value extracts the ordering value from the given Weapon.
	Value    func(*Weapon) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) weapon.OrderOption
	toCursor func(*Weapon) Cursor
}

// WeaponOrder defines the ordering of Weapon.
type WeaponOrder struct {
	Direction OrderDirection    `json:"direction"`
	Field     *WeaponOrderField `json:"field"`
}

// DefaultWeaponOrder is the default ordering of Weapon.
var DefaultWeaponOrder = &WeaponOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &WeaponOrderField{
		Value: func(w *Weapon) (ent.Value, error) {
			return w.ID, nil
		},
		column: weapon.FieldID,
		toTerm: weapon.ByID,
		toCursor: func(w *Weapon) Cursor {
			return Cursor{ID: w.ID}
		},
	},
}

// ToEdge converts Weapon into WeaponEdge.
func (w *Weapon) ToEdge(order *WeaponOrder) *WeaponEdge {
	if order == nil {
		order = DefaultWeaponOrder
	}
	return &WeaponEdge{
		Node:   w,
		Cursor: order.Field.toCursor(w),
	}
}

// WeaponDamageEdge is the edge representation of WeaponDamage.
type WeaponDamageEdge struct {
	Node   *WeaponDamage `json:"node"`
	Cursor Cursor        `json:"cursor"`
}

// WeaponDamageConnection is the connection containing edges to WeaponDamage.
type WeaponDamageConnection struct {
	Edges      []*WeaponDamageEdge `json:"edges"`
	PageInfo   PageInfo            `json:"pageInfo"`
	TotalCount int                 `json:"totalCount"`
}

func (c *WeaponDamageConnection) build(nodes []*WeaponDamage, pager *weapondamagePager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *WeaponDamage
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *WeaponDamage {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *WeaponDamage {
			return nodes[i]
		}
	}
	c.Edges = make([]*WeaponDamageEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &WeaponDamageEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// WeaponDamagePaginateOption enables pagination customization.
type WeaponDamagePaginateOption func(*weapondamagePager) error

// WithWeaponDamageOrder configures pagination ordering.
func WithWeaponDamageOrder(order *WeaponDamageOrder) WeaponDamagePaginateOption {
	if order == nil {
		order = DefaultWeaponDamageOrder
	}
	o := *order
	return func(pager *weapondamagePager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultWeaponDamageOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithWeaponDamageFilter configures pagination filter.
func WithWeaponDamageFilter(filter func(*WeaponDamageQuery) (*WeaponDamageQuery, error)) WeaponDamagePaginateOption {
	return func(pager *weapondamagePager) error {
		if filter == nil {
			return errors.New("WeaponDamageQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type weapondamagePager struct {
	reverse bool
	order   *WeaponDamageOrder
	filter  func(*WeaponDamageQuery) (*WeaponDamageQuery, error)
}

func newWeaponDamagePager(opts []WeaponDamagePaginateOption, reverse bool) (*weapondamagePager, error) {
	pager := &weapondamagePager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultWeaponDamageOrder
	}
	return pager, nil
}

func (p *weapondamagePager) applyFilter(query *WeaponDamageQuery) (*WeaponDamageQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *weapondamagePager) toCursor(wd *WeaponDamage) Cursor {
	return p.order.Field.toCursor(wd)
}

func (p *weapondamagePager) applyCursors(query *WeaponDamageQuery, after, before *Cursor) (*WeaponDamageQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultWeaponDamageOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *weapondamagePager) applyOrder(query *WeaponDamageQuery) *WeaponDamageQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultWeaponDamageOrder.Field {
		query = query.Order(DefaultWeaponDamageOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *weapondamagePager) orderExpr(query *WeaponDamageQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultWeaponDamageOrder.Field {
			b.Comma().Ident(DefaultWeaponDamageOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to WeaponDamage.
func (wd *WeaponDamageQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...WeaponDamagePaginateOption,
) (*WeaponDamageConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newWeaponDamagePager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if wd, err = pager.applyFilter(wd); err != nil {
		return nil, err
	}
	conn := &WeaponDamageConnection{Edges: []*WeaponDamageEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = wd.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if wd, err = pager.applyCursors(wd, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		wd.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := wd.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	wd = pager.applyOrder(wd)
	nodes, err := wd.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

// WeaponDamageOrderField defines the ordering field of WeaponDamage.
type WeaponDamageOrderField struct {
	// Value extracts the ordering value from the given WeaponDamage.
	Value    func(*WeaponDamage) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) weapondamage.OrderOption
	toCursor func(*WeaponDamage) Cursor
}

// WeaponDamageOrder defines the ordering of WeaponDamage.
type WeaponDamageOrder struct {
	Direction OrderDirection          `json:"direction"`
	Field     *WeaponDamageOrderField `json:"field"`
}

// DefaultWeaponDamageOrder is the default ordering of WeaponDamage.
var DefaultWeaponDamageOrder = &WeaponDamageOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &WeaponDamageOrderField{
		Value: func(wd *WeaponDamage) (ent.Value, error) {
			return wd.ID, nil
		},
		column: weapondamage.FieldID,
		toTerm: weapondamage.ByID,
		toCursor: func(wd *WeaponDamage) Cursor {
			return Cursor{ID: wd.ID}
		},
	},
}

// ToEdge converts WeaponDamage into WeaponDamageEdge.
func (wd *WeaponDamage) ToEdge(order *WeaponDamageOrder) *WeaponDamageEdge {
	if order == nil {
		order = DefaultWeaponDamageOrder
	}
	return &WeaponDamageEdge{
		Node:   wd,
		Cursor: order.Field.toCursor(wd),
	}
}

// WeaponPropertyEdge is the edge representation of WeaponProperty.
type WeaponPropertyEdge struct {
	Node   *WeaponProperty `json:"node"`
	Cursor Cursor          `json:"cursor"`
}

// WeaponPropertyConnection is the connection containing edges to WeaponProperty.
type WeaponPropertyConnection struct {
	Edges      []*WeaponPropertyEdge `json:"edges"`
	PageInfo   PageInfo              `json:"pageInfo"`
	TotalCount int                   `json:"totalCount"`
}

func (c *WeaponPropertyConnection) build(nodes []*WeaponProperty, pager *weaponpropertyPager, after *Cursor, first *int, before *Cursor, last *int) {
	c.PageInfo.HasNextPage = before != nil
	c.PageInfo.HasPreviousPage = after != nil
	if first != nil && *first+1 == len(nodes) {
		c.PageInfo.HasNextPage = true
		nodes = nodes[:len(nodes)-1]
	} else if last != nil && *last+1 == len(nodes) {
		c.PageInfo.HasPreviousPage = true
		nodes = nodes[:len(nodes)-1]
	}
	var nodeAt func(int) *WeaponProperty
	if last != nil {
		n := len(nodes) - 1
		nodeAt = func(i int) *WeaponProperty {
			return nodes[n-i]
		}
	} else {
		nodeAt = func(i int) *WeaponProperty {
			return nodes[i]
		}
	}
	c.Edges = make([]*WeaponPropertyEdge, len(nodes))
	for i := range nodes {
		node := nodeAt(i)
		c.Edges[i] = &WeaponPropertyEdge{
			Node:   node,
			Cursor: pager.toCursor(node),
		}
	}
	if l := len(c.Edges); l > 0 {
		c.PageInfo.StartCursor = &c.Edges[0].Cursor
		c.PageInfo.EndCursor = &c.Edges[l-1].Cursor
	}
	if c.TotalCount == 0 {
		c.TotalCount = len(nodes)
	}
}

// WeaponPropertyPaginateOption enables pagination customization.
type WeaponPropertyPaginateOption func(*weaponpropertyPager) error

// WithWeaponPropertyOrder configures pagination ordering.
func WithWeaponPropertyOrder(order *WeaponPropertyOrder) WeaponPropertyPaginateOption {
	if order == nil {
		order = DefaultWeaponPropertyOrder
	}
	o := *order
	return func(pager *weaponpropertyPager) error {
		if err := o.Direction.Validate(); err != nil {
			return err
		}
		if o.Field == nil {
			o.Field = DefaultWeaponPropertyOrder.Field
		}
		pager.order = &o
		return nil
	}
}

// WithWeaponPropertyFilter configures pagination filter.
func WithWeaponPropertyFilter(filter func(*WeaponPropertyQuery) (*WeaponPropertyQuery, error)) WeaponPropertyPaginateOption {
	return func(pager *weaponpropertyPager) error {
		if filter == nil {
			return errors.New("WeaponPropertyQuery filter cannot be nil")
		}
		pager.filter = filter
		return nil
	}
}

type weaponpropertyPager struct {
	reverse bool
	order   *WeaponPropertyOrder
	filter  func(*WeaponPropertyQuery) (*WeaponPropertyQuery, error)
}

func newWeaponPropertyPager(opts []WeaponPropertyPaginateOption, reverse bool) (*weaponpropertyPager, error) {
	pager := &weaponpropertyPager{reverse: reverse}
	for _, opt := range opts {
		if err := opt(pager); err != nil {
			return nil, err
		}
	}
	if pager.order == nil {
		pager.order = DefaultWeaponPropertyOrder
	}
	return pager, nil
}

func (p *weaponpropertyPager) applyFilter(query *WeaponPropertyQuery) (*WeaponPropertyQuery, error) {
	if p.filter != nil {
		return p.filter(query)
	}
	return query, nil
}

func (p *weaponpropertyPager) toCursor(wp *WeaponProperty) Cursor {
	return p.order.Field.toCursor(wp)
}

func (p *weaponpropertyPager) applyCursors(query *WeaponPropertyQuery, after, before *Cursor) (*WeaponPropertyQuery, error) {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	for _, predicate := range entgql.CursorsPredicate(after, before, DefaultWeaponPropertyOrder.Field.column, p.order.Field.column, direction) {
		query = query.Where(predicate)
	}
	return query, nil
}

func (p *weaponpropertyPager) applyOrder(query *WeaponPropertyQuery) *WeaponPropertyQuery {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	query = query.Order(p.order.Field.toTerm(direction.OrderTermOption()))
	if p.order.Field != DefaultWeaponPropertyOrder.Field {
		query = query.Order(DefaultWeaponPropertyOrder.Field.toTerm(direction.OrderTermOption()))
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return query
}

func (p *weaponpropertyPager) orderExpr(query *WeaponPropertyQuery) sql.Querier {
	direction := p.order.Direction
	if p.reverse {
		direction = direction.Reverse()
	}
	if len(query.ctx.Fields) > 0 {
		query.ctx.AppendFieldOnce(p.order.Field.column)
	}
	return sql.ExprFunc(func(b *sql.Builder) {
		b.Ident(p.order.Field.column).Pad().WriteString(string(direction))
		if p.order.Field != DefaultWeaponPropertyOrder.Field {
			b.Comma().Ident(DefaultWeaponPropertyOrder.Field.column).Pad().WriteString(string(direction))
		}
	})
}

// Paginate executes the query and returns a relay based cursor connection to WeaponProperty.
func (wp *WeaponPropertyQuery) Paginate(
	ctx context.Context, after *Cursor, first *int,
	before *Cursor, last *int, opts ...WeaponPropertyPaginateOption,
) (*WeaponPropertyConnection, error) {
	if err := validateFirstLast(first, last); err != nil {
		return nil, err
	}
	pager, err := newWeaponPropertyPager(opts, last != nil)
	if err != nil {
		return nil, err
	}
	if wp, err = pager.applyFilter(wp); err != nil {
		return nil, err
	}
	conn := &WeaponPropertyConnection{Edges: []*WeaponPropertyEdge{}}
	ignoredEdges := !hasCollectedField(ctx, edgesField)
	if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) {
		hasPagination := after != nil || first != nil || before != nil || last != nil
		if hasPagination || ignoredEdges {
			if conn.TotalCount, err = wp.Clone().Count(ctx); err != nil {
				return nil, err
			}
			conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0
			conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0
		}
	}
	if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) {
		return conn, nil
	}
	if wp, err = pager.applyCursors(wp, after, before); err != nil {
		return nil, err
	}
	if limit := paginateLimit(first, last); limit != 0 {
		wp.Limit(limit)
	}
	if field := collectedField(ctx, edgesField, nodeField); field != nil {
		if err := wp.collectField(ctx, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil {
			return nil, err
		}
	}
	wp = pager.applyOrder(wp)
	nodes, err := wp.All(ctx)
	if err != nil {
		return nil, err
	}
	conn.build(nodes, pager, after, first, before, last)
	return conn, nil
}

var (
	// WeaponPropertyOrderFieldIndx orders WeaponProperty by indx.
	WeaponPropertyOrderFieldIndx = &WeaponPropertyOrderField{
		Value: func(wp *WeaponProperty) (ent.Value, error) {
			return wp.Indx, nil
		},
		column: weaponproperty.FieldIndx,
		toTerm: weaponproperty.ByIndx,
		toCursor: func(wp *WeaponProperty) Cursor {
			return Cursor{
				ID:    wp.ID,
				Value: wp.Indx,
			}
		},
	}
	// WeaponPropertyOrderFieldName orders WeaponProperty by name.
	WeaponPropertyOrderFieldName = &WeaponPropertyOrderField{
		Value: func(wp *WeaponProperty) (ent.Value, error) {
			return wp.Name, nil
		},
		column: weaponproperty.FieldName,
		toTerm: weaponproperty.ByName,
		toCursor: func(wp *WeaponProperty) Cursor {
			return Cursor{
				ID:    wp.ID,
				Value: wp.Name,
			}
		},
	}
)

// String implement fmt.Stringer interface.
func (f WeaponPropertyOrderField) String() string {
	var str string
	switch f.column {
	case WeaponPropertyOrderFieldIndx.column:
		str = "INDX"
	case WeaponPropertyOrderFieldName.column:
		str = "NAME"
	}
	return str
}

// MarshalGQL implements graphql.Marshaler interface.
func (f WeaponPropertyOrderField) MarshalGQL(w io.Writer) {
	io.WriteString(w, strconv.Quote(f.String()))
}

// UnmarshalGQL implements graphql.Unmarshaler interface.
func (f *WeaponPropertyOrderField) UnmarshalGQL(v interface{}) error {
	str, ok := v.(string)
	if !ok {
		return fmt.Errorf("WeaponPropertyOrderField %T must be a string", v)
	}
	switch str {
	case "INDX":
		*f = *WeaponPropertyOrderFieldIndx
	case "NAME":
		*f = *WeaponPropertyOrderFieldName
	default:
		return fmt.Errorf("%s is not a valid WeaponPropertyOrderField", str)
	}
	return nil
}

// WeaponPropertyOrderField defines the ordering field of WeaponProperty.
type WeaponPropertyOrderField struct {
	// Value extracts the ordering value from the given WeaponProperty.
	Value    func(*WeaponProperty) (ent.Value, error)
	column   string // field or computed.
	toTerm   func(...sql.OrderTermOption) weaponproperty.OrderOption
	toCursor func(*WeaponProperty) Cursor
}

// WeaponPropertyOrder defines the ordering of WeaponProperty.
type WeaponPropertyOrder struct {
	Direction OrderDirection            `json:"direction"`
	Field     *WeaponPropertyOrderField `json:"field"`
}

// DefaultWeaponPropertyOrder is the default ordering of WeaponProperty.
var DefaultWeaponPropertyOrder = &WeaponPropertyOrder{
	Direction: entgql.OrderDirectionAsc,
	Field: &WeaponPropertyOrderField{
		Value: func(wp *WeaponProperty) (ent.Value, error) {
			return wp.ID, nil
		},
		column: weaponproperty.FieldID,
		toTerm: weaponproperty.ByID,
		toCursor: func(wp *WeaponProperty) Cursor {
			return Cursor{ID: wp.ID}
		},
	},
}

// ToEdge converts WeaponProperty into WeaponPropertyEdge.
func (wp *WeaponProperty) ToEdge(order *WeaponPropertyOrder) *WeaponPropertyEdge {
	if order == nil {
		order = DefaultWeaponPropertyOrder
	}
	return &WeaponPropertyEdge{
		Node:   wp,
		Cursor: order.Field.toCursor(wp),
	}
}