runtime

type ActionPlanOperation struct {
	Decision Decision             `json:"decision"`
	Desired  *PlannedActionTarget `json:"desired,omitempty"`
	Prior    *ActionStatePayload  `json:"prior,omitempty"`
}

type ActionRegistration interface {
	NewReceiver() any
	Run(ctx context.Context, receiver, cfg any) (any, error)
	OutputType() reflect.Type
}

type ActionStatePayload = state.ActionStatePayload

type AnyInputField[In any] interface {
	// contains filtered or unexported methods
}

type AnyOutputField[Out any] interface {
	// contains filtered or unexported methods
}

type ApplyError struct {
	Address        string
	Kind           NodeKind
	Decision       Decision
	Alias          string
	LibraryPath    string
	Elapsed        time.Duration
	Err            error
	SkippedCount   int
	SucceededCount int
}

type ApplyEvent struct {
	Address string
	Kind    NodeKind

	// Composite marks an event for a composite call site (a boundary).
	// A boundary's Kind is its own resource/data/action kind, so this
	// is what tells a boundary apart from a leaf of that kind.
	Composite bool

	Decision Decision
	Stage    ApplyStage
	Time     time.Time
	Elapsed  time.Duration
	Err      error
}

type ApplyFailure struct {
	Stage ApplyFailureStage
	Cause error
}

type ApplyFailureStage string

type ApplyStage string

type Binding = state.CanonicalBinding

type CompositePlanOperation struct {
	Decision Decision                `json:"decision"`
	Desired  *PlannedCompositeTarget `json:"desired,omitempty"`
	Prior    *CompositeStatePayload  `json:"prior,omitempty"`
}

type CompositeStatePayload = state.CompositeStatePayload

type CompositeType struct {
	Name                 string
	Kind                 NodeKind
	SyntaxBody           *syntax.FactoryBody
	AssetSetID           string
	Libraries            map[string]*Library
	LibraryBindings      map[string]string
	LibraryConfigSchemas map[string]LibraryConfigSchema
}

type ConfigurationRecord = state.ConfigurationRecord

type DAG struct {
	Nodes map[string]*Node
	Edges map[string][]string
}

type DataSourcePlanOperation struct {
	Decision        Decision                 `json:"decision"`
	Desired         *PlannedDataSourceTarget `json:"desired,omitempty"`
	Prior           *DataSourceStatePayload  `json:"prior,omitempty"`
	ObservedOutputs *EncodedValue            `json:"observed-outputs,omitempty"`
}

type DataSourceRegistration interface {
	NewReceiver() any
	Read(ctx context.Context, receiver, cfg any) (any, error)
	OutputType() reflect.Type
}

type DataSourceStatePayload = state.DataSourceStatePayload

type Decision string

type DriftRule[Out any] struct {
	// contains filtered or unexported fields
}

type EncodedValue = encodedvalue.Value

type EncodedValueKind = encodedvalue.Kind

type EntryMoveMode int

type EntryMoveResult struct {
	From EntryRef
	To   EntryRef
}

type EntryMoveSpec struct {
	From EntryRef
	To   EntryRef
}

type EntryRef = stateref.EntryRef

type EvalContext struct {
	Inputs     map[string]any
	Resources  map[string]any
	Data       map[string]any
	Actions    map[string]any
	Libraries  map[string]*Library
	Bindings   map[string]any
	Assets     *asset.Set
	AssetCache *asset.Cache

	// Each holds named iteration bindings, @each for a @for-each body
	// and declared names like @rule for a chained constraint form,
	// each a key/value record read as @name.key and @name.value.
	Each map[string]lang.EachValue

	// MissingAsNull makes path navigation yield null instead of
	// ErrEvalNotFound, or a hard error, when a key is absent or a parent
	// is itself null. The constraint checkers set it so a predicate over
	// an unset optional input, including a nested one, reduces to a
	// boolean rather than collapsing the whole expression to null or
	// failing on a null parent. Navigating into a non-null scalar is
	// still an error. It stays false everywhere else, because the planner
	// relies on ErrEvalNotFound to detect forward references to upstreams
	// that have not run yet.
	MissingAsNull bool
	// contains filtered or unexported fields
}

type ExecResult struct {
	Outputs    map[string]any
	Actions    map[string]any
	Data       map[string]any
	WrittenRev string
}

type Executor struct {
	DAG            *DAG
	Libraries      map[string]*Library
	LibraryCatalog *LibraryCatalog
	Inputs         map[string]any

	AssetCatalog   *asset.Catalog
	AssetCache     *asset.Cache
	RootAssetSetID string

	// SyntaxSource is the typed factory body for grammar-first callers.
	SyntaxSource *syntax.FactoryBody

	Store   state.Backend
	Factory state.FactoryInfo

	// PlanBackend describes the state provider recorded in a version 2 plan.
	PlanBackend *StateRefV2

	// Parallelism caps the number of in-flight resource, data-source, and
	// action steps during ApplyPlanV2. Zero or negative uses the saved
	// plan's limit, or DefaultParallelism when no limit was recorded.
	Parallelism int

	// Destroy makes PlanV2 remove recorded entries using their saved
	// bindings and configurations, without evaluating root outputs.
	Destroy bool

	// Drain, when non-nil, lets the caller ask the scheduler to stop
	// dispatching new steps without canceling the apply context. The
	// runner closes this channel on SIGINT so in-flight CRUD calls
	// finish and their state writes commit; SIGTERM cancels the
	// context directly. A nil channel disables the drain signal.
	Drain <-chan struct{}

	// Events, when non-nil, receives one ApplyEvent per step stage
	// during ApplyPlanV2: start when the scheduler hands the step to a
	// worker, done or fail when the worker returns. The caller owns
	// the channel and is responsible for sizing the buffer and
	// closing it after ApplyPlanV2 returns. A nil channel disables
	// event emission.
	Events chan<- ApplyEvent
	// contains filtered or unexported fields
}

type FactoryRef struct {
	Name            string `json:"name"`
	Version         string `json:"version"`
	ContentRevision string `json:"content-revision"`
}

type FunctionType struct {
	Name        string
	Description string
	ArgCount    int
	Variadic    bool
	Func        func(args []any) (any, error)
}

type IdentityMigrationFunc func(
	oldVersion int,
	resource ResourceMigrationState,
	priorStableID *string,
) (*string, error)

type IdentityRecord = state.IdentityRecord

type IdentityScope string

type InputDescriptor[In, Value any] struct {
	// contains filtered or unexported fields
}

type InputRule[In any] struct {
	// contains filtered or unexported fields
}

type InputSemantics[In any] struct {
	Rules []InputRule[In]
}

type Library struct {
	Name          string
	LibraryPath   string
	Description   string
	Configuration cfg.Registration
	Actions       map[string]ActionRegistration
	Resources     map[string]ResourceRegistration
	DataSources   map[string]DataSourceRegistration
	// Composites are kept in one map per kind, mirroring the
	// Resources / DataSources / Actions Go-type maps. resource,
	// data-source, and action are distinct namespaces, so a library may
	// declare resource.foo and data-source.foo as separate composites.
	ResourceComposites map[string]*CompositeType
	DataComposites     map[string]*CompositeType
	ActionComposites   map[string]*CompositeType
	Functions          map[string]FunctionType
	// Schema carries the library's resource, data source, and action
	// output field sets. Populated by the dev CLI from a fetched Go
	// library's source for compile-time reference checking; nil at
	// runtime since the generated binary does not need it.
	Schema *LibrarySchema

	// Constraints holds each Go type's cross-field constraints in the
	// embeddable spec form, keyed by "<kind>.<type>" (e.g. "resource.vpc")
	// since resource, data-source, and action are distinct namespaces. codegen
	// sets it in the generated main.go from the constraints goschema
	// derived from the library's source; the plan checks a node against
	// Constraints[node.Kind + "." + node.Type]. UB composites carry their
	// own constraints in their bodies, so this stays empty for UB libraries.
	Constraints map[string][]lang.ConstraintSpec

	// Defaults holds each Go type's declared input defaults, keyed by
	// "<kind>.<type>" like Constraints and set the same way by codegen.
	// The runtime fills a Value default into a body's inputs wherever a
	// field is left out, before constraints, triggers, and decode read
	// them; an Optional marker fills nothing.
	Defaults map[string][]lang.DefaultSpec
}

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

type LibraryConfigSchema struct {
	Path        string
	Identity    string
	Fields      []typecheck.ObjectField
	Defaults    []lang.DefaultSpec
	Constraints []lang.ConstraintSpec
	Digest      string
	Empty       bool
}

type LibraryConfigurationPlanOperation struct {
	Decision Decision             `json:"decision"`
	Inputs   EncodedValue         `json:"inputs"`
	Result   PlannedConfiguration `json:"result"`
}

type LibraryRegistration struct {
	LibraryPath string
	New         func() *Library
}

type LibrarySchema struct {
	Resources   map[string]*TypeSchema
	DataSources map[string]*TypeSchema
	Actions     map[string]*TypeSchema
	// Functions maps each function name the library exports to its
	// declared signature. The implementations live in the compiled Go
	// and cannot run at compile time, but the signature lets the
	// reference checker reject a call to an unknown function or one
	// given the wrong number of arguments, and the inferrer check each
	// argument's type and use the result type. A function registered
	// without declared types reads as all-Unknown, which counts
	// arguments but checks no types.
	Functions map[string]typecheck.FuncSig

	// Configuration describes the fields of the library's Configuration
	// struct, keyed by kebab-case field name. Nil when the library
	// declares no configuration or when the struct behind the
	// ConfigurationType's New function cannot be read from source.
	// HasConfiguration distinguishes the two: it is true whenever the
	// library declares a configuration, readable or not, so checks can
	// tell "no configuration" from "fields unknowable".
	Configuration            map[string]typecheck.Type
	ConfigurationFields      []typecheck.ObjectField
	ConfigurationDefaults    []lang.DefaultSpec
	ConfigurationConstraints []lang.ConstraintSpec
	ConfigurationIdentity    string
	ConfigurationDigest      string
	ConfigurationEmpty       bool
	HasConfiguration         bool
}

type MissingLibraryConfig struct {
	Address string
	Alias   string
}

type NoConfig struct{}

type Node struct {
	Address              string
	Kind                 NodeKind
	Alias                string
	LibraryPath          string
	Type                 string
	Name                 string
	Body                 lang.Expr
	Composite            string
	CompositeSyntaxBody  *syntax.FactoryBody
	AssetSetID           string
	Libraries            map[string]*Library
	LibraryConfigSchemas map[string]LibraryConfigSchema

	ForEach lang.Expr

	// LockName is the value of a node body's `@lock:` field. Two nodes
	// sharing a non-empty LockName cannot run in parallel under apply's
	// scheduler, even on unrelated DAG branches. Empty means the node is
	// not under a named lock. It applies to any kind; since the
	// scheduler only runs nodes in parallel at apply, a lock has no
	// effect on a data source whose inputs are known and read at plan.
	LockName string

	// Timeout is the parsed value of a node body's `@timeout:` field: a
	// limit on how long the node's apply step may run. Zero means no
	// limit. On expiry the step's context is cancelled and the step
	// fails like any other apply error. Like @lock it only bites at
	// apply, so it does not bound a data source read at plan.
	Timeout time.Duration
}

type NodeKind string

type ObservationStatus string

type OutputDescriptor[Out, Value any] struct {
	// contains filtered or unexported fields
}

type OutputPlanOperation struct {
	Decision  Decision     `json:"decision"`
	Value     EncodedValue `json:"value"`
	Sensitive bool         `json:"sensitive"`
}

type PanicError struct {
	Op      string
	Library string
	Value   any
	Stack   []byte
	Core    bool
}

type PendingValue struct {
	Refs []string
}

type PlanFileV2 struct {
	FormatVersion int                `json:"format-version"`
	Factory       FactoryRef         `json:"factory"`
	Stack         string             `json:"stack"`
	StateRevision string             `json:"state-revision"`
	GeneratedAt   time.Time          `json:"generated-at"`
	Inputs        EncodedValue       `json:"inputs"`
	Backend       *StateRefV2        `json:"backend,omitempty"`
	Parallelism   int                `json:"parallelism"`
	Mode          PlanMode           `json:"mode"`
	StateMoves    []PlannedEntryMove `json:"state-moves"`
	Steps         []PlanStepV2       `json:"steps"`
	Digest        string             `json:"digest"`
}

type PlanMode string

type PlanStepV2 struct {
	Address   string        `json:"address"`
	Kind      NodeKind      `json:"kind"`
	DependsOn []string      `json:"depends-on"`
	Operation StepOperation `json:"operation"`
}

type PlannedActionTarget struct {
	Binding              Binding              `json:"binding"`
	Inputs               EncodedValue         `json:"inputs"`
	Configuration        PlannedConfiguration `json:"configuration"`
	TriggerHash          string               `json:"trigger-hash"`
	SensitiveInputPaths  []string             `json:"sensitive-input-paths"`
	SensitiveOutputPaths []string             `json:"sensitive-output-paths"`
}

type PlannedCompositeTarget struct {
	Category             NodeKind     `json:"category"`
	Binding              Binding      `json:"binding"`
	Inputs               EncodedValue `json:"inputs"`
	SensitiveInputPaths  []string     `json:"sensitive-input-paths"`
	SensitiveOutputPaths []string     `json:"sensitive-output-paths"`
}

type PlannedConfiguration struct {
	Kind        PlannedConfigurationKind `json:"kind"`
	Record      *ConfigurationRecord     `json:"record,omitempty"`
	PendingRefs []string                 `json:"pending-refs,omitempty"`
}

type PlannedConfigurationKind string

type PlannedDataSourceTarget struct {
	Binding              Binding              `json:"binding"`
	Inputs               EncodedValue         `json:"inputs"`
	Configuration        PlannedConfiguration `json:"configuration"`
	SensitiveInputPaths  []string             `json:"sensitive-input-paths"`
	SensitiveOutputPaths []string             `json:"sensitive-output-paths"`
}

type PlannedEntryMove struct {
	From string `json:"from"`
	To   string `json:"to"`
}

type PlannedResourceTarget struct {
	Binding              Binding              `json:"binding"`
	Inputs               EncodedValue         `json:"inputs"`
	Configuration        PlannedConfiguration `json:"configuration"`
	SensitiveInputPaths  []string             `json:"sensitive-input-paths"`
	SensitiveOutputPaths []string             `json:"sensitive-output-paths"`
}

type Prior[In, Out any] struct {
	Inputs   In
	Outputs  Out
	Observed Out
}

type RefMatch struct {
	Address  string
	Segments int
}

type RefreshResult struct {
	WrittenRev string
	Refreshed  int
	Dropped    int
}

type ReplacementRule[In any] struct {
	// contains filtered or unexported fields
}

type ReplacementRules[In, Out any] struct {
	Inputs []ReplacementRule[In]
	Drift  []DriftRule[Out]
}

type ResourceDefinition[In, Out, Config any] struct {
	SchemaVersion  int
	Migrate        ResourceMigrationFunc
	Validate       ResourceValidateFunc[In, Config]
	InputSemantics InputSemantics[In]
	Identity       ResourceIdentity[In, Out]
	Replacement    ReplacementRules[In, Out]
}

type ResourceIdentity[In, Out any] struct {
	Version       int
	Scope         IdentityScope
	AddressInputs []AnyInputField[In]
	StableID      func(In, Out) (string, error)
	Migrate       IdentityMigrationFunc
}

type ResourceMigrationFunc func(
	oldVersion int,
	prior ResourceMigrationState,
) (ResourceMigrationState, error)

type ResourceMigrationState struct {
	Inputs  EncodedValue
	Outputs EncodedValue
}

type ResourceObservation struct {
	Status   ObservationStatus `json:"status"`
	Outputs  *EncodedValue     `json:"outputs,omitempty"`
	Identity *IdentityRecord   `json:"identity,omitempty"`
}

type ResourcePlanOperation struct {
	Decision    Decision               `json:"decision"`
	Desired     *PlannedResourceTarget `json:"desired,omitempty"`
	Prior       *ResourceTarget        `json:"prior,omitempty"`
	Observation *ResourceObservation   `json:"observation,omitempty"`
	Reasons     []string               `json:"reasons"`
}

type ResourceRegistration interface {
	// contains filtered or unexported methods
}

type ResourceStatePayload = state.ResourceStatePayload

type ResourceTarget = state.ResourceTarget

type ResourceValidateFunc[In, Config any] func(context.Context, In, Config) error

type SensitiveValueRecord = state.SensitiveValueRecord

type StateRef = state.Ref

type StateRefV2 struct {
	Name string       `json:"name"`
	Body EncodedValue `json:"body"`
}

type StateUnlockError struct {
	Cause error
}

type StepNode struct {
	Address     string   `json:"address"`
	Kind        NodeKind `json:"node-kind"`
	Composite   bool     `json:"composite,omitempty"`
	Decision    Decision `json:"decision"`
	DependsOn   []string `json:"depends-on,omitempty"`
	Category    string   `json:"category,omitempty"`
	ImportAlias string   `json:"import-alias,omitempty"`
	LibraryPath string   `json:"library-path,omitempty"`
	ExportKind  string   `json:"kind,omitempty"`
	Name        string   `json:"name,omitempty"`
	Parent      string   `json:"parent,omitempty"`
}

type StepOperation struct {
	Kind                 StepOperationKind                  `json:"kind"`
	Resource             *ResourcePlanOperation             `json:"resource,omitempty"`
	Action               *ActionPlanOperation               `json:"action,omitempty"`
	DataSource           *DataSourcePlanOperation           `json:"data-source,omitempty"`
	LibraryConfiguration *LibraryConfigurationPlanOperation `json:"library-configuration,omitempty"`
	Composite            *CompositePlanOperation            `json:"composite,omitempty"`
	Output               *OutputPlanOperation               `json:"output,omitempty"`
}

type StepOperationKind string

type TypeSchema struct {
	Inputs           map[string]typecheck.Type
	Outputs          map[string]typecheck.Type
	SensitiveInputs  []string
	SensitiveOutputs []string

	// Constraints holds the type's cross-field constraints, derived from
	// its Constraints method at compile time, in the embeddable string
	// form. A check parses them with lang.ParseSpecs and runs them through
	// lang.CheckConstraintEntries, the same path UB constraints take.
	Constraints []lang.ConstraintSpec

	// Defaults holds the type's declared input defaults, derived from
	// its Defaults method at compile time. A field with a Value default
	// is filled in when a body leaves it out; an Optional marker only
	// declares that absence is fine. Any other input is required.
	Defaults []lang.DefaultSpec
}

type TypedAction[Out, Config any] interface {
	Run(ctx context.Context, config Config) (Out, error)
}

type TypedDataSource[Out, Config any] interface {
	Read(ctx context.Context, config Config) (Out, error)
}

type TypedResource[In, Out, Config any] interface {
	Create(ctx context.Context, config Config) (Out, error)
	Read(ctx context.Context, config Config, prior Out) (Out, error)
	Update(ctx context.Context, config Config, prior Prior[In, Out]) (Out, error)
	Delete(ctx context.Context, config Config, prior Out) error
}