resolve

type AfterFetchHook interface {
	OnData(ctx HookContext, output []byte, singleFlight bool)
	OnError(ctx HookContext, output []byte, singleFlight bool)
}

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

type BatchFetch struct {
	Fetch        *SingleFetch
	BatchFactory DataSourceBatchFactory
}

type BeforeFetchHook interface {
	OnBeforeFetch(ctx HookContext, input []byte)
}

type BigInt struct {
	Path     []string
	Nullable bool
	Export   *FieldExport `json:"export,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 Context struct {
	Variables []byte
	Request   Request

	RenameTypeNames []RenameTypeName
	// contains filtered or unexported fields
}

type ContextVariable struct {
	Path     []string
	Renderer VariableRenderer
}

type CustomNode struct {
	CustomResolve
	Nullable bool
	Path     []string
}

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

type DataSource interface {
	Load(ctx context.Context, input []byte, w io.Writer) (err error)
}

type DataSourceBatch interface {
	Demultiplex(responseBufPair *BufPair, outputBuffers []*BufPair) (err error)
	Input() *fastbuffer.FastBuffer
}

type DataSourceBatchFactory interface {
	CreateBatch(inputs [][]byte) (DataSourceBatch, error)
}

type Defer struct {
	Enabled    bool
	PatchIndex int
}

type DeferField struct{}

type EmptyArray struct{}

type EmptyObject struct{}

type Fetch interface {
	FetchKind() FetchKind
}

type FetchKind int

type Fetcher struct {
	EnableSingleFlightLoader bool
	// contains filtered or unexported fields
}

type Fetches []Fetch

type Field struct {
	Name                    []byte
	Value                   Node
	Position                Position
	Defer                   *DeferField
	Stream                  *StreamField
	HasBuffer               bool
	BufferID                int
	OnTypeNames             [][]byte
	SkipDirectiveDefined    bool
	SkipVariableName        string
	IncludeDirectiveDefined bool
	IncludeVariableName     string
}

type FieldExport struct {
	Path     []string
	AsString bool
}

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

type FlushWriter interface {
	io.Writer
	Flush()
}

type GraphQLResponse struct {
	Data            Node
	RenameTypeNames []RenameTypeName
}

type GraphQLResponsePatch struct {
	Value     Node
	Fetch     Fetch
	Operation []byte
}

type GraphQLStreamingResponse struct {
	InitialResponse *GraphQLResponse
	Patches         []*GraphQLResponsePatch
	FlushInterval   int64
}

type GraphQLSubscription struct {
	Trigger  GraphQLSubscriptionTrigger
	Response *GraphQLResponse
}

type GraphQLSubscriptionTrigger struct {
	Input                 []byte
	InputTemplate         InputTemplate
	Variables             Variables
	Source                SubscriptionDataSource
	ProcessResponseConfig ProcessResponseConfig
}

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

type HeaderVariable struct {
	Path []string
}

type HookContext struct {
	CurrentPath []byte
}

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 JSONVariableRenderer struct {
	JSONSchema string
	Kind       string
	// contains filtered or unexported fields
}

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

type JsonRootTypeKind int

type Node interface {
	NodeKind() NodeKind
}

type NodeKind int

type Null struct {
	Defer Defer
}

type Object struct {
	Nullable             bool
	Path                 []string
	Fields               []*Field
	Fetch                Fetch
	UnescapeResponseJson bool `json:"unescape_response_json,omitempty"`
}

type ObjectVariable struct {
	Path     []string
	Renderer VariableRenderer
}

type ParallelFetch struct {
	Fetches []Fetch
}

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

type Position struct {
	Line   uint32
	Column uint32
}

type ProcessResponseConfig struct {
	ExtractGraphqlResponse    bool
	ExtractFederationEntities bool
}

type RenameTypeName struct {
	From, To []byte
}

type Request struct {
	Header http.Header
}

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

type SegmentType int

type SingleFetch struct {
	BufferId   int
	Input      string
	DataSource DataSource
	Variables  Variables
	// DisallowSingleFlight is used for write operations like mutations, POST, DELETE etc. to disable singleFlight
	// By default SingleFlight for fetches is disabled and needs to be enabled on the Resolver first
	// If the resolver allows SingleFlight it's up to each individual DataSource Planner to decide whether an Operation
	// should be allowed to use SingleFlight
	DisallowSingleFlight  bool
	DisableDataLoader     bool
	InputTemplate         InputTemplate
	DataSourceIdentifier  []byte
	ProcessResponseConfig ProcessResponseConfig
	// 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 Stream struct {
	Enabled          bool
	InitialBatchSize int
	PatchIndex       int
}

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 SubscriptionDataSource interface {
	Start(ctx context.Context, input []byte, next chan<- []byte) error
}

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

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

type VariableKind int

type VariableRenderer interface {
	GetKind() string
	RenderVariable(ctx context.Context, data []byte, out io.Writer) error
}

type VariableSchema struct {
}

type Variables []Variable