resolve

type Array struct {
	Path     []string
	Nullable bool
	Item     Node

	SkipItem SkipArrayItem
}

type AsyncErrorWriter interface {
	WriteError(ctx *Context, err error, res *GraphQLResponse, w io.Writer)
}

type AsyncSubscriptionDataSource interface {
	AsyncStart(ctx *Context, id uint64, input []byte, updater SubscriptionUpdater) error
	AsyncStop(id uint64)
	UniqueRequestID(ctx *Context, input []byte, xxh *xxhash.Digest) (err error)
}

type AuthorizationDeny struct {
	Reason string
}

type Authorizer interface {
	// AuthorizePreFetch is called prior to making a fetch in the loader
	// This allows to implement policies to prevent fetches to an origin
	// E.g. for Mutations, it might be undesired to just filter out the response
	// You'd want to prevent sending the Operation to the Origin completely
	//
	// The input argument is the final render of the datasource input
	AuthorizePreFetch(ctx *Context, dataSourceID string, input json.RawMessage, coordinate GraphCoordinate) (result *AuthorizationDeny, err error)
	// AuthorizeObjectField operates on the response and can solely be used to implement policies to filter out response fields
	// In contrast to AuthorizePreFetch, this cannot be used to prevent origin requests
	// This function only allows you to filter the response before rendering it to the client
	//
	// The object argument is the flat render of the field-enclosing response object
	// Flat render means, we're only rendering scalars, not arrays or objects
	AuthorizeObjectField(ctx *Context, dataSourceID string, object json.RawMessage, coordinate GraphCoordinate) (result *AuthorizationDeny, err error)
	HasResponseExtensionData(ctx *Context) bool
	RenderResponseExtension(ctx *Context, out io.Writer) error
}

type BatchEntityFetch struct {
	FetchDependencies

	Input                BatchInput
	DataSource           DataSource
	PostProcessing       PostProcessingConfiguration
	DataSourceIdentifier []byte
	Trace                *DataSourceLoadTrace
	Info                 *FetchInfo
}

type BatchInput struct {
	Header InputTemplate
	Items  []InputTemplate
	// If SkipNullItems is set to true, items that render to null will not be included in the batch but skipped
	SkipNullItems bool
	// Same as SkipNullItems but for empty objects
	SkipEmptyObjectItems bool
	// If SkipErrItems is set to true, items that return an error during rendering will not be included in the batch but skipped
	// In this case, the error will be swallowed
	// E.g. if a field is not nullable and the value is null, the item will be skipped
	SkipErrItems bool
	Separator    InputTemplate
	Footer       InputTemplate
}

type BigInt struct {
	Path     []string
	Nullable bool
	Export   *FieldExport `json:"export,omitempty"`
}

type BodyData struct {
	Query         string          `json:"query,omitempty"`
	OperationName string          `json:"operationName,omitempty"`
	Variables     json.RawMessage `json:"variables,omitempty"`
}

type Boolean struct {
	Path     []string
	Nullable bool
	Export   *FieldExport `json:"export,omitempty"`
}

type BufPair struct {
	Data   *fastbuffer.FastBuffer
	Errors *fastbuffer.FastBuffer
}

type CSVVariableRenderer struct {
	Kind string
	// contains filtered or unexported fields
}

type ConnectDoneStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
	Network                  string `json:"network"`
	Addr                     string `json:"addr"`
	Err                      string `json:"err,omitempty"`
}

type ConnectStartStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
	Network                  string `json:"network"`
	Addr                     string `json:"addr"`
}

type Context struct {
	Variables        *astjson.Value
	Files            []*httpclient.FileUpload
	Request          Request
	RenameTypeNames  []RenameTypeName
	RemapVariables   map[string]string
	TracingOptions   TraceOptions
	RateLimitOptions RateLimitOptions
	ExecutionOptions ExecutionOptions
	InitialPayload   []byte
	Extensions       []byte
	LoaderHooks      LoaderHooks
	// contains filtered or unexported fields
}

type ContextVariable struct {
	Path     []string
	Renderer VariableRenderer
}

type CustomNode struct {
	CustomResolve

	Nullable bool
	Path     []string
}

type CustomResolve interface {
	Resolve(ctx *Context, value []byte) ([]byte, error)
}

type DNSDoneStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
}

type DNSStartStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
	Host                     string `json:"host"`
}

type DataSource interface {
	Load(ctx context.Context, input []byte, out *bytes.Buffer) (err error)
	LoadWithFiles(ctx context.Context, input []byte, files []*httpclient.FileUpload, out *bytes.Buffer) (err error)
}

type DataSourceInfo struct {
	ID   string
	Name string
}

type DataSourceLoadTrace struct {
	RawInputData               json.RawMessage `json:"raw_input_data,omitempty"`
	Input                      json.RawMessage `json:"input,omitempty"`
	Output                     json.RawMessage `json:"output,omitempty"`
	LoadError                  string          `json:"error,omitempty"`
	DurationSinceStartNano     int64           `json:"duration_since_start_nanoseconds,omitempty"`
	DurationSinceStartPretty   string          `json:"duration_since_start_pretty,omitempty"`
	DurationLoadNano           int64           `json:"duration_load_nanoseconds,omitempty"`
	DurationLoadPretty         string          `json:"duration_load_pretty,omitempty"`
	SingleFlightUsed           bool            `json:"single_flight_used"`
	SingleFlightSharedResponse bool            `json:"single_flight_shared_response"`
	LoadSkipped                bool            `json:"load_skipped"`
	LoadStats                  *LoadStats      `json:"load_stats,omitempty"`
	Path                       string          `json:"-"`
}

type DeferField struct{}

type EmptyArray struct{}

type EmptyObject struct{}

type EntityFetch struct {
	FetchDependencies

	Input                EntityInput
	DataSource           DataSource
	PostProcessing       PostProcessingConfiguration
	DataSourceIdentifier []byte
	Trace                *DataSourceLoadTrace
	Info                 *FetchInfo
}

type EntityInput struct {
	Header      InputTemplate
	Item        InputTemplate
	SkipErrItem bool
	Footer      InputTemplate
}

type Enum struct {
	Path               []string
	Nullable           bool
	Export             *FieldExport `json:"export,omitempty"`
	TypeName           string
	Values             []string
	InaccessibleValues []string
}

type ErrMergeResult struct {
	Subgraph string
	Reason   error
	Path     string
}

type ExecutionOptions struct {
	SkipLoader                 bool
	IncludeQueryPlanInResponse bool
	SendHeartbeat              bool
}

type Fetch interface {
	FetchKind() FetchKind
	Dependencies() *FetchDependencies

	// FetchInfo returns additional fetch-related information.
	// Callers must treat FetchInfo as read-only after planning; it may be nil when disabled by planner options.
	FetchInfo() *FetchInfo
}

type FetchConfiguration struct {
	Input      string
	Variables  Variables
	DataSource DataSource

	// RequiresParallelListItemFetch indicates that the single fetches should be executed without batching.
	// If we have multiple fetches attached to the object, then after post-processing of a plan
	// we will get ParallelListItemFetch instead of ParallelFetch.
	// Happens only for objects under the array path and used only for the introspection.
	RequiresParallelListItemFetch bool

	// RequiresEntityFetch will be set to true if the fetch is an entity fetch on an object.
	// After post-processing, we will get EntityFetch.
	RequiresEntityFetch bool

	// RequiresEntityBatchFetch indicates that entity fetches on array items should be batched.
	// After post-processing, we will get EntityBatchFetch.
	RequiresEntityBatchFetch bool

	// PostProcessing specifies the data and error extraction path in the response along with
	// the merge path where will insert the response.
	PostProcessing PostProcessingConfiguration

	// SetTemplateOutputToNullOnVariableNull will safely return "null" if one of the template variables renders to null
	// This is the case, e.g. when using batching and one sibling is null, resulting in a null value for one batch item
	// Returning null in this case tells the batch implementation to skip this item
	SetTemplateOutputToNullOnVariableNull bool

	QueryPlan *QueryPlan

	// OperationName is non-empty when the operation name is propagated to the upstream subgraph fetch.
	OperationName string
}

type FetchDependencies struct {
	FetchID           int
	DependsOnFetchIDs []int
}

type FetchDependency struct {
	// Coordinate is the type+field which depends on one or more FetchDependencyOrigin
	Coordinate GraphCoordinate `json:"coordinate"`
	// IsUserRequested is true if the field was requested by the user/client
	// If false, this indicates that the Coordinate is a dependency for another fetch
	IsUserRequested bool `json:"isUserRequested"`
	// DependsOn are the FetchDependencyOrigins the Coordinate depends on
	DependsOn []FetchDependencyOrigin `json:"dependsOn"`
}

type FetchDependencyOrigin struct {
	// FetchID is the fetch id providing the Coordinate
	FetchID int `json:"fetchId"`
	// Subgraph is the subgraph providing the Coordinate
	Subgraph string `json:"subgraph"`
	// Coordinate is the GraphCoordinate that another Coordinate depends on
	Coordinate GraphCoordinate `json:"coordinate"`
	// IsKey is true if the Coordinate is a @key dependency
	IsKey bool `json:"isKey"`
	// IsRequires is true if the Coordinate is a @requires dependency
	IsRequires bool `json:"isRequires"`
}

type FetchInfo struct {
	DataSourceID   string
	DataSourceName string
	RootFields     []GraphCoordinate
	OperationType  ast.OperationType
	QueryPlan      *QueryPlan

	// CoordinateDependencies contain a list of GraphCoordinates (typeName+fieldName)
	// and which fields from other fetches they depend on.
	// This information is useful to understand why a fetch depends on other fetches,
	// and how multiple dependencies lead to a chain of fetches
	CoordinateDependencies []FetchDependency

	// FetchReasons contains provenance for reasons why particular fields were fetched.
	// If this structure is built, then all the fields are processed.
	FetchReasons []FetchReason

	// PropagatedFetchReasons holds those FetchReasons that will be propagated
	// with the request to the subgraph as part of the "fetch_reason" extension.
	// Specifically, it is created only for fields stored in the DataSource.RequireFetchReasons().
	PropagatedFetchReasons []FetchReason
}

type FetchItem struct {
	Fetch                Fetch
	FetchPath            []FetchItemPathElement
	ResponsePath         string
	ResponsePathElements []string
}

type FetchItemPathElement struct {
	Kind      FetchItemPathElementKind
	Path      []string
	TypeNames []string
}

type FetchItemPathElementKind string

type FetchKind int

type FetchReason struct {
	TypeName    string   `json:"typename"`
	FieldName   string   `json:"field"`
	BySubgraphs []string `json:"by_subgraphs,omitempty"`
	ByUser      bool     `json:"by_user,omitempty"`
	IsKey       bool     `json:"is_key,omitempty"`
	IsRequires  bool     `json:"is_requires,omitempty"`
	Nullable    bool     `json:"-"`
}

type FetchTraceNode struct {
	Kind       string                 `json:"kind"`
	Path       string                 `json:"path"`
	SourceID   string                 `json:"source_id"`
	SourceName string                 `json:"source_name"`
	Trace      *DataSourceLoadTrace   `json:"trace,omitempty"`
	Traces     []*DataSourceLoadTrace `json:"traces,omitempty"`
}

type FetchTreeNode struct {
	Kind FetchTreeNodeKind `json:"kind"`
	// Trigger is only set for subscription
	Trigger         *FetchTreeNode   `json:"trigger"`
	Item            *FetchItem       `json:"item"`
	ChildNodes      []*FetchTreeNode `json:"child_nodes"`
	NormalizedQuery string           `json:"normalized_query"`
}

type FetchTreeNodeKind string

type FetchTreeQueryPlan struct {
	Kind              string            `json:"kind"`
	Path              string            `json:"path,omitempty"`
	SubgraphName      string            `json:"subgraphName"`
	SubgraphID        string            `json:"subgraphId"`
	FetchID           int               `json:"fetchId"`
	DependsOnFetchIDs []int             `json:"dependsOnFetchIds,omitempty"`
	Representations   []Representation  `json:"representations,omitempty"`
	Query             string            `json:"query,omitempty"`
	Dependencies      []FetchDependency `json:"dependencies,omitempty"`
}

type FetchTreeQueryPlanNode struct {
	Version         string                    `json:"version,omitempty"`
	Kind            FetchTreeNodeKind         `json:"kind"`
	Trigger         *FetchTreeQueryPlan       `json:"trigger,omitempty"`
	Children        []*FetchTreeQueryPlanNode `json:"children,omitempty"`
	Fetch           *FetchTreeQueryPlan       `json:"fetch,omitempty"`
	NormalizedQuery string                    `json:"normalizedQuery,omitempty"`
}

type FetchTreeTraceNode struct {
	Kind     FetchTreeNodeKind     `json:"kind"`
	Children []*FetchTreeTraceNode `json:"children,omitempty"`
	Fetch    *FetchTraceNode       `json:"fetch,omitempty"`
}

type Field struct {
	Name              []byte
	Value             Node
	Position          Position
	Defer             *DeferField
	Stream            *StreamField
	OnTypeNames       [][]byte
	ParentOnTypeNames []ParentOnTypeNames
	Info              *FieldInfo
}

type FieldExport struct {
	Path     []string
	AsString bool
}

type FieldInfo struct {
	// Name is the name of the field.
	Name                string
	ExactParentTypeName string
	// ParentTypeNames is the list of possible parent types for this field.
	// E.g. for a root field, this will be Query, Mutation, Subscription.
	// For a field on an object type, this will be the name of that object type.
	// For a field on an interface type, this will be the name of that interface type and all of its possible implementations.
	ParentTypeNames []string
	// NamedType is the underlying node type of the field.
	// E.g. for a field of type Hobby! this will be Hobby.
	// For a field of type [Hobby] this will be Hobby.
	// For a field of type [Hobby!]! this will be Hobby.
	// For scalar fields, this will return string, int, float, boolean, ID.
	NamedType string
	Source    TypeFieldSource
	FetchID   int
	// HasAuthorizationRule needs to be set to true if the Authorizer should be called for this field
	HasAuthorizationRule bool
	// IndirectInterfaceNames is set to the interfaces name if the field is on a concrete type that implements an interface which wraps it
	// It's plural because interfaces and be overlapping with types that implement multiple interfaces
	IndirectInterfaceNames []string
}

type FieldValue struct {
	// Name is the name of the field, e.g. "id", "name", etc.
	Name string
	// Type is the type of the field, e.g. "String", "Int", etc.
	Type string
	// ParentType is the type of the parent object, e.g. "User", "Post", etc.
	ParentType string
	// IsListItem indicates whether the field is a list (array) item.
	IsListItem bool
	// IsNullable indicates whether the field is nullable.
	IsNullable bool
	// IsEnum is a value of Enum
	IsEnum bool

	// Path holds the path to the field in the response.
	Path string

	// Data holds the actual field value data.
	Data []byte

	// ParsedData is the astjson.Value representation of the field value data.
	ParsedData *astjson.Value
}

type FieldValueRenderer interface {
	// RenderFieldValue renders a field value to the provided writer.
	RenderFieldValue(ctx *Context, value FieldValue, out io.Writer) error
}

type Float struct {
	Path     []string
	Nullable bool
	Export   *FieldExport `json:"export,omitempty"`
}

type GetConnStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
	HostPort                 string `json:"host_port"`
}

type GotConnStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
	Reused                   bool   `json:"reused"`
	WasIdle                  bool   `json:"was_idle"`
	IdleTimeNano             int64  `json:"idle_time_nanoseconds"`
	IdleTimePretty           string `json:"idle_time_pretty"`
}

type GotFirstResponseByteStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
}

type GraphCoordinate struct {
	TypeName             string `json:"typeName"`
	FieldName            string `json:"fieldName"`
	HasAuthorizationRule bool   `json:"-"`
}

type GraphQLError struct {
	Message   string     `json:"message"`
	Locations []Location `json:"locations,omitempty"`
	// Path is a list of path segments that lead to the error, can be number or string
	Path       []any          `json:"path"`
	Extensions map[string]any `json:"extensions,omitempty"`
}

type GraphQLResolveInfo struct {
	ResolveAcquireWaitTime time.Duration
}

type GraphQLResponse struct {
	Data *Object

	RawFetches []*FetchItem
	Fetches    *FetchTreeNode

	Info        *GraphQLResponseInfo
	DataSources []DataSourceInfo
}

type GraphQLResponseInfo struct {
	OperationType ast.OperationType
}

type GraphQLSubscription struct {
	Trigger  GraphQLSubscriptionTrigger
	Response *GraphQLResponse
	Filter   *SubscriptionFilter
}

type GraphQLSubscriptionTrigger struct {
	Input          []byte
	InputTemplate  InputTemplate
	Variables      Variables
	Source         SubscriptionDataSource
	PostProcessing PostProcessingConfiguration
	QueryPlan      *QueryPlan
}

type GraphQLVariableRenderer struct {
	JSONSchema string
	Kind       string
	// contains filtered or unexported fields
}

type GraphQLVariableResolveRenderer struct {
	Kind string
	Node Node
}

type HeaderVariable struct {
	Path []string
}

type HookableSubscriptionDataSource interface {
	// SubscriptionOnStart is called when a new subscription is created
	// If an error is returned, the error is propagated to the client.
	SubscriptionOnStart(ctx StartupHookContext, input []byte) (err error)
}

type InputTemplate struct {
	Segments []TemplateSegment
	// SetTemplateOutputToNullOnVariableNull will safely return "null" if one of the template variables renders to null
	// This is the case, e.g. when using batching and one sibling is null, resulting in a null value for one batch item
	// Returning null in this case tells the batch implementation to skip this item
	SetTemplateOutputToNullOnVariableNull bool
}

type Integer struct {
	Path     []string
	Nullable bool
	Export   *FieldExport `json:"export,omitempty"`
}

type IntrospectionData struct {
	IncludeDeprecatedVariableName string
}

type JSONVariableRenderer struct {
	Kind string
	// contains filtered or unexported fields
}

type JsonRootType struct {
	Value  jsonparser.ValueType
	Values []jsonparser.ValueType
	Kind   JsonRootTypeKind
}

type JsonRootTypeKind int

type LoadStats struct {
	GetConn              GetConnStats              `json:"get_conn"`
	GotConn              GotConnStats              `json:"got_conn"`
	GotFirstResponseByte GotFirstResponseByteStats `json:"got_first_response_byte"`
	DNSStart             DNSStartStats             `json:"dns_start"`
	DNSDone              DNSDoneStats              `json:"dns_done"`
	ConnectStart         ConnectStartStats         `json:"connect_start"`
	ConnectDone          ConnectDoneStats          `json:"connect_done"`
	TLSHandshakeStart    TLSHandshakeStartStats    `json:"tls_handshake_start"`
	TLSHandshakeDone     TLSHandshakeDoneStats     `json:"tls_handshake_done"`
	WroteHeaders         WroteHeadersStats         `json:"wrote_headers"`
	WroteRequest         WroteRequestStats         `json:"wrote_request"`
}

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

type LoaderHooks interface {
	// OnLoad is called before the fetch is executed
	OnLoad(ctx context.Context, ds DataSourceInfo) context.Context
	// OnFinished is called after the fetch has been executed and the response has been processed and merged
	OnFinished(ctx context.Context, ds DataSourceInfo, info *ResponseInfo)
}

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

type Node interface {
	NodeKind() NodeKind
	NodePath() []string
	NodeNullable() bool
	Equals(Node) bool
	Copy() Node
}

type NodeKind int

type Null struct {
}

type Object struct {
	Nullable bool
	Path     []string
	Fields   []*Field

	PossibleTypes map[string]struct{} `json:"-"`
	SourceName    string              `json:"-"`
	TypeName      string              `json:"-"`
}

type ObjectVariable struct {
	Path     []string
	Renderer VariableRenderer
}

type ParallelListItemFetch struct {
	Fetch  *SingleFetch
	Traces []*SingleFetch
	Trace  *DataSourceLoadTrace
}

type ParentOnTypeNames struct {
	Depth int
	Names [][]byte
}

type PhaseStats struct {
	DurationNano             int64  `json:"duration_nanoseconds"`
	DurationPretty           string `json:"duration_pretty"`
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
}

type PlainVariableRenderer struct {
	JSONSchema string
	Kind       string
}

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

type Position struct {
	Line   uint32
	Column uint32
}

type PostProcessingConfiguration struct {
	// SelectResponseDataPath used to make a jsonparser.Get call on the response data
	SelectResponseDataPath []string

	// SelectResponseErrorsPath is similar to SelectResponseDataPath, but for errors
	// If this is set, the response will be considered an error if the jsonparser.Get call returns a non-empty value
	// The value will be expected to be a GraphQL error object
	SelectResponseErrorsPath []string

	// MergePath can be defined to merge the result of the post-processing into the parent object at the given path
	// e.g. if the parent is {"a":1}, result is {"foo":"bar"} and the MergePath is ["b"],
	// the result will be {"a":1,"b":{"foo":"bar"}}
	// If the MergePath is empty, the result will be merged into the parent object
	// In this case, the result would be {"a":1,"foo":"bar"}
	// This is useful if we make multiple fetches, e.g. parallel fetches, that would otherwise overwrite each other
	MergePath []string
}

type QueryPlan struct {
	DependsOnFields []Representation
	Query           string
}

type RateLimitDeny struct {
	Reason string
}

type RateLimitError struct {
	SubgraphName string
	Path         string
	Reason       string
}

type RateLimitErrorExtensionCode struct {
	Enabled bool
	Code    string
}

type RateLimitOptions struct {
	// Enable switches rate limiting on or off
	Enable bool
	// IncludeStatsInResponseExtension includes the rate limit stats in the response extensions
	IncludeStatsInResponseExtension bool

	Rate                    int
	Burst                   int
	Period                  time.Duration
	RateLimitKey            string
	RejectExceedingRequests bool

	ErrorExtensionCode RateLimitErrorExtensionCode
}

type RateLimiter interface {
	RateLimitPreFetch(ctx *Context, info *FetchInfo, input json.RawMessage) (result *RateLimitDeny, err error)
	RenderResponseExtension(ctx *Context, out io.Writer) error
}

type RenameTypeName struct {
	From, To []byte
}

type Reporter interface {
	// SubscriptionUpdateSent called when a new subscription update is sent
	SubscriptionUpdateSent()
	// SubscriptionCountInc increased when a new subscription is added to a trigger, this includes inflight subscriptions
	SubscriptionCountInc(count int)
	// SubscriptionCountDec decreased when a subscription is removed from a trigger e.g. on shutdown
	SubscriptionCountDec(count int)
	// TriggerCountInc increased when a new trigger is added e.g. when a trigger is started and initialized
	TriggerCountInc(count int)
	// TriggerCountDec decreased when a trigger is removed e.g. when a trigger is shutdown
	TriggerCountDec(count int)
}

type Representation struct {
	Kind      RepresentationKind `json:"kind"`
	TypeName  string             `json:"typeName"`
	FieldName string             `json:"fieldName,omitempty"`
	Fragment  string             `json:"fragment"`
}

type RepresentationKind string

type Request struct {
	ID     string
	Header http.Header
}

type RequestData struct {
	Method  string      `json:"method"`
	URL     string      `json:"url"`
	Headers http.Header `json:"headers"`
	Body    BodyData    `json:"body,omitempty"`
}

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

type ResolvableObjectVariable struct {
	Renderer *GraphQLVariableResolveRenderer
}

type ResolvableOptions struct {
	ApolloCompatibilityValueCompletionInExtensions bool
	ApolloCompatibilityTruncateFloatValues         bool
	ApolloCompatibilitySuppressFetchErrors         bool
	ApolloCompatibilityReplaceInvalidVarError      bool
}

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

type ResolverOptions struct {
	// MaxConcurrency limits the number of concurrent tool calls which is used to resolve operations.
	// The limit is only applied to getToolsWithLimit() calls. Intentionally, we don't use this limit for
	// subscription updates to prevent blocking the subscription during a network collapse because a one-to-one
	// relation is not given as in the case of single http request. We already enforce concurrency limits through
	// the MaxSubscriptionWorkers option that is a semaphore to limit the number of concurrent subscription updates.
	//
	// If set to 0, no limit is applied
	// It is advised to set this to a reasonable value to prevent excessive memory usage
	// Each concurrent resolve operation allocates ~50kb of memory
	// In addition, there's a limit of how many concurrent requests can be efficiently resolved
	// This depends on the number of CPU cores available, the complexity of the operations, and the origin services
	MaxConcurrency int

	Debug bool

	Reporter         Reporter
	AsyncErrorWriter AsyncErrorWriter

	// PropagateSubgraphErrors adds Subgraph Errors to the response
	PropagateSubgraphErrors bool

	// PropagateSubgraphStatusCodes adds the status code of the Subgraph to the extensions field of a Subgraph Error
	PropagateSubgraphStatusCodes bool

	// SubgraphErrorPropagationMode defines how Subgraph Errors are propagated
	// SubgraphErrorPropagationModeWrapped wraps Subgraph Errors in a Subgraph Error to prevent leaking internal information
	// SubgraphErrorPropagationModePassThrough passes Subgraph Errors through without modification
	SubgraphErrorPropagationMode SubgraphErrorPropagationMode

	// RewriteSubgraphErrorPaths rewrites the paths of Subgraph Errors to match the path of the field from the perspective of the client
	// This means that nested entity requests will have their paths rewritten from e.g. "_entities.foo.bar" to "person.foo.bar" if the root field above is "person"
	RewriteSubgraphErrorPaths bool

	// OmitSubgraphErrorLocations omits the locations field of Subgraph Errors
	OmitSubgraphErrorLocations bool

	// OmitSubgraphErrorExtensions omits the extensions field of Subgraph Errors
	OmitSubgraphErrorExtensions bool

	// AllowAllErrorExtensionFields allows all fields in the extensions field of a root subgraph error
	AllowAllErrorExtensionFields bool

	// AllowedErrorExtensionFields defines which fields are allowed in the extensions field of a root subgraph error
	AllowedErrorExtensionFields []string

	// AttachServiceNameToErrorExtensions attaches the service name to the extensions field of a root subgraph error
	AttachServiceNameToErrorExtensions bool

	// DefaultErrorExtensionCode is the default error code to use for subgraph errors if no code is provided
	DefaultErrorExtensionCode string

	// MaxRecyclableParserSize limits the size of the Parser that can be recycled back into the Pool.
	// If set to 0, no limit is applied
	// This helps keep the Heap size more maintainable if you regularly perform large queries.
	MaxRecyclableParserSize int

	// ResolvableOptions are configuration options for the Resolvable struct
	ResolvableOptions ResolvableOptions

	// AllowedCustomSubgraphErrorFields defines which fields are allowed in the subgraph error when in passthrough mode
	AllowedSubgraphErrorFields []string

	// SubscriptionHeartbeatInterval defines the interval in which a heartbeat is sent to all subscriptions (whether or not this does anything is determined by the subscription response writer)
	SubscriptionHeartbeatInterval time.Duration

	// MaxSubscriptionFetchTimeout defines the maximum time a subscription fetch can take before it is considered timed out
	MaxSubscriptionFetchTimeout time.Duration

	// ApolloRouterCompatibilitySubrequestHTTPError is a compatibility flag for Apollo Router, it is used to handle HTTP errors in subrequests differently
	ApolloRouterCompatibilitySubrequestHTTPError bool

	// PropagateFetchReasons enables adding the "fetch_reasons" extension to
	// upstream subgraph requests. This extension explains why each field was requested.
	// This flag does not expose the data to clients.
	PropagateFetchReasons bool

	ValidateRequiredExternalFields bool
}

type ResponseInfo struct {
	StatusCode int
	Err        error
	// Request is the original request that was sent to the subgraph. This should only be used for reading purposes,
	// in order to ensure there aren't memory conflicts, and the body will be nil, as it was read already.
	Request *http.Request
	// ResponseHeaders contains a clone of the headers of the response from the subgraph.
	ResponseHeaders http.Header
	// contains filtered or unexported fields
}

type ResponseWriter interface {
	io.Writer
}

type Scalar struct {
	Path     []string
	Nullable bool
	Export   *FieldExport `json:"export,omitempty"`
}

type SegmentType int

type SingleFetch struct {
	FetchConfiguration
	FetchDependencies

	InputTemplate        InputTemplate
	DataSourceIdentifier []byte
	Trace                *DataSourceLoadTrace
	Info                 *FetchInfo
}

type SingleFlightStats struct {
	SingleFlightUsed           bool
	SingleFlightSharedResponse bool
}

type SkipArrayItem func(ctx *Context, arrayItem *astjson.Value) bool

type StartupHookContext struct {
	Context context.Context
	Updater func(data []byte)
}

type StaticString struct {
	Path  []string
	Value string
}

type StreamField struct {
	InitialBatchSize int
}

type String struct {
	Path                 []string
	Nullable             bool
	Export               *FieldExport `json:"export,omitempty"`
	UnescapeResponseJson bool         `json:"unescape_response_json,omitempty"`
	IsTypeName           bool         `json:"is_type_name,omitempty"`
}

type SubgraphError struct {
	DataSourceInfo DataSourceInfo
	Path           string
	Reason         string
	ResponseCode   int

	DownstreamErrors []*GraphQLError
}

type SubgraphErrorPropagationMode int

type SubscriptionCloseKind struct {
	WSCode ws.StatusCode
	Reason string
}

type SubscriptionDataSource interface {
	// Start is called when a new subscription is created. It establishes the connection to the data source.
	// The updater is used to send updates to the client. Deduplication of the request must be done before calling this method.
	Start(ctx *Context, input []byte, updater SubscriptionUpdater) error
	UniqueRequestID(ctx *Context, input []byte, xxh *xxhash.Digest) (err error)
}

type SubscriptionFieldFilter struct {
	FieldPath []string
	Values    []InputTemplate
}

type SubscriptionFilter struct {
	And []SubscriptionFilter
	Or  []SubscriptionFilter
	Not *SubscriptionFilter
	In  *SubscriptionFieldFilter
}

type SubscriptionIdentifier struct {
	ConnectionID   int64
	SubscriptionID int64
}

type SubscriptionResponseWriter interface {
	ResponseWriter
	Flush() error
	Complete()
	Heartbeat() error
	Close(kind SubscriptionCloseKind)
}

type SubscriptionUpdater interface {
	// Update sends an update to the client. It is not guaranteed that the update is sent immediately.
	Update(data []byte)
	// UpdateSubscription sends an update to a single subscription. It is not guaranteed that the update is sent immediately.
	UpdateSubscription(id SubscriptionIdentifier, data []byte)
	// Complete also takes care of cleaning up the trigger and all subscriptions. No more updates should be sent after calling Complete.
	Complete()
	// Close closes the subscription and cleans up the trigger and all subscriptions. No more updates should be sent after calling Close.
	Close(kind SubscriptionCloseKind)
	// CloseSubscription closes a single subscription. No more updates should be sent to that subscription after calling CloseSubscription.
	CloseSubscription(kind SubscriptionCloseKind, id SubscriptionIdentifier)
	// Subscriptions return all the subscriptions associated to this Updater
	Subscriptions() map[context.Context]SubscriptionIdentifier
}

type TLSHandshakeDoneStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
	Err                      string `json:"err,omitempty"`
}

type TLSHandshakeStartStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
}

type TemplateSegment struct {
	SegmentType        SegmentType
	Data               []byte
	VariableKind       VariableKind
	VariableSourcePath []string
	Renderer           VariableRenderer
	Segments           []TemplateSegment
}

type TraceData struct {
	Version string              `json:"version"`
	Info    *TraceInfo          `json:"info"`
	Fetches *FetchTreeTraceNode `json:"fetches"`
	Request *RequestData        `json:"request,omitempty"`
}

type TraceInfo struct {
	TraceStart     time.Time  `json:"-"`
	TraceStartTime string     `json:"trace_start_time"`
	TraceStartUnix int64      `json:"trace_start_unix"`
	ParseStats     PhaseStats `json:"parse_stats"`
	NormalizeStats PhaseStats `json:"normalize_stats"`
	ValidateStats  PhaseStats `json:"validate_stats"`
	PlannerStats   PhaseStats `json:"planner_stats"`
	// contains filtered or unexported fields
}

type TraceOptions struct {
	// Enable switches tracing on or off
	Enable bool
	// ExcludeParseStats excludes parse timing information from the trace output
	ExcludeParseStats bool
	// ExcludeNormalizeStats excludes normalize timing information from the trace output
	ExcludeNormalizeStats bool
	// ExcludeValidateStats excludes validation timing information from the trace output
	ExcludeValidateStats bool
	// ExcludePlannerStats excludes planner timing information from the trace output
	ExcludePlannerStats bool
	// ExcludeRawInputData excludes the raw input for a load operation from the trace output
	ExcludeRawInputData bool
	// ExcludeInput excludes the rendered input for a load operation from the trace output
	ExcludeInput bool
	// ExcludeOutput excludes the result of a load operation from the trace output
	ExcludeOutput bool
	// ExcludeLoadStats excludes the load timing information from the trace output
	ExcludeLoadStats bool
	// EnablePredictableDebugTimings makes the timings in the trace output predictable for debugging purposes
	EnablePredictableDebugTimings bool
	// IncludeTraceOutputInResponseExtensions includes the trace output in the response extensions
	IncludeTraceOutputInResponseExtensions bool
	// Debug makes trace IDs of fetches predictable for debugging purposes
	Debug bool
}

type TypeFieldSource struct {
	IDs   []string
	Names []string
}

type Variable interface {
	GetVariableKind() VariableKind
	Equals(another Variable) bool
	TemplateSegment() TemplateSegment
}

type VariableKind int

type VariableRenderer interface {
	GetKind() string
	RenderVariable(ctx context.Context, data *astjson.Value, out io.Writer) error
}

type Variables []Variable

type WroteHeadersStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
}

type WroteRequestStats struct {
	DurationSinceStartNano   int64  `json:"duration_since_start_nanoseconds"`
	DurationSinceStartPretty string `json:"duration_since_start_pretty"`
	Err                      string `json:"err,omitempty"`
}