gqlx

type ArgDef struct {
	Name     string
	Type     GQLType
	Default  any
	Required bool
}

type Argument struct {
	Name  string
	Value Value
}

type AuthFunc func(ctx context.Context) string

type BoolValue struct{ V bool }

type Directive struct {
	Name      string
	Arguments []*Argument
}

type Document struct {
	Operations []*Operation
	Fragments  []*FragmentDef
}

type EnumType struct {
	Name        string
	Description string
	// contains filtered or unexported fields
}

type EnumValue struct{ V string }

type EnumValueDef struct {
	Name        string
	Description string
	Deprecation string
}

type ExecuteOptions struct {
	Validate           ValidateOptions
	AllowIntrospection bool

	// MaxResolvedFields bounds the TOTAL number of fields the executor
	// resolves for one operation, counting every field reached through
	// fragment spreads, inline fragments, nested selections, and list
	// elements. It is the executor's own defense-in-depth against
	// fragment bombs: the validator already memoizes fragment cost
	// (PERF-0064), but a caller that disables the complexity limits can
	// still hand the executor a document whose expansion is exponential
	// in document size (the executor re-walks fragment selections per
	// spread site — memoizing results would be wrong, the result differs
	// per spread site). When the budget is exhausted execution halts and
	// the response carries a single ErrResolvedFieldLimit error.
	// PERF-0075.
	//
	// Zero applies DefaultMaxResolvedFields; a negative value disables
	// the budget.
	MaxResolvedFields int
}

type Field struct {
	Alias      string
	Name       string
	Arguments  []*Argument
	Directives []*Directive
	Selections []Selection
}

type FieldDef struct {
	Type        GQLType
	Args        []ArgDef
	Description string
	Auth        string
	RateLimit   int
	Resolve     ResolverFunc
	Subscribe   SubscribeFunc
	// contains filtered or unexported fields
}

type FloatValue struct{ V float64 }

type FragmentDef struct {
	Name          string
	TypeCondition string
	Directives    []*Directive
	Selections    []Selection
}

type FragmentSpread struct {
	Name       string
	Directives []*Directive
}

type GQLError struct {
	Message    string         `json:"message"`
	Locations  []Location     `json:"locations,omitempty"`
	Path       []any          `json:"path,omitempty"`
	Extensions map[string]any `json:"extensions,omitempty"`
	// contains filtered or unexported fields
}

type GQLType interface {
	TypeName() string
	// contains filtered or unexported methods
}

type Handler struct {
	// contains filtered or unexported fields
}

type HandlerOptions struct {
	Timeout       time.Duration
	MaxQueryBytes int
	MaxBatchSize  int
	MaxDepth      int
	MaxComplexity int
	MaxAliases    int

	// AllowIntrospection, when true, lets the handler accept root-level
	// __schema and __type selections and resolves them against the
	// loaded Schema. Defaults to false so an accidental rebuild does not
	// expose a previously-protected surface. Pair with an admin-only
	// auth check on the route.
	AllowIntrospection bool

	// MaxResolvedFields bounds the TOTAL number of fields the executor
	// may resolve for a single handler-served request, mirroring
	// ExecuteOptions.MaxResolvedFields (PERF-0075). Zero applies
	// DefaultMaxResolvedFields; a negative value disables the budget.
	MaxResolvedFields int

	// DocCacheSize bounds the per-Handler LRU cache of parsed+validated
	// documents keyed by raw query string (PERF-0058). The zero value
	// selects the default of 256 entries; a negative value disables the
	// cache so every request re-parses and re-validates. The MaxQueryBytes
	// gate runs in front of the cache, so cache keys are bounded and an
	// attacker streaming unique oversized queries cannot grow the cache.
	DocCacheSize int

	// MaxBatchConcurrency bounds the number of batch elements handleBatch
	// executes concurrently (N-10), mirroring pkg/mcpx's
	// batchMaxConcurrency semaphore for its own parallel tool-batch
	// dispatch. MaxBatchSize alone only bounds the TOTAL element count
	// per request, not how many run at once — every element previously
	// got its own unbounded goroutine, so an operator raising
	// MaxBatchSize (e.g. for a legitimately large trusted-client batch)
	// also raised the in-flight goroutine/resolver-concurrency ceiling by
	// the same amount with no separate control. A value <= 0 selects the
	// default of 8 (matching mcpx).
	MaxBatchConcurrency int
}

type InlineFragment struct {
	TypeCondition string
	Directives    []*Directive
	Selections    []Selection
}

type InputFieldDef struct {
	Type     GQLType
	Required bool
	Default  any
}

type InputObjectType struct {
	Name        string
	Description string
	// contains filtered or unexported fields
}

type IntValue struct{ V int64 }

type ListType struct {
	Elem GQLType
}

type ListValue struct{ Values []Value }

type Location struct {
	Line   int `json:"line"`
	Column int `json:"column"`
}

type NonNullType struct {
	Elem GQLType
}

type NullValue struct{}

type ObjectField struct {
	Name  string
	Value Value
}

type ObjectType struct {
	// contains filtered or unexported fields
}

type ObjectValue struct{ Fields []*ObjectField }

type Operation struct {
	Type       OperationType
	Name       string
	Variables  []*VariableDef
	Directives []*Directive
	Selections []Selection
}

type OperationType int

type ParseOptions struct {
	// AllowIntrospection, when true, lets __schema and __type appear as
	// root-level selections. Even with this disabled __typename remains
	// allowed in nested selections so client tooling that depends on
	// type-tagging continues to work.
	AllowIntrospection bool

	// MaxDepth caps the structural nesting depth (selection sets + list/object
	// argument values) the recursive-descent parser will descend before
	// aborting with ErrDepthExceeded. This is a DEFENSE against stack-overflow
	// DoS: the validator's MaxDepth runs only AFTER a full parse, so without
	// this a deeply-nested document crashes the process during parsing (a Go
	// stack overflow is a fatal throw that recover() cannot catch). 0 selects
	// defaultParseMaxDepth. Counts both selection and value nesting, so it is
	// intentionally larger than the selection-only validation MaxDepth. R2-1.
	MaxDepth int
}

type ResolverFunc func(ctx context.Context, args map[string]any) (any, error)

type Response struct {
	Data   any         `json:"data"`
	Errors []*GQLError `json:"errors,omitempty"`
}

type ScalarType struct {
	Name   string
	Coerce func(any) (any, error)
}

type Schema struct {
	Query        *ObjectType
	Mutation     *ObjectType
	Subscription *ObjectType

	// AuthFunc is called to enforce field-level auth. When a FieldDef has
	// a non-empty Auth string the executor calls AuthFunc; if it returns
	// "" the field is rejected with ErrAuthRequired.
	AuthFunc AuthFunc
}

type Selection interface {
	// contains filtered or unexported methods
}

type StringValue struct{ V string }

type SubscribeFunc func(ctx context.Context, args map[string]any) (<-chan any, error)

type SubscriptionHandler struct {
	// contains filtered or unexported fields
}

type SubscriptionOptions struct {
	MaxSubscriptions int
	ValidateOptions  ValidateOptions
	// IdleTimeout bounds how long the read loop will block waiting for the
	// next client frame. Without it a connected-but-idle (or slow-trickle)
	// client holds the read goroutine and socket forever — a slow-loris DoS,
	// since the GraphQL-WS path reads the raw net.Conn directly. 0 selects
	// defaultSubscriptionIdleTimeout. R2-2.
	IdleTimeout time.Duration
}

type Token struct {
	Kind  TokenKind
	Value string
	Line  int
	Col   int
}

type TokenKind int

type TypeRef struct {
	Name    string
	Elem    *TypeRef
	NonNull bool
}

type ValidateOptions struct {
	MaxDepth      int
	MaxComplexity int
	MaxAliases    int
}

type Value interface {
	// contains filtered or unexported methods
}

type VariableDef struct {
	Name    string
	Type    TypeRef
	Default Value
}

type VariableValue struct{ Name string }