core

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

type AccessControllerOptions struct {
	Authenticators           []authentication.Authenticator
	AuthenticationRequired   bool
	SkipIntrospectionQueries bool
	IntrospectionSkipSecret  string
}

type AccessLogsConfig struct {
	Attributes            []config.CustomAttribute
	Logger                *zap.Logger
	SubgraphEnabled       bool
	SubgraphAttributes    []config.CustomAttribute
	IgnoreQueryParamsList []string
}

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

type ApiTransportFactory interface {
	RoundTripper(transport http.RoundTripper) http.RoundTripper
	DefaultHTTPProxyURL() *url.URL
}

type AuthorizationExtension struct {
	MissingScopes []MissingScopesError `json:"missingScopes,omitempty"`
	ActualScopes  []string             `json:"actualScopes"`
}

type BatchedOperationId struct{}

type BatchingConfig struct {
	Enabled               bool
	MaxConcurrentRoutines int
	MaxEntriesPerBatch    int
	OmitExtensions        bool
}

type BlockMutationOptions struct {
	Enabled   bool
	Condition string
}

type BlockNonPersistedOptions struct {
	Enabled   bool
	Condition string
}

type BlockPersistedOptions struct {
	Enabled   bool
	Condition string
}

type BlockSubscriptionOptions struct {
	Enabled   bool
	Condition string
}

type BuildGraphMuxOptions struct {
	FeatureFlagName       string
	RouterConfigVersion   string
	EngineConfig          *nodev1.EngineConfiguration
	ConfigSubgraphs       []*nodev1.Subgraph
	RoutingUrlGroupings   map[string]map[string]bool
	ReloadPersistentState *ReloadPersistentState
}

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

type CacheWarmupConfig struct {
	Log            *zap.Logger
	Source         CacheWarmupSource
	FallbackSource CacheWarmupSource
	Workers        int
	ItemsPerSecond int
	Timeout        time.Duration
	Processor      CacheWarmupProcessor
	AfterOperation func(item *CacheWarmupOperationPlanResult)
}

type CacheWarmupItem struct {
	Request GraphQLRequest
	Client  *ClientInfo
}

type CacheWarmupOperationPlanResult struct {
	OperationHash string
	OperationName string
	OperationType string
	ClientName    string
	ClientVersion string
	PlanningTime  time.Duration
}

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

type CacheWarmupPlanningProcessorOptions struct {
	OperationProcessor        *OperationProcessor
	OperationPlanner          *OperationPlanner
	ComplexityLimits          *config.ComplexityLimits
	RouterSchema              *ast.Document
	TrackSchemaUsage          bool
	DisableVariablesRemapping bool
}

type CacheWarmupProcessor interface {
	ProcessOperation(ctx context.Context, item *nodev1.Operation) (*CacheWarmupOperationPlanResult, error)
}

type CacheWarmupSource interface {
	LoadItems(ctx context.Context, log *zap.Logger) ([]*nodev1.Operation, error)
}

type Cleaner interface {
	// Cleanup is called after the server stops
	Cleanup() error
}

type ClientInfo struct {
	// Name contains the client name, derived from the request headers
	Name string
	// Version contains the client version, derived from the request headers
	Version string
	// WGRequestToken contains the token to authenticate the request from the platform
	WGRequestToken string
}

type ComplexityCacheEntry struct {
	Depth            int
	TotalFields      int
	RootFields       int
	RootFieldAliases int
}

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

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

type CosmoAuthorizerOptions struct {
	FieldConfigurations           []*nodev1.FieldConfiguration
	RejectOperationIfUnauthorized bool
}

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

type CosmoRateLimiterOptions struct {
	RedisClient rd.RDCloser
	Debug       bool

	RejectStatusCode int

	KeySuffixExpression string
	ExprManager         *expr.Manager
}

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

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

type DialerFunc func(ctx context.Context, network, address string) (net.Conn, error)

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

type EnginePostOriginHandler interface {
	// OnOriginResponse is called after the request is sent to the origin.
	// Might be called multiple times if there are multiple origins
	OnOriginResponse(resp *http.Response, ctx RequestContext) *http.Response
}

type EnginePreOriginHandler interface {
	// OnOriginRequest is called before the request is sent to the origin
	// Might be called multiple times if there are multiple origins
	OnOriginRequest(req *http.Request, ctx RequestContext) (*http.Request, *http.Response)
}

type ExecutionConfig struct {
	Watch         bool
	WatchInterval time.Duration
	Path          string
}

type ExecutionPlanCache[K any, V any] interface {
	// Get the value from the cache
	Get(key K) (V, bool)
	// Set the value in the cache with a cost. The cost depends on the cache implementation
	Set(key K, value V, cost int64) bool
	// Iterate over all items in the cache (non-deterministic)
	IterValues(cb func(v V) (stop bool))
	// Close the cache and free resources
	Close()
}

type Executor struct {
	PlanConfig plan.Configuration
	// ClientSchema is the GraphQL Schema that is exposed from our API
	// it is used for the introspection and query normalization/validation.
	ClientSchema *ast.Document
	// RouterSchema the GraphQL Schema that we use for planning the queries
	RouterSchema    *ast.Document
	Resolver        *resolve.Resolver
	RenameTypeNames []resolve.RenameTypeName
	TrackUsageInfo  bool
}

type ExecutorBuildOptions struct {
	EngineConfig                   *nodev1.EngineConfiguration
	Subgraphs                      []*nodev1.Subgraph
	RouterEngineConfig             *RouterEngineConfiguration
	Reporter                       resolve.Reporter
	ApolloCompatibilityFlags       config.ApolloCompatibilityFlags
	ApolloRouterCompatibilityFlags config.ApolloRouterCompatibilityFlags
	HeartbeatInterval              time.Duration
	TraceClientRequired            bool
	PluginsEnabled                 bool
	InstanceData                   InstanceData
}

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

type ExprWrapError struct {
	Err error
}

type Extensions struct {
	RateLimit     json.RawMessage `json:"rateLimit,omitempty"`
	Authorization json.RawMessage `json:"authorization,omitempty"`
	Trace         json.RawMessage `json:"trace,omitempty"`
	StatusCode    int             `json:"statusCode,omitempty"`
	Code          string          `json:"code,omitempty"`
}

type FactoryResolver interface {
	ResolveGraphqlFactory(subgraphName string) (plan.PlannerFactory[graphql_datasource.Configuration], error)
	ResolveStaticFactory() (plan.PlannerFactory[staticdatasource.Configuration], error)
	InstanceData() InstanceData
}

type FileSystemSource struct {
	RootPath string
}

type FileSystemSourceConfig struct {
	RootPath string
}

type GraphQLErrorResponse struct {
	Errors     []graphqlError `json:"errors"`
	Data       any            `json:"data"`
	Extensions *Extensions    `json:"extensions,omitempty"`
}

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

type GraphQLMetricsConfig struct {
	Enabled           bool
	CollectorEndpoint string
}

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

type GraphQLRequestExtensions struct {
	PersistedQuery *GraphQLRequestExtensionsPersistedQuery `json:"persistedQuery"`
}

type GraphQLRequestExtensionsPersistedQuery struct {
	Version    int    `json:"version"`
	Sha256Hash string `json:"sha256Hash"`
}

type HandlerOptions struct {
	Executor       *Executor
	Log            *zap.Logger
	EngineStats    statistics.EngineStatistics
	TracerProvider trace.TracerProvider
	Authorizer     *CosmoAuthorizer
	RateLimiter    *CosmoRateLimiter

	RateLimitConfig          *config.RateLimitConfiguration
	SubgraphErrorPropagation config.SubgraphErrorPropagationConfiguration
	EngineLoaderHooks        resolve.LoaderHooks

	EnableCacheResponseHeaders      bool
	EnableResponseHeaderPropagation bool

	ApolloSubscriptionMultipartPrintBoundary bool
	HeaderPropagation                        *HeaderPropagation
}

type HandlerOpts struct {
	MaxEntriesPerBatch  int
	MaxRoutines         int
	HandlerSent         http.Handler
	Tracer              trace.Tracer
	ClientHeader        config.ClientHeader
	BaseOtelAttributes  []attribute.KeyValue
	RouterConfigVersion string
	Digest              *xxhash.Digest
	OmitExtensions      bool
	Logger              *zap.Logger
}

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

type HeaderWithHash struct {
	Header http.Header
	Hash   uint64
}

type HttpError interface {
	error
	// ExtensionCode is the code that should be included in the error extensions
	ExtensionCode() string
	// Message represents a human-readable error message to be sent to the client/user
	Message() string
	// StatusCode is the status code to be sent to the client
	StatusCode() int
}

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

type IPAnonymizationConfig struct {
	Enabled bool
	Method  IPAnonymizationMethod
}

type IPAnonymizationMethod string

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

type InstanceData struct {
	HostName      string
	ListenAddress string
}

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

type MissingScopesError struct {
	Coordinate       resolve.GraphCoordinate `json:"coordinate"`
	RequiredOrScopes [][]string              `json:"required"`
}

type Module interface {
	Module() ModuleInfo
}

type ModuleContext struct {
	stdContext.Context
	Module Module
	Logger *zap.Logger
}

type ModuleID string

type ModuleInfo struct {
	// Name is the name of the module
	ID       ModuleID
	Priority int
	// New is the function that creates a new instance of the module
	New func() Module
}

type ModuleRequestContext interface {
	// RequestContext shared across all modules
	RequestContext
	// SendError returns the most recent error occurred while trying to make the origin request.
	SendError() error
}

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

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

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

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

type OperationBlockerOptions struct {
	BlockMutations              BlockMutationOptions
	BlockSubscriptions          BlockSubscriptionOptions
	BlockNonPersisted           BlockNonPersistedOptions
	BlockPersisted              BlockPersistedOptions
	SafelistEnabled             bool
	LogUnknownOperationsEnabled bool
	// contains filtered or unexported fields
}

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

type OperationContext interface {
	// Name is the name of the operation
	Name() string
	// Type is the type of the operation (query, mutation, subscription)
	Type() string
	// Hash is the hash of the operation
	Hash() uint64
	// Content is the content of the operation
	Content() string
	// Variables is the variables of the operation
	Variables() *astjson.Value
	// ClientInfo returns information about the client that initiated this operation
	ClientInfo() ClientInfo

	// Sha256Hash returns the SHA256 hash of the original operation
	// It is important to note that this hash is not calculated just because this method has been called
	// and is only calculated based on other existing logic (such as if sha256Hash is used in expressions)
	Sha256Hash() string

	// QueryPlanStats returns some statistics about the query plan for the operation
	// if called too early in request chain, it may be inaccurate for modules, using
	// in Middleware is recommended
	QueryPlanStats() (QueryPlanStats, error)

	// Timings returns the timing information for various stages of operation processing
	// if called too early in request chain, it may be inaccurate for modules, using
	// in Middleware is recommended
	Timings() OperationTimings
}

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

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

type OperationMetricsOptions struct {
	InFlightAddOption        otelmetric.AddOption
	SliceAttributes          []attribute.KeyValue
	RouterConfigVersion      string
	RequestContentLength     int64
	RouterMetrics            RouterMetrics
	Logger                   *zap.Logger
	TrackUsageInfo           bool
	PrometheusTrackUsageInfo bool
}

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

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

type OperationProcessorOptions struct {
	Executor                            *Executor
	MaxOperationSizeInBytes             int64
	PersistedOperationClient            *persistedoperation.Client
	AutomaticPersistedOperationCacheTtl int

	EnablePersistedOperationsCache                         bool
	PersistedOpsNormalizationCache                         *ristretto.Cache[uint64, NormalizationCacheEntry]
	NormalizationCache                                     *ristretto.Cache[uint64, NormalizationCacheEntry]
	QueryDepthCache                                        *ristretto.Cache[uint64, ComplexityCacheEntry]
	VariablesNormalizationCache                            *ristretto.Cache[uint64, VariablesNormalizationCacheEntry]
	RemapVariablesCache                                    *ristretto.Cache[uint64, RemapVariablesCacheEntry]
	ValidationCache                                        *ristretto.Cache[uint64, bool]
	OperationHashCache                                     *ristretto.Cache[uint64, string]
	ParseKitPoolSize                                       int
	IntrospectionEnabled                                   bool
	ApolloCompatibilityFlags                               config.ApolloCompatibilityFlags
	ApolloRouterCompatibilityFlags                         config.ApolloRouterCompatibilityFlags
	DisableExposingVariablesContentOnValidationError       bool
	RelaxSubgraphOperationFieldSelectionMergingNullability bool
	ComplexityLimits                                       *config.ComplexityLimits
	ParserTokenizerLimits                                  astparser.TokenizerLimits
	OperationNameLengthLimit                               int
}

type OperationProtocol string

type OperationTimes struct {
	ParseTime     time.Duration
	NormalizeTime time.Duration
	ValidateTime  time.Duration
	PlanTime      time.Duration
}

type OperationTimings struct {
	ParsingTime       time.Duration
	ValidationTime    time.Duration
	PlanningTime      time.Duration
	NormalizationTime time.Duration
}

type OperationType = string

type Option func(svr *Router)

type ParsedOperation struct {
	// ID represents a unique-ish ID for the operation calculated by hashing
	// its normalized representation.
	ID uint64

	// InternalID is the internal ID of the operation calculated by hashing
	// its normalized representation with the original operation name and normalized variables.
	InternalID uint64

	// Sha256Hash is the sha256 hash of the original operation query sent by the client.
	Sha256Hash string

	// Type is a string representing the operation type. One of "query", "mutation", "subscription".
	Type           string
	Variables      *fastjson.Object
	VariablesHash  uint64
	RemapVariables map[string]string

	// NormalizedRepresentation is the normalized representation of the operation as a string.
	// This is provided for modules to be able to access the operation.
	// Only available after the operation has been normalized.
	NormalizedRepresentation string

	Request                    GraphQLRequest
	GraphQLRequestExtensions   GraphQLRequestExtensions
	IsPersistedOperation       bool
	PersistedOperationCacheHit bool

	// NormalizationCacheHit is set to true if the request is a non-persisted operation,
	// and the normalized operation was loaded from cache.
	NormalizationCacheHit bool
}

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

type PlanOptions struct {
	ClientInfo           *ClientInfo
	TraceOptions         resolve.TraceOptions
	ExecutionOptions     resolve.ExecutionOptions
	TrackSchemaUsageInfo bool
}

type PlanOutputFormat string

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

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

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

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

type PreHandlerOptions struct {
	Logger             *zap.Logger
	Executor           *Executor
	Metrics            RouterMetrics
	OperationProcessor *OperationProcessor
	Planner            *OperationPlanner
	AccessController   *AccessController
	OperationBlocker   *OperationBlocker
	RouterPublicKey    *ecdsa.PublicKey
	TracerProvider     *sdktrace.TracerProvider
	ComplexityLimits   *config.ComplexityLimits
	MaxUploadFiles     int
	MaxUploadFileSize  int

	FlushTelemetryAfterResponse            bool
	FileUploadEnabled                      bool
	TraceExportVariables                   bool
	DevelopmentMode                        bool
	EnableRequestTracing                   bool
	AlwaysIncludeQueryPlan                 bool
	AlwaysSkipLoader                       bool
	QueryPlansEnabled                      bool
	QueryPlansLoggingEnabled               bool
	TrackSchemaUsageInfo                   bool
	ClientHeader                           config.ClientHeader
	ComputeOperationSha256                 bool
	ApolloCompatibilityFlags               *config.ApolloCompatibilityFlags
	DisableVariablesRemapping              bool
	ExprManager                            *expr.Manager
	OmitBatchExtensions                    bool
	OperationContentAttributes             bool
	EnableRequestDeduplication             bool
	ForceEnableRequestDeduplication        bool
	HasPreOriginHandlers                   bool
	EnableInboundRequestDeduplication      bool
	ForceEnableInboundRequestDeduplication bool
	HeaderPropagation                      *HeaderPropagation
}

type ProgramWithKey struct {
	Program *vm.Program
	Key     string
}

type Provisioner interface {
	// Provision is called before the server starts
	Provision(*ModuleContext) error
}

type ProxyFunc func(req *http.Request) (*url.URL, error)

type QueryPlanStats struct {
	TotalSubgraphFetches int
	SubgraphFetches      map[string]int
	SubgraphRootFields   []SubgraphRootField
}

type RateLimitStats struct {
	Key                    string `json:"key,omitempty"`
	RequestRate            int    `json:"requestRate"`
	Remaining              int    `json:"remaining"`
	RetryAfterMilliseconds int64  `json:"retryAfterMs"`
	ResetAfterMilliseconds int64  `json:"resetAfterMs"`
}

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

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

type ReportError interface {
	error
	Report() *operationreport.Report
}

type RequestContext interface {
	// ResponseWriter is the original response writer received by the router.
	ResponseWriter() http.ResponseWriter

	// Request is the original request received by the router.
	Request() *http.Request

	// Logger is the logger for the request
	Logger() *zap.Logger

	// Operation is the GraphQL operation
	Operation() OperationContext

	// Set is used to store a new key/value pair exclusively for this context.
	Set(string, any)

	// Get returns the value for the given key, ie: (value, true).
	Get(string) (value any, exists bool)

	// GetString returns the value associated with the key as a string.
	GetString(string) string

	// MustGet returns the value for the given key if it exists, otherwise it panics.
	MustGet(string) any

	// GetBool returns the value associated with the key as a boolean.
	GetBool(string) bool

	// GetInt returns the value associated with the key as an integer.
	GetInt(string) int

	// GetInt64 returns the value associated with the key as an integer.
	GetInt64(string) int64

	// GetUint returns the value associated with the key as an unsigned integer.
	GetUint(string) uint

	// GetUint64 returns the value associated with the key as an unsigned integer.
	GetUint64(string) uint64

	// GetFloat64 returns the value associated with the key as a float64.
	GetFloat64(string) float64

	// GetTime returns the value associated with the key as time.
	GetTime(string) time.Time

	// GetDuration returns the value associated with the key as a duration.
	GetDuration(string) time.Duration

	// GetStringSlice returns the value associated with the key as a slice of strings.
	GetStringSlice(string) []string

	// GetStringMap returns the value associated with the key as a map of interfaces.
	GetStringMap(string) map[string]any

	// GetStringMapString returns the value associated with the key as a map of strings.
	GetStringMapString(string) map[string]string

	// GetStringMapStringSlice returns the value associated with the key as a map to a slice of strings.
	GetStringMapStringSlice(string) map[string][]string

	// ActiveSubgraph returns the current subgraph to which the request is made to
	ActiveSubgraph(subgraphRequest *http.Request) *Subgraph

	// SubgraphByID return the subgraph by its ID
	SubgraphByID(subgraphID string) *Subgraph

	// Authentication returns the authentication information for the request, if any
	Authentication() authentication.Authentication

	// SetAuthenticationScopes sets the scopes for the request on Authentication
	// If Authentication is not set, it will be initialized with the scopes
	SetAuthenticationScopes(scopes []string)

	// SetCustomFieldValueRenderer overrides the default field value rendering behavior
	// This can be used, e.g. to obfuscate sensitive data in the response
	SetCustomFieldValueRenderer(renderer resolve.FieldValueRenderer)

	// SetForceSha256Compute forces the computation of the Sha256Hash of the operation
	// This is useful if the Sha256Hash is needed in custom modules but not used anywhere else
	SetForceSha256Compute()

	// Error returns the error associated with the request, if any
	Error() error
}

type RequiredAndScopes struct {
	RequiredAndScopes []string `json:"and"`
}

type Router struct {
	Config

	EngineStats statistics.EngineStatistics
	// contains filtered or unexported fields
}

type RouterConfigPollerConfig struct {
	config.ExecutionConfig
	PollInterval time.Duration
	PollJitter   time.Duration
	GraphSignKey string
}

type RouterEngineConfiguration struct {
	Execution                config.EngineExecutionConfiguration
	Headers                  *config.HeaderRules
	Events                   config.EventsConfiguration
	SubgraphErrorPropagation config.SubgraphErrorPropagationConfiguration
	StreamMetricStore        rmetric.StreamMetricStore
}

type RouterMetrics interface {
	StartOperation(logger *zap.Logger, requestContentLength int64, sliceAttr []attribute.KeyValue, inFlightAddOption otelmetric.AddOption) *OperationMetrics
	ExportSchemaUsageInfo(operationContext *operationContext, statusCode int, hasError bool, exportSynchronous bool)
	ExportSchemaUsageInfoPrometheus(operationContext *operationContext, statusCode int, hasError bool, exportSynchronous bool)
	GQLMetricsExporter() *graphqlmetrics.GraphQLMetricsExporter
	PrometheusMetricsExporter() *graphqlmetrics.PrometheusMetricsExporter
	MetricStore() metric.Store
}

type RouterMiddlewareHandler interface {
	// Middleware is the middleware handler
	Middleware(ctx RequestContext, next http.Handler)
}

type RouterOnRequestHandler interface {
	RouterOnRequest(ctx RequestContext, next http.Handler)
}

type RouterResources struct {
	Config                *config.Config
	Logger                *zap.Logger
	ReloadPersistentState *ReloadPersistentState
}

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

type RouterSupervisorOpts struct {
	BaseLogger            *zap.Logger
	ConfigFactory         func() (*config.Config, error)
	RouterFactory         func(ctx context.Context, res *RouterResources) (*Router, error)
	ReloadPersistentState *ReloadPersistentState
}

type SafelistPersistedOptions struct {
	Enabled bool
}

type Server interface {
	HttpServer() *http.Server
	HealthChecks() health.Checker
}

type StreamHandlerError struct {
	// The message for this error.
	Message string
}

type StreamPublishEventHandler interface {
	// OnPublishEvents is called each time a batch of events is going to be sent to a provider.
	// The events argument contains all events from a batch.
	// Use events.All() to iterate through them and event.Clone() to create mutable copies, when needed.
	// Returning an error will result in a GraphQL error being returned to the client, could be customized returning a
	// StreamHookError.
	OnPublishEvents(ctx StreamPublishEventHandlerContext, events datasource.StreamEvents) (datasource.StreamEvents, error)
}

type StreamPublishEventHandlerContext interface {
	// Request is the original request received by the router.
	Request() *http.Request
	// Logger is the logger for the request
	Logger() *zap.Logger
	// Operation is the GraphQL operation
	Operation() OperationContext
	// Authentication is the authentication for the request
	Authentication() authentication.Authentication
	// PublishEventConfiguration the publish event configuration
	PublishEventConfiguration() datasource.PublishEventConfiguration
	// NewEvent creates a new event that can be used in the subscription.
	//
	// The data parameter must contain valid JSON bytes representing the event payload
	// that will be sent to your message broker (Kafka, NATS, etc.). The JSON must have
	// properly quoted property names and must include the __typename field required by GraphQL.
	// For example: []byte(`{"__typename": "Employee", "id": 1, "update": {"name": "John"}}`).
	//
	// This method is typically used in OnPublishEvents hooks to create new or modified events
	// before they are sent to the message broker.
	NewEvent(data []byte) datasource.MutableStreamEvent
}

type StreamReceiveEventHandler interface {
	// OnReceiveEvents is called whenever a batch of events is received from a provider,
	// before delivering them to clients.
	// The hook will be called once for each active subscription, therefore it is adviced to
	// avoid resource heavy computation or blocking tasks whenever possible.
	// The events argument contains all events from a batch and is shared between
	// all active subscribers of these events.
	// Use events.All() to iterate through them and event.Clone() to create mutable copies, when needed.
	// Returning an error will result in the subscription being closed and the error being logged.
	OnReceiveEvents(ctx StreamReceiveEventHandlerContext, events datasource.StreamEvents) (datasource.StreamEvents, error)
}

type StreamReceiveEventHandlerContext interface {
	// Context is a context for handlers.
	// If it is cancelled, the handler should stop processing.
	Context() context.Context
	// Request is the initial client request that started the subscription
	Request() *http.Request
	// Logger is the logger for the request
	Logger() *zap.Logger
	// Operation is the GraphQL operation
	Operation() OperationContext
	// Authentication is the authentication for the request
	Authentication() authentication.Authentication
	// SubscriptionEventConfiguration the subscription event configuration
	SubscriptionEventConfiguration() datasource.SubscriptionEventConfiguration
	// NewEvent creates a new event that can be used in the subscription.
	//
	// The data parameter must contain valid JSON bytes representing the raw event payload
	// from your message broker (Kafka, NATS, etc.). The JSON must have properly quoted
	// property names and must include the __typename field required by GraphQL.
	// For example: []byte(`{"__typename": "Employee", "id": 1, "update": {"name": "John"}}`).
	//
	// This method is typically used in OnReceiveEvents hooks to create new or modified events.
	NewEvent(data []byte) datasource.MutableStreamEvent
}

type Subgraph struct {
	Id        string
	Name      string
	Url       *url.URL
	UrlString string
}

type SubgraphCircuitBreakerOptions struct {
	CircuitBreaker circuit.CircuitBreakerConfig
	SubgraphMap    map[string]circuit.CircuitBreakerConfig
}

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

type SubgraphRootField struct {
	SubgraphName string
	TypeName     string
	FieldName    string
	Count        int
}

type SubgraphTransportOptions struct {
	*TransportRequestOptions
	SubgraphMap map[string]*TransportRequestOptions
}

type SubscriptionClientOptions struct {
	PingInterval time.Duration
	PingTimeout  time.Duration
	ReadTimeout  time.Duration
	FrameTimeout time.Duration
}

type SubscriptionOnStartHandler interface {
	// SubscriptionOnStart is called once at subscription start
	// The error is propagated to the client.
	SubscriptionOnStart(ctx SubscriptionOnStartHandlerContext) error
}

type SubscriptionOnStartHandlerContext interface {
	// Request is the original request received by the router.
	Request() *http.Request
	// Logger is the logger for the request
	Logger() *zap.Logger
	// Operation is the GraphQL operation
	Operation() OperationContext
	// Authentication is the authentication for the request
	Authentication() authentication.Authentication
	// SubscriptionEventConfiguration is the subscription event configuration (will return nil for engine subscription)
	SubscriptionEventConfiguration() datasource.SubscriptionEventConfiguration
	// EmitEvent sends an event directly to the subscription stream of the
	// currently connected client.
	//
	// This method triggers the router to resolve the client's operation and emit
	// the resulting data as a stream event. The event exists only within the
	// router; it is not forwarded to any message broker.
	//
	// The event is delivered exclusively to the client associated with the current
	// handler execution. No other subscriptions are affected.
	//
	// The method returns true if the event was successfully emitted, or false if
	// it was dropped.
	EmitEvent(event datasource.StreamEvent) bool
	// NewEvent creates a new event that can be used in the subscription.
	//
	// The data parameter must contain valid JSON bytes. The format depends on the subscription type.
	//
	// For event-driven subscriptions (Cosmo Streams / EDFS), the data should contain:
	// __typename : The name of the schema entity, which is expected to be returned to the client.
	// {keyName} : The key of the entity as configured on the schema via @key directive.
	// Example usage: ctx.NewEvent([]byte(`{"__typename": "Employee", "id": 1}`))
	//
	// For normal subscriptions, you need to provide the complete GraphQL response structure.
	// Example usage: ctx.NewEvent([]byte(`{"data": {"fieldName": value}}`))
	//
	// You can use EmitEvent to emit this event to subscriptions.
	NewEvent(data []byte) datasource.MutableStreamEvent
}

type SubscriptionParams struct {
	UseSse        bool
	SubscribeOnce bool
	UseMultipart  bool
}

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

type TlsClientAuthConfig struct {
	Required bool
	CertFile string
}

type TlsConfig struct {
	Enabled  bool
	CertFile string
	KeyFile  string

	ClientAuth *TlsClientAuthConfig
}

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

type TracePropagationProvider interface {
	// TracePropagators returns the custom trace propagators which should be used by the router.
	TracePropagators() []propagation.TextMapPropagator
}

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

type TransportOptions struct {
	PreHandlers                   []TransportPreHandler
	PostHandlers                  []TransportPostHandler
	SubgraphTransportOptions      *SubgraphTransportOptions
	RetryOptions                  retrytransport.RetryOptions
	LocalhostFallbackInsideDocker bool
	MetricStore                   metric.Store
	ConnectionMetricStore         metric.ConnectionMetricStore
	CircuitBreaker                *circuit.Manager
	Logger                        *zap.Logger
	TracerProvider                *sdktrace.TracerProvider
	TracePropagators              propagation.TextMapPropagator
	EnableTraceClient             bool
}

type TransportPostHandler func(resp *http.Response, ctx RequestContext) *http.Response

type TransportPreHandler func(req *http.Request, ctx RequestContext) (*http.Request, *http.Response)

type TransportRequestOptions struct {
	RequestTimeout         time.Duration
	ResponseHeaderTimeout  time.Duration
	ExpectContinueTimeout  time.Duration
	KeepAliveIdleTimeout   time.Duration
	DialTimeout            time.Duration
	TLSHandshakeTimeout    time.Duration
	KeepAliveProbeInterval time.Duration

	MaxConnsPerHost     int
	MaxIdleConns        int
	MaxIdleConnsPerHost int
}

type UsageTracker interface {
	Close()
	TrackUptime(ctx context.Context)
	TrackRouterConfigUsage(usage map[string]any)
	TrackExecutionConfigUsage(usage map[string]any)
}

type UsageTrackerNoOp struct{}

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

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

type WebSocketConnectionHandlerOptions struct {
	ClientInfoFromInitialPayload config.WebSocketClientInfoFromInitialPayloadConfiguration
	ForwardInitialPayload        bool
	OperationProcessor           *OperationProcessor
	OperationBlocker             *OperationBlocker
	Planner                      *OperationPlanner
	GraphQLHandler               *GraphQLHandler
	PreHandler                   *PreHandler
	Metrics                      RouterMetrics
	ResponseWriter               http.ResponseWriter
	Request                      *http.Request
	Connection                   *wsConnectionWrapper
	Protocol                     wsproto.Proto
	Logger                       *zap.Logger
	Stats                        statistics.EngineStatistics
	PlanOptions                  PlanOptions
	ConnectionID                 int64
	ClientInfo                   *ClientInfo
	InitRequestID                string
	ForwardUpgradeHeaders        forwardConfig
	ForwardQueryParams           forwardConfig
	DisableVariablesRemapping    bool
	ApolloCompatibilityFlags     config.ApolloCompatibilityFlags
}

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

type WebsocketMiddlewareOptions struct {
	OperationProcessor *OperationProcessor
	OperationBlocker   *OperationBlocker
	Planner            *OperationPlanner
	GraphQLHandler     *GraphQLHandler
	PreHandler         *PreHandler
	Metrics            RouterMetrics
	AccessController   *AccessController
	Logger             *zap.Logger
	Stats              statistics.EngineStatistics
	ReadTimeout        time.Duration
	WriteTimeout       time.Duration

	EnableNetPoll         bool
	NetPollTimeout        time.Duration
	NetPollConnBufferSize int

	WebSocketConfiguration *config.WebSocketConfiguration
	ClientHeader           config.ClientHeader

	DisableVariablesRemapping bool

	ApolloCompatibilityFlags config.ApolloCompatibilityFlags
}