execution

type ArgsResolver interface {
	ResolveArgs(args []datasource.Argument, data []byte) ResolvedArgs
}

type BooleanCondition interface {
	Evaluate(ctx Context, data []byte) bool
}

type Context struct {
	context.Context
	Variables      Variables
	ExtraArguments []datasource.Argument
}

type DataResolvingConfig struct {
	PathSelector   datasource.PathSelector
	Transformation Transformation
}

type DataSourceDefinition struct {
	// the type name to which the data source is attached
	TypeName []byte
	// the field on the type to which the data source is attached
	FieldName []byte
	// a factory method to return a new planner
	DataSourcePlannerFactory func() datasource.Planner
}

type DataSourceInvocation struct {
	Args       []datasource.Argument
	DataSource datasource.DataSource
}

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

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

type Fetch interface {
	Fetch(ctx Context, data []byte, argsResolver ArgsResolver, suffix string, buffers *LockableBufferMap) (n int, err error)
}

type Field struct {
	Name            []byte
	Value           Node
	Skip            BooleanCondition
	HasResolvedData bool
}

type GraphQLDataSourceConfig struct {
	Host   string
	Url    string
	Method HTTP_METHOD
	Params *[]*Parameter
}

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

type HTTP_METHOD int

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

type Header struct {
	Key   string
	Value string
}

type HttpJsonDataSourceConfig struct {
	Host                       string
	Url                        string
	Method                     HTTP_METHOD
	Params                     *[]*Parameter
	Body                       *string
	Headers                    *[]*Header
	DefaultTypeName            *string
	StatusCodeTypeNameMappings *[]*StatusCodeTypeNameMapping
}

type HttpPollingStreamDataSourceConfig struct {
	Host         string
	Url          string
	Method       HTTP_METHOD
	DelaySeconds int64
	Params       *[]*Parameter
}

type IfEqual struct {
	Left, Right datasource.Argument
}

type IfNotEqual struct {
	Left, Right datasource.Argument
}

type JSONValueType int

type List struct {
	DataResolvingConfig DataResolvingConfig
	Value               Node
	Filter              ListFilter
}

type ListFilter interface {
	Kind() ListFilterKind
}

type ListFilterFirstN struct {
	FirstN int
}

type ListFilterKind int

type LockableBufferMap struct {
	sync.Mutex
	Buffers map[uint64]*bytes.Buffer
}

type MAPPING_MODE int

type MQTTDataSourceConfig struct {
	BrokerAddr string
	ClientID   string
	Topic      string
}

type MappingConfig struct {
	Mode         MAPPING_MODE
	PathSelector *string
}

type NatsDataSourceConfig struct {
	Addr  string
	Topic string
}

type Node interface {
	// Kind returns the NodeKind of each Node
	Kind() NodeKind
	// HasResolversRecursively returns true if this Node or any child Node has a resolver
	HasResolversRecursively() bool
}

type NodeKind int

type Object struct {
	DataResolvingConfig DataResolvingConfig
	Fields              []Field
	Fetch               Fetch
	// contains filtered or unexported fields
}

type PARAMETER_SOURCE int

type ParallelFetch struct {
	Fetches []Fetch
	// contains filtered or unexported fields
}

type Parameter struct {
	Name         string
	SourceKind   PARAMETER_SOURCE
	SourceName   string
	VariableType string
}

type PipelineDataSourceConfig struct {
	ConfigFilePath *string
	ConfigString   *string
	InputJSON      string
}

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

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

type ResolvedArgs []ResolvedArgument

type ResolvedArgument struct {
	Key   []byte
	Value []byte
}

type RootNode interface {
	Node
	OperationType() ast.OperationType
}

type SerialFetch struct {
	Fetches []Fetch
}

type SingleFetch struct {
	Source     *DataSourceInvocation
	BufferName string
}

type StaticDataSourceConfig struct {
	Data *string
}

type StatusCodeTypeNameMapping struct {
	StatusCode int64
	TypeName   string
}

type TRANSFORMATION_MODE int

type Transformation interface {
	Transform(input []byte) ([]byte, error)
}

type TransformationConfig struct {
	Mode                 TRANSFORMATION_MODE
	PipelineConfigFile   *string
	PipelineConfigString *string
}

type Value struct {
	DataResolvingConfig DataResolvingConfig
	ValueType           JSONValueType
}

type Variables map[uint64][]byte

type WasmDataSourceConfig struct {
	Input    string
	WasmFile string
}