dagql

type AllView struct{}

type AnyObjectResult interface {
	AnyResult

	// ObjectType returns the type of the object.
	ObjectType() ObjectType

	// Receiver resolves the object result referenced by this result call's receiver, if any.
	Receiver(context.Context, *Server) (AnyObjectResult, error)

	// Select evaluates the field selected by the given selector and returns the result.
	//
	// The returned value is the raw Typed value returned from the field; it must
	// be instantiated with a class for further selection.
	//
	// Any Nullable values are automatically unwrapped.
	Select(context.Context, *Server, Selector) (AnyResult, error)
}

type AnyResult interface {
	Typed
	Wrapper
	IDable
	RecipeIDable
	Setter

	// RecipeDigest returns the semantic recipe digest of the value.
	RecipeDigest(context.Context) (digest.Digest, error)

	// DerefValue returns an AnyResult when the wrapped value is Derefable and
	// has a value set. If the value is not derefable, it returns itself.
	DerefValue() (AnyResult, bool)

	// NthValue returns the Nth value of the wrapped value when the wrapped value
	// is an Enumerable. If the wrapped value is not Enumerable, it returns an error.
	NthValue(context.Context, int) (AnyResult, error)

	// NullableWrapped returns a nullable view over the same underlying result.
	NullableWrapped() AnyResult

	// WithContentDigest returns a new AnyResult with the given content digest.
	WithContentDigestAny(context.Context, digest.Digest) (AnyResult, error)
	// WithSessionResourceHandle returns a new AnyResult with the given session resource handle.
	WithSessionResourceHandleAny(context.Context, SessionResourceHandle) (AnyResult, error)

	HitCache() bool
	ResultCall() (*ResultCall, error)
	// contains filtered or unexported methods
}

type ArbitraryCachedResult interface {
	Value() any
	HitCache() bool
}

type Argument struct {
	Spec InputSpec
}

type AroundFunc func(
	context.Context,
	*CallRequest,
) (context.Context, func(res AnyResult, cached bool, err *error))

type Array[T Typed] []T

type ArrayInput[I Input] []I

type Boolean bool

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

type CacheDebugArbitraryCall struct {
	CallKey           string `json:"call_key"`
	Waiters           int    `json:"waiters"`
	OwnerSessionCount int    `json:"owner_session_count"`
	Completed         bool   `json:"completed"`
	HasValue          bool   `json:"has_value"`
	ValueType         string `json:"value_type,omitempty"`
	Error             string `json:"error,omitempty"`
}

type CacheDebugOngoingCall struct {
	CallKey           string `json:"call_key"`
	ConcurrencyKey    string `json:"concurrency_key,omitempty"`
	Waiters           int    `json:"waiters"`
	IsPersistable     bool   `json:"is_persistable"`
	TTLSeconds        int64  `json:"ttl_seconds,omitempty"`
	Completed         bool   `json:"completed"`
	Error             string `json:"error,omitempty"`
	SharedResultID    uint64 `json:"shared_result_id,omitempty"`
	ResultDescription string `json:"result_description,omitempty"`
	ResultRecordType  string `json:"result_record_type,omitempty"`
	ResultTypeName    string `json:"result_type_name,omitempty"`
}

type CacheDebugResult struct {
	EGraphDebugResult
	ResultCall                            *ResultCall      `json:"result_call,omitempty"`
	ResultCallRecipeDigest                string           `json:"result_call_recipe_digest,omitempty"`
	ResultCallRecipeDigestError           string           `json:"result_call_recipe_digest_error,omitempty"`
	ResultCallContentPreferredDigest      string           `json:"result_call_content_preferred_digest,omitempty"`
	ResultCallContentPreferredDigestError string           `json:"result_call_content_preferred_digest_error,omitempty"`
	ResultCallInputDigests                []string         `json:"result_call_input_digests,omitempty"`
	ResultCallInputDigestsError           string           `json:"result_call_input_digests_error,omitempty"`
	AssociatedTermIDs                     []uint64         `json:"associated_term_ids,omitempty"`
	IndexedDigests                        []string         `json:"indexed_digests,omitempty"`
	ExpiresAtUnix                         int64            `json:"expires_at_unix,omitempty"`
	CreatedAtUnixNano                     int64            `json:"created_at_unix_nano,omitempty"`
	LastUsedAtUnixNano                    int64            `json:"last_used_at_unix_nano,omitempty"`
	CacheUsageSizeByIdentity              map[string]int64 `json:"cache_usage_size_by_identity,omitempty"`
	PersistedEnvelopeKind                 string           `json:"persisted_envelope_kind,omitempty"`
	PersistedEnvelopeTypeName             string           `json:"persisted_envelope_type_name,omitempty"`
}

type CacheDebugResultDigestIndex struct {
	Digest          string   `json:"digest"`
	SharedResultIDs []uint64 `json:"shared_result_ids"`
}

type CacheDebugSessionResults struct {
	SessionID       string   `json:"session_id"`
	SharedResultIDs []uint64 `json:"shared_result_ids"`
}

type CacheDebugSnapshot struct {
	TraceFormatVersion      int                           `json:"trace_format_version"`
	BootID                  string                        `json:"boot_id"`
	CapturedAtSeq           uint64                        `json:"captured_at_seq"`
	CapturedAtTime          string                        `json:"captured_at_time"`
	SessionResults          []CacheDebugSessionResults    `json:"session_results,omitempty"`
	Results                 []CacheDebugResult            `json:"results"`
	ResultDigestIndexes     []CacheDebugResultDigestIndex `json:"result_digest_indexes"`
	Terms                   []EGraphDebugTerm             `json:"terms"`
	ResultTerms             []EGraphDebugResultTerm       `json:"result_terms"`
	Digests                 []EGraphDebugDigestMapping    `json:"digests"`
	EqClasses               []EGraphDebugEqClass          `json:"eq_classes"`
	OngoingCalls            []CacheDebugOngoingCall       `json:"ongoing_calls,omitempty"`
	OngoingArbitraryCalls   []CacheDebugArbitraryCall     `json:"ongoing_arbitrary_calls,omitempty"`
	CompletedArbitraryCalls []CacheDebugArbitraryCall     `json:"completed_arbitrary_calls,omitempty"`
}

type CacheEntryStats struct {
	OngoingCalls            int
	CompletedCalls          int
	RetainedCalls           int
	CompletedCallsByContent int
	OngoingArbitrary        int
	CompletedArbitrary      int
}

type CachePersistenceResetReason string

type CachePrunePolicy struct {
	All           bool
	Filters       []string
	KeepDuration  time.Duration
	ReservedSpace int64
	MaxUsedSpace  int64
	MinFreeSpace  int64
	TargetSpace   int64

	// CurrentFreeSpace is optional available-disk bytes at prune start used to
	// evaluate MinFreeSpace. When unset, MinFreeSpace behaves as if free space
	// were zero.
	CurrentFreeSpace int64
}

type CachePruneReport struct {
	Entries        []CacheUsageEntry
	ReclaimedBytes int64
}

type CacheUsageEntry struct {
	ID                        string
	Description               string
	RecordType                string
	RecordTypes               []string
	DagqlCall                 string
	SizeBytes                 int64
	CreatedTimeUnixNano       int64
	MostRecentUseTimeUnixNano int64
	ActivelyUsed              bool
}

type CallRequest struct {
	*ResultCall

	ConcurrencyKey string
	TTL            int64
	DoNotCache     bool
	IsPersistable  bool
}

type Class[T Typed] struct {
	// contains filtered or unexported fields
}

type ClassOpts[T Typed] struct {
	// NoIDs disables the default "id" field and disables the IDType method.
	NoIDs bool

	// Typed contains the Typed value whose Type() determines the class's type.
	//
	// In the simple case, we can just use a zero-value, but it is also allowed
	// to use a dynamic Typed value.
	Typed T

	// The inner type sourceMap directive so additional type
	// registered by the engine can store also store its origin.
	SourceMap *ast.Directive
}

type DecoderFunc func(any) (Input, error)

type Definitive interface {
	TypeDefinition(view call.View) *ast.Definition
}

type DependencyResult struct {
	Result AnyResult
	// Owned is true when the parent's install span should also be attributed
	// to this dep for lazy failure causality. False marks the edge as
	// liveness-only — the dep is kept alive by the parent and preflighted
	// before the parent's lazy callback, but failures in the dep do not
	// short-circuit attribution onto the parent's install span.
	Owned bool
}

type Derefable interface {
	Deref() (Typed, bool)
}

type DerefableResult interface {
	Derefable
	DerefToResult(call *ResultCall) (AnyResult, bool)
}

type Descriptive interface {
	TypeDescription() string
}

type DigestedSerializedString[T any] struct {
	Self   T
	Digest digest.Digest
}

type DirectiveLocation string

type DirectiveSpec struct {
	Name         string              `field:"true"`
	Description  string              `field:"true"`
	Args         InputSpecs          `field:"true"`
	Locations    []DirectiveLocation `field:"true"`
	IsRepeatable bool                `field:"true"`
}

type DynamicArrayInput struct {
	Elem   Input
	Values []Input
}

type DynamicArrayOutput struct {
	Elem   Typed
	Values []Typed
}

type DynamicInputFunc[T Typed, A any] func(
	context.Context,
	ObjectResult[T],
	A,
	*CallRequest,
) error

type DynamicNullable struct {
	Elem  Typed
	Value Typed
	Valid bool
}

type DynamicOptional struct {
	Elem  Input
	Value Input
	Valid bool
}

type DynamicResultArrayOutput struct {
	Elem   Typed
	Values []AnyResult
}

type EGraphDebugDigestMapping struct {
	Digest    string `json:"digest"`
	EqClassID uint64 `json:"eq_class_id"`
}

type EGraphDebugEqClass struct {
	EqClassID uint64   `json:"eq_class_id"`
	Digests   []string `json:"digests"`
}

type EGraphDebugInputProvenance struct {
	Kind string `json:"kind"`
}

type EGraphDebugResult struct {
	SharedResultID           uint64                     `json:"shared_result_id"`
	OutputEqClassIDs         []uint64                   `json:"output_eq_class_ids,omitempty"`
	RecordType               string                     `json:"record_type,omitempty"`
	Description              string                     `json:"description,omitempty"`
	TypeName                 string                     `json:"type_name,omitempty"`
	IncomingOwnershipCount   int64                      `json:"incoming_ownership_count"`
	HasValue                 bool                       `json:"has_value"`
	PayloadState             string                     `json:"payload_state"`
	HasPersistedEdge         bool                       `json:"has_persisted_edge"`
	PersistedEdgeUnpruneable bool                       `json:"persisted_edge_unpruneable"`
	ExplicitDeps             []uint64                   `json:"explicit_dep_ids,omitempty"`
	HeldDependencyResults    int                        `json:"held_dependency_results_count"`
	SnapshotLinks            []PersistedSnapshotRefLink `json:"snapshot_links,omitempty"`
}

type EGraphDebugResultTerm struct {
	SharedResultID  uint64                       `json:"shared_result_id"`
	TermID          uint64                       `json:"term_id"`
	InputProvenance []EGraphDebugInputProvenance `json:"input_provenance,omitempty"`
}

type EGraphDebugSnapshot struct {
	TraceFormatVersion int                        `json:"trace_format_version"`
	BootID             string                     `json:"boot_id"`
	CapturedAtSeq      uint64                     `json:"captured_at_seq"`
	CapturedAtTime     string                     `json:"captured_at_time"`
	Results            []EGraphDebugResult        `json:"results"`
	Terms              []EGraphDebugTerm          `json:"terms"`
	ResultTerms        []EGraphDebugResultTerm    `json:"result_terms"`
	Digests            []EGraphDebugDigestMapping `json:"digests"`
	EqClasses          []EGraphDebugEqClass       `json:"eq_classes"`
}

type EGraphDebugTerm struct {
	TermID     uint64   `json:"term_id"`
	SelfDigest string   `json:"self_digest"`
	InputEqIDs []uint64 `json:"input_eq_ids"`
	TermDigest string   `json:"term_digest"`
	OutputEqID uint64   `json:"output_eq_id"`
}

type EnumValue[T enumValue] struct {
	Value       T
	Underlying  T
	Description string
	View        ViewFilter
}

type EnumValueName struct {
	Enum string
	Name string
}

type EnumValues[T enumValue] []EnumValue[T]

type Enumerable interface {
	// Element returns the element of the Enumerable.
	Element() Typed
	// Len returns the number of elements in the Enumerable.
	Len() int
	// Nth returns the Nth element of the Enumerable, with 1 representing the
	// first entry.
	Nth(int) (Typed, error)

	NthValue(i int, call *ResultCall) (AnyResult, error)
}

type ExactView string

type ExtendedError interface {
	error
	Extensions() map[string]any
}

type Field[T Typed] struct {
	Spec *FieldSpec
	Func func(context.Context, ObjectResult[T], map[string]Input, call.View) (AnyResult, error)
}

type FieldFunc func(context.Context, AnyResult, map[string]Input) (AnyResult, error)

type FieldSpec struct {
	// Name is the name of the field.
	Name string
	// Description is the description of the field.
	Description string
	// Args is the list of arguments that the field accepts.
	Args InputSpecs
	// Type is the type of the field's result.
	Type Typed
	// Sensitive indicates that the value returned by this field is sensitive and
	// should not be displayed in telemetry.
	Sensitive bool
	// DeprecatedReason deprecates the field and provides a reason.
	DeprecatedReason *string
	// ExperimentalReason marks the field as experimental and provides a reason.
	ExperimentalReason string
	// Module is frame-native provenance for the module that provides the field's
	// implementation.
	Module *ResultCallModule
	// Directives is the list of GraphQL directives attached to this field.
	Directives []*ast.Directive
	// BuiltinLoadByIDFunc is the execution path for schema-generated
	// load<Type>FromID fields, which re-enter the graph from an object ID
	// rather than behaving like normal field resolvers.
	BuiltinLoadByIDFunc LoadByIDFunc

	// ViewFilter is filter that specifies under which views this field is
	// accessible. If not view is present, the default is the "global" view.
	ViewFilter ViewFilter

	// If set, the result of this field will never be cached and not have concurrent equal
	// calls deduped. The string value is a reason why the field should not be cached.
	DoNotCache string

	// If set, the result of this field will be cached for the given TTL (in seconds).
	TTL int64

	// If set, the result of this field is eligible for persistent cache storage.
	IsPersistable bool

	// If set, this GetDynamicInput will be called before cache evaluation to
	// make any dynamic adjustments to the call request or its policy.
	GetDynamicInput GenericDynamicInputFunc

	// ImplicitInputs are engine-computed inputs that are attached to the call
	// identity but are not explicit GraphQL field args.
	ImplicitInputs []ImplicitInput

	// NoTelemetry suppresses telemetry (AroundFunc) for this field.
	// Used for entrypoint proxies that delegate to real fields which
	// emit their own telemetry.
	NoTelemetry bool

	// Trivial marks fields that only unwrap data from their receiver rather
	// than performing meaningful work. Used to suppress install-span capture
	// for synthetic accessors (e.g. auto-generated module object field
	// accessors) so they don't claim ownership of values they merely return.
	Trivial bool
	// contains filtered or unexported fields
}

type Fields[T Typed] []Field[T]

type Float float64

type ForkableObjectType interface {
	ForkObjectType(*Server) (ObjectType, error)
}

type FuncHandler[T Typed, A any, R any] func(ctx context.Context, self T, args A) (R, error)

type GenericDynamicInputFunc func(
	context.Context,
	AnyResult,
	map[string]Input,
	call.View,
	*CallRequest,
) error

type HasDependencyResults interface {
	AttachDependencyResults(context.Context, AnyResult, func(AnyResult) (AnyResult, error)) ([]AnyResult, error)
}

type HasDependencyResultsKinds interface {
	AttachDependencyResultsKinds(context.Context, AnyResult, func(AnyResult) (AnyResult, error)) ([]DependencyResult, error)
}

type HasLazyEvaluation interface {
	LazyEvalFunc() LazyEvalFunc
}

type ID[T Typed] struct {
	// contains filtered or unexported fields
}

type IDType interface {
	Input
	IDable
	ScalarType
}

type IDable interface {
	// ID returns the runtime handle ID of the value.
	ID() (*call.ID, error)
}

type ImplicitInput struct {
	Name     string
	Resolver ImplicitInputResolver
}

type ImplicitInputResolver func(context.Context, map[string]Input) (Input, error)

type Input interface {
	// All Inputs are typed.
	Typed
	// All Inputs are able to be represented as a Literal.
	call.Literate
	// All Inputs now how to decode new instances of themselves.
	Decoder() InputDecoder
}

type InputDecoder interface {
	// Decode converts a value to the Input type, if possible.
	DecodeInput(any) (Input, error)
}

type InputObject[T Type] struct {
	Value T
	// contains filtered or unexported fields
}

type InputObjectSpec struct {
	Name        string
	Description string
	Fields      InputSpecs
}

type InputSpec struct {
	// Name is the name of the argument.
	Name string
	// Description is the description of the argument.
	Description string
	// Type is the type of the argument.
	Type Input
	// Default is the default value of the argument.
	Default Input
	// DeprecatedReason deprecates the input and provides a reason.
	DeprecatedReason *string
	// ExperimentalReason marks the field as experimental and provides a reason.
	ExperimentalReason string
	// Sensitive indicates that the value of this arg is sensitive and should be
	// omitted from telemetry.
	Sensitive bool
	// Directives is the list of GraphQL directives attached to this input.
	Directives []*ast.Directive

	// ViewFilter is filter that specifies under which views this field is
	// accessible. If not view is present, the default is the "global" view.
	ViewFilter ViewFilter

	// Internal indicates that this input can only be set by internal server
	// calls, never by external clients. It may appear in IDs sent to/from
	// clients, but can't be set in new graphql queries.
	// This argument will not be exposed in the introspection schema.
	Internal bool
}

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

type Inputs []NamedInput

type InstallHook interface {
	InstallObject(ObjectType, ...*ast.Directive)
}

type InstallHookForker interface {
	ForkInstallHook(*Server) InstallHook
}

type Int int64

type InterfaceValue interface {
	// UnderlyingObject returns the underlying object of the InterfaceValue
	UnderlyingObject() (Typed, error)
}

type LazyEvalFunc func(context.Context) error

type LoadByIDFunc func(context.Context, AnyResult, map[string]Input) (AnyResult, error)

type NamedInput struct {
	Name  string
	Value Input
}

type NodeFuncHandler[T Typed, A any, R any] func(ctx context.Context, self ObjectResult[T], args A) (R, error)

type Nullable[T Typed] struct {
	Value T
	Valid bool
}

type ObjectResult[T Typed] struct {
	Result[T]
	// contains filtered or unexported fields
}

type ObjectResultArray[T Typed] []ObjectResult[T]

type ObjectType interface {
	Type
	// Typed returns a Typed value whose Type refers to the object type.
	Typed() Typed
	// IDType returns the scalar type for the object's IDs.
	IDType() (IDType, bool)
	// New creates a new instance of the type.
	New(val AnyResult) (AnyObjectResult, error)
	// ParseField parses the given field and returns a Selector and an expected
	// return type.
	ParseField(ctx context.Context, view call.View, astField *ast.Field, vars map[string]any) (Selector, *ast.Type, error)
	// Extend registers an additional field onto the type.
	//
	// Unlike natively added fields, the extended func is limited to the external
	// Object interface.
	// cacheConfigFunc is optional, if not set the default dagql ID cache key will be used.
	Extend(spec FieldSpec, fun FieldFunc)
	// ExtendLoadByID registers a builtin load<Type>FromID field that re-enters
	// the graph from an object ID instead of behaving like a normal field
	// resolver.
	ExtendLoadByID(spec FieldSpec, fun LoadByIDFunc)
	// FieldSpec looks up a field spec by name.
	FieldSpec(name string, view call.View) (FieldSpec, bool)
	// FieldSpecs returns all field specs visible under the given view.
	FieldSpecs(view call.View) []FieldSpec
}

type OnReleaseFunc = func(context.Context) error

type OnReleaser interface {
	OnRelease(context.Context) error
}

type OperationLeaseProvider interface {
	WithOperationLease(context.Context) (context.Context, func(context.Context) error, error)
}

type OperationLeaseProviderFunc func(context.Context) (context.Context, func(context.Context) error, error)

type Optional[I Input] struct {
	Value I
	// true if the value is set
	Valid bool
}

type PanicError struct {
	Cause     any
	Self      AnyResult
	Selection Selection
	Stack     []byte
}

type PersistedObject interface {
	Typed
	EncodePersistedObject(context.Context, PersistedObjectCache) (PersistedObjectEncoding, error)
}

type PersistedObjectCache interface {
	PersistedResultID(AnyResult) (uint64, error)
}

type PersistedObjectDecoder interface {
	Typed
	DecodePersistedObject(context.Context, *Server, uint64, *ResultCall, json.RawMessage) (Typed, error)
}

type PersistedObjectEncoding struct {
	JSON          json.RawMessage
	SnapshotLinks []PersistedSnapshotRefLink
}

type PersistedResultEncoding struct {
	Envelope      PersistedResultEnvelope
	SnapshotLinks []PersistedSnapshotRefLink
}

type PersistedResultEnvelope struct {
	Version               int                       `json:"version"`
	Kind                  string                    `json:"kind"`
	TypeName              string                    `json:"typeName,omitempty"`
	ResultID              uint64                    `json:"resultID,omitempty"`
	SessionResourceHandle SessionResourceHandle     `json:"sessionResourceHandle,omitempty"`
	ObjectJSON            json.RawMessage           `json:"objectJSON,omitempty"`
	ScalarJSON            json.RawMessage           `json:"scalarJSON,omitempty"`
	ElemTypeName          string                    `json:"elemTypeName,omitempty"`
	Items                 []PersistedResultEnvelope `json:"items,omitempty"`
}

type PersistedSelfCodec interface {
	EncodeResult(context.Context, PersistedObjectCache, AnyResult) (PersistedResultEncoding, error)
	DecodeResult(context.Context, *Server, uint64, *ResultCall, PersistedResultEnvelope) (AnyResult, error)
}

type PersistedSnapshotRefLink struct {
	RefKey string
	Role   string
}

type PersistedSnapshotRefLinkProvider interface {
	PersistedSnapshotRefLinks() []PersistedSnapshotRefLink
}

type RecipeIDable interface {
	// RecipeID returns the semantic recipe ID of the value.
	RecipeID(context.Context) (*call.ID, error)
}

type Result[T Typed] struct {
	// contains filtered or unexported fields
}

type ResultArray[T Typed] []Result[T]

type ResultCall struct {
	Kind        ResultCallKind  `json:"kind"`
	Type        *ResultCallType `json:"type,omitempty"`
	Field       string          `json:"field,omitempty"`
	SyntheticOp string          `json:"syntheticOp,omitempty"`
	View        call.View       `json:"view,omitempty"`
	Nth         int64           `json:"nth,omitempty"`
	EffectIDs   []string        `json:"effectIDs,omitempty"`
	// ExtraDigests are the original extra digests explicitly attached when this
	// call/result was first created. They are useful provenance, but they are
	// not the authoritative merged digest state. The cache/e-graph remains the
	// source of truth for the full merged output-equivalence digest set.
	ExtraDigests   []call.ExtraDigest `json:"extraDigests,omitempty"`
	Receiver       *ResultCallRef     `json:"receiver,omitempty"`
	Module         *ResultCallModule  `json:"module,omitempty"`
	Args           []*ResultCallArg   `json:"args,omitempty"`
	ImplicitInputs []*ResultCallArg   `json:"implicitInputs,omitempty"`
	// contains filtered or unexported fields
}

type ResultCallArg struct {
	Name        string             `json:"name,omitempty"`
	IsSensitive bool               `json:"isSensitive,omitempty"`
	Value       *ResultCallLiteral `json:"value,omitempty"`
}

type ResultCallKind string