durable

type AttemptEndHookInfo struct {
	OperationHookInfo
	Attempt int
	Outcome PluginAttemptOutcome
	Error   error
}

type AttemptHookInfo struct {
	OperationHookInfo
	Attempt int
}

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

type BatchError struct {
	// Name is the batch operation's name.
	Name string

	// Reason is the completion reason of the failed batch.
	Reason CompletionReason

	// Errors contains the per-item errors, in input order.
	Errors []error
	// contains filtered or unexported fields
}

type BatchItem[O any] struct {

	// Index is the zero-based position of this item in the original input
	// slice.
	Index int

	// Name identifies the item or branch.
	Name string

	// Status is the item's terminal status.
	Status BatchItemStatus

	// Result is the item's result. It is the zero value unless Status is
	// [BatchItemSucceeded].
	Result O

	// Err is the item's error. It is nil unless Status is
	// [BatchItemFailed].
	Err error
	// contains filtered or unexported fields
}

type BatchItemProgress struct {

	// Index is the zero-based position of the item in the input slice.
	Index int

	// Name identifies the item or branch. It is empty when the item has
	// no name.
	Name string

	// Status is [BatchItemNotStarted] for an item the batch has not yet
	// admitted, [BatchItemStarted] for an item in flight, and
	// [BatchItemSucceeded] or [BatchItemFailed] once it is terminal.
	Status BatchItemStatus
	// contains filtered or unexported fields
}

type BatchItemStatus int

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

type BatchProgress struct {

	// TotalCount is the number of items in the batch, started or not.
	TotalCount int

	// CompletedCount is the number of items that have reached a terminal
	// state: SuccessCount + FailureCount.
	CompletedCount int

	// SuccessCount is the number of items that have succeeded so far.
	SuccessCount int

	// FailureCount is the number of items that have failed so far.
	FailureCount int

	// Items holds one entry per item of the batch, in input order, so
	// Items[i] is the item at input index i whatever the order in which
	// items finish. Its length is TotalCount.
	Items []BatchItemProgress
	// contains filtered or unexported fields
}

type BatchResult[O any] struct {

	// Items holds the per-item outcomes in input order. Items that started
	// but were abandoned when the batch completed early are included with
	// status [BatchItemStarted]; items that never started are omitted.
	Items []BatchItem[O]

	// Reason records why the batch completed.
	Reason CompletionReason
	// contains filtered or unexported fields
}

type Branch[O any] struct {

	// Name identifies the branch. It may be empty in [Parallel]. [Select]
	// returns it as the winner and rejects duplicate names.
	Name string

	// Func is the branch body.
	Func func(Context) (O, error)
	// contains filtered or unexported fields
}

type Callback[O any] struct {
	// contains filtered or unexported fields
}

type CallbackDetails struct {
	// CallbackId is the identifier external systems use to resolve the
	// callback. It is assigned by the backend when the callback starts.
	CallbackId *string

	// Result is the payload the external system submitted, set on success.
	Result *string

	// Error carries failure details, set on failure.
	Error *ErrorObject
}

type CallbackError struct {
	// Name is the callback operation's name.
	Name string

	// CallbackID is the identifier that was issued to the external system.
	CallbackID string

	// ErrorType is the wire ErrorType recorded for the failure: the type
	// the external system reported, or the SDK's own name for the failure
	// mode when the record carries none.
	ErrorType string

	// Message is the recorded failure message.
	Message string

	// ErrorData is the recorded ErrorData, if any.
	ErrorData string

	// StackTrace holds recorded stack trace lines, when captured.
	StackTrace []string

	// Err is the stand-in for the recorded failure.
	Err error
}

type CallbackExternalError struct {
	CallbackError
}

type CallbackOption interface {
	WaitForCallbackOption
	// contains filtered or unexported methods
}

type CallbackOptions struct {
	// TimeoutSeconds bounds how long the callback waits for an external
	// submission. Zero disables the timeout.
	TimeoutSeconds int32

	// HeartbeatTimeoutSeconds bounds the interval between heartbeats.
	// Zero disables the heartbeat timeout.
	HeartbeatTimeoutSeconds int32
}

type CallbackSubmitterError struct {
	CallbackError
}

type CallbackTimeoutError struct {
	CallbackError

	// Heartbeat is true when the heartbeat timeout elapsed, and false when
	// the overall callback timeout elapsed. It is derived from the timeout
	// message the service recorded.
	Heartbeat bool
}

type ChainedInvokeDetails struct {
	// Result is the invoked function's serialized result, set on success.
	Result *string

	// Error carries failure details, set on failure.
	Error *ErrorObject
}

type ChainedInvokeOptions struct {
	// FunctionName is the name or ARN of the function to invoke.
	FunctionName *string

	// TenantId is the tenant identifier for the chained invocation.
	TenantId *string
}

type CheckpointError struct {
	// Err is the original error from the checkpoint API call.
	Err error
	// contains filtered or unexported fields
}

type CheckpointInput struct {
	// ExecutionArn identifies the durable execution.
	ExecutionArn string

	// CheckpointToken is the caller's current checkpoint token. The
	// backend rejects stale tokens, which serializes checkpoint writers.
	CheckpointToken string

	// Updates are the operation updates to apply atomically.
	Updates []OperationUpdate
}

type CheckpointOutput struct {
	// CheckpointToken is the rotated token to use for subsequent calls.
	CheckpointToken string

	// NewExecutionState carries the updated operations from the backend,
	// including backend-assigned fields (such as callback IDs).
	NewExecutionState []Operation
}

type ChildContextError struct {
	// Name is the child context's name.
	Name string

	// ErrorType is the wire ErrorType of the error that escaped the child.
	ErrorType string

	// Message is the escaping error's recorded message.
	Message string

	// ErrorData is the payload attached with [WithErrorData], if any.
	ErrorData string

	// StackTrace holds recorded stack trace lines, when captured.
	StackTrace []string

	// Err is the stand-in for the error that escaped the child.
	Err error
}

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

type ClientError struct {
	// Scope states how far the failure reaches.
	Scope ErrorScope

	// Err is the underlying failure, kept for diagnostics.
	Err error
}

type CombinatorError struct {
	// Name is the combinator operation's name.
	Name string

	// Errors contains the individual future errors.
	Errors []error
	// contains filtered or unexported fields
}

type CompletionConfig struct {

	// MinSuccessful completes the batch early once this many items
	// succeed. Zero leaves the threshold unset.
	MinSuccessful int

	// ToleratedFailureCount fails the batch once more than this many
	// items fail. Nil leaves the threshold unset; an explicit zero fails
	// the batch on the first failure.
	ToleratedFailureCount *int

	// ToleratedFailurePercentage fails the batch once the failure
	// percentage, computed against the total item count, strictly
	// exceeds this value. Nil leaves the threshold unset; an explicit
	// zero fails the batch on the first failure. The comparison is
	// exact: with three items and a threshold of 33, one failure
	// (33.3%) exceeds the threshold.
	ToleratedFailurePercentage *int

	// ShouldComplete decides completion programmatically. It is called
	// after each item reaches a terminal state, with a [BatchProgress]
	// snapshot taken at that moment, and returns [ContinueBatch] to keep
	// going or [CompleteBatch] to complete the batch now. Completing early
	// leaves the items still in flight with status [BatchItemStarted] and
	// omits the items that never started, exactly as a threshold does.
	// The batch's [CompletionReason] is then [CompletionCustomSucceeded]
	// or [CompletionCustomFailed], by the decision's [CompletionOutcome];
	// that outcome alone decides [BatchResult.Status] and whether Map or
	// Parallel returns a [BatchError].
	//
	// The callback must be deterministic: it must depend only on its
	// argument, and it must return the same decision for the same
	// progress every time it is called. The decision it makes is
	// checkpointed with the batch, so replaying a completed batch reads
	// the recorded reason and does not call the callback again. A
	// callback that reads state outside its argument can decide
	// differently on one invocation than the checkpoint of an earlier
	// invocation recorded, and the execution then diverges from its
	// checkpoint log.
	//
	// Items can finish between two evaluations, so the batch may complete
	// with more terminal items than the snapshot that decided it showed.
	// A callback that panics, or that completes the batch with an outcome
	// that is not a defined [CompletionOutcome], fails the batch operation
	// with an error that is not a BatchError.
	ShouldComplete func(BatchProgress) CompletionDecision
	// contains filtered or unexported fields
}

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

type CompletionOutcome int

type CompletionReason int

type ConditionConfig[S any] struct {

	// InitialState is the state passed to the first check.
	InitialState S

	// WaitStrategy decides, after each check, whether to keep waiting and
	// for how long. attempt is the 1-based number of completed checks.
	// The strategy must be a deterministic function of its arguments,
	// except for randomized jitter in the returned delay.
	//
	// Build one from declarative configuration with [NewWaitStrategy] or
	// [MustNewWaitStrategy], or write a function literal. The field keeps
	// its unnamed function type so that a [WaitStrategy] value, a function
	// literal, and a caller-defined function type all assign to it.
	//
	// If nil, the strategy that WaitConfig[S]{} builds is used: keep
	// polling with exponential backoff — a 5 second initial delay
	// multiplied by 1.5 after each attempt, capped at 300 seconds, with
	// full jitter — and fail the operation once 60 attempts have been
	// made. That default has no condition predicate, so it never reports
	// the condition met; set WaitStrategy to make the wait succeed.
	WaitStrategy func(state S, attempt int) WaitDecision

	// Serdes overrides the serializer for the condition state.
	Serdes Serdes
	// contains filtered or unexported fields
}

type Context interface {
	context.Context

	// ExecutionArn returns the ARN of the current durable execution.
	ExecutionArn() string

	// RequestID returns the AWS request ID of the current Lambda
	// invocation. It is empty outside a Lambda invocation (such as under
	// the [durabletest] local runner).
	//
	// The request ID varies across invocations of one execution, so using
	// it in handler logic outside a [Step] introduces non-determinism on
	// replay. If the raw aws-lambda-go invocation context is genuinely
	// needed, it remains reachable from the embedded [context.Context] via
	// lambdacontext.FromContext(ctx).
	RequestID() string

	// InvokedFunctionARN returns the ARN used to invoke the current
	// Lambda function. It is empty outside a Lambda invocation (such as
	// under the [durabletest] local runner).
	InvokedFunctionARN() string

	// Logger returns the logger for this context. Its records carry the
	// request ID and execution ARN as structured attributes, and the
	// tenant ID when the invocation has one, whichever [slog.Handler] is
	// installed with [WithLogHandler] or [ConfigureLogging]. Inside a child
	// context (from [RunInChildContext], [Go], [Map], [Parallel], or
	// [WaitForCallback]) the records also carry the child operation's ID
	// as operationId and its name as operationName. While this context is
	// replaying, log output is suppressed so that replayed code does not
	// duplicate log lines, unless [ReplayLogModeEmit] is in effect, in
	// which case replayed records are emitted with the attribute
	// replay=true. Suppression is decided per branch: each context (root,
	// child context, and each concurrent branch from [Go], [Map], or
	// [Parallel]) consults its own replay state, so a branch that is still
	// replaying stays suppressed even after a sibling branch has reached
	// live execution.
	Logger() *slog.Logger

	// IsReplaying reports whether the execution is currently replaying
	// previously checkpointed operations.
	IsReplaying() bool
	// contains filtered or unexported methods
}

type ContextDetails struct {
	// Result is the child context's serialized result, set on success.
	Result *string

	// ReplayChildren reports whether the completed context's child
	// operations are included in replay state.
	ReplayChildren *bool

	// Error carries failure details, set on failure.
	Error *ErrorObject
}

type ContextOptions struct {
	// ReplayChildren requests that the completed context's child
	// operations be included in replay state.
	ReplayChildren *bool
}

type Deserializer interface {
	Unmarshal(data []byte, v any) error
}

type ErrorMatcher func(err error) bool

type ErrorObject struct {
	// ErrorType is the error's type name.
	ErrorType *string

	// ErrorMessage is the human-readable error message.
	ErrorMessage *string

	// ErrorData is machine-readable error data.
	ErrorData *string

	// StackTrace is optional stack trace information.
	StackTrace []string
}

type ErrorScope string

type ExecutionClient interface {
	// GetExecutionState returns one page of the execution's checkpointed
	// operation log. Set [GetExecutionStateInput.Marker] from a previous
	// page's NextMarker to continue pagination.
	GetExecutionState(ctx context.Context, in GetExecutionStateInput) (GetExecutionStateOutput, error)

	// Checkpoint atomically applies operation updates and rotates the
	// checkpoint token. The returned state carries the updated operations,
	// including any backend-assigned fields (such as callback IDs).
	Checkpoint(ctx context.Context, in CheckpointInput) (CheckpointOutput, error)
}

type ExecutionDetails struct {
	// InputPayload is the original input to the durable execution.
	InputPayload *string
}

type FieldMatchMode int

type FileSystemPathEncoding int

type FileSystemSerdesConfig struct {

	// Mode controls when data is written to the filesystem. Default is
	// FileSystemSerdesModeAlways.
	Mode FileSystemSerdesMode

	// PathEncoding controls the directory and file names of offloaded
	// values. Default is FileSystemPathEncodingURI, the readable layout.
	//
	// The checkpoint envelope stores the full path of each file, so a
	// value is read back correctly whatever layout was in effect when it
	// was written. Changing this setting affects only where new files are
	// written.
	PathEncoding FileSystemPathEncoding

	// GeneratePreview, when set, is called with each value that is written
	// to a file, and its non-nil result is stored in the checkpoint
	// envelope next to the file reference as the "preview" member. The
	// operation log then shows the preview without reading the file. It is
	// not called for a value stored inline in
	// [FileSystemSerdesModeOverflow], since that value is already visible.
	//
	// Use [BuildPreview] with a [PreviewConfig] to select and mask fields:
	//
	//	GeneratePreview: func(v any) map[string]any {
	//		return durable.BuildPreview(v, durable.PreviewConfig{
	//			Mode:    durable.PreviewExcludeAll,
	//			Include: []durable.PreviewField{{Name: "id"}},
	//			Mask:    []durable.PreviewField{{Name: "email"}},
	//		})
	//	}
	//
	// The preview is advisory metadata. Masking a field in the preview does
	// not redact it from the file, which holds the value in full. An
	// envelope written without a preview reads back unchanged, so this
	// setting can be added to or removed from a deployed function without
	// affecting executions that are already running.
	GeneratePreview func(value any) map[string]any
	// contains filtered or unexported fields
}

type FileSystemSerdesMode int

type Future[O any] struct {
	// contains filtered or unexported fields
}

type GetExecutionStateInput struct {
	// ExecutionArn identifies the durable execution.
	ExecutionArn string

	// CheckpointToken is the caller's current checkpoint token.
	CheckpointToken string

	// Marker continues pagination from a previous page's NextMarker.
	// Empty requests the first page.
	Marker string
}

type GetExecutionStateOutput struct {
	// Operations are the checkpointed operations on this page.
	Operations []Operation

	// NextMarker is non-empty when more pages remain. Pass it as the next
	// request's Marker.
	NextMarker string
}

type Handler[I, O any] func(ctx Context, event I) (O, error)

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

type InvocationEndHookInfo struct {
	ExecutionArn string
	Status       PluginInvocationStatus

	// ExecutionResult is the handler's return value when the invocation
	// succeeded. Nil on failure or suspension.
	ExecutionResult any

	// ExecutionError is the error that caused invocation failure. Nil on
	// success or suspension.
	ExecutionError error
}

type InvocationHookInfo struct {
	ExecutionArn      string
	IsFirstInvocation bool

	// ExecutionInput is the deserialized customer event for the execution.
	// It is the raw unmarshaled value (typically a map or struct).
	ExecutionInput any

	// ExecutionStartTimestamp is the time the execution was first created,
	// sourced from the execution operation's StartTimestamp in the wire
	// payload. Zero when unavailable (e.g. payload lacks timestamp data).
	ExecutionStartTimestamp time.Time

	// UpdatedOperations contains operations whose status changed
	// externally between invocations, keyed by operation ID. This
	// embeds the same data as OnOperationChange to allow plugins that
	// need both to avoid state ordering dependencies. It is a subset of
	// Operations.
	UpdatedOperations map[string]OperationHookInfo

	// Operations contains every operation known at the start of the
	// invocation, keyed by operation ID, including the root execution
	// operation and operations that did not change since the previous
	// invocation. UpdatedOperations is a subset of it. On the first
	// invocation it holds the execution operation alone. Each entry
	// carries the checkpointed status, timestamps, result, and error, with
	// IsReplay set, as an OnOperationEnd hook would report the operation.
	//
	// The map is built before the invocation hooks run and is not
	// modified afterwards, so a plugin may read it at any time. It is nil
	// when no registered plugin implements OnInvocationStart or
	// WrapInvocation, the hooks that receive it.
	Operations map[string]OperationHookInfo
}

type InvokeError struct {
	// Name is the invoke operation's name.
	Name string

	// FunctionID is the function name or ARN that was invoked.
	FunctionID string

	// Status is the terminal operation status that caused the failure
	// (Failed, TimedOut, Stopped, or Cancelled). It enables callers to
	// distinguish the reason for failure without sentinel error matching.
	Status OperationStatus

	// ErrorType is the wire ErrorType the invoked function recorded.
	ErrorType string

	// Message is the invoked function's recorded error message.
	Message string

	// ErrorData is the invoked function's recorded ErrorData, if any.
	ErrorData string

	// StackTrace holds recorded stack trace lines, when captured.
	StackTrace []string

	// Err is the stand-in for the invoked function's failure.
	Err error
}

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

type JitterStrategy string

type LinearRetryConfig struct {

	// MaxAttempts is the maximum number of total attempts, including the
	// first. The default is 6. It must not be negative.
	MaxAttempts int

	// InitialDelay is the delay before the first retry. The default is
	// 1 second. When set, it must be at least 1 second.
	InitialDelay time.Duration

	// Increment is added to the delay before each retry after the first.
	// The default is 1 second. It must not be negative. For a fixed
	// interval between attempts, use [NewRetryStrategy] with a
	// BackoffRate of 1 instead.
	Increment time.Duration

	// MaxDelay caps the delay between retries. The default is 5 minutes.
	// When set, it must be at least 1 second.
	MaxDelay time.Duration

	// Jitter is the jitter strategy applied to computed delays. The
	// default is [JitterNone], so the default sequence is exact. When
	// set, it must be one of the defined [JitterStrategy] constants.
	Jitter JitterStrategy

	// RetryableErrors restricts retries to errors that at least one
	// matcher reports as retryable. When empty, every error is retryable.
	// Entries must not be nil. See [RetryConfig.RetryableErrors].
	RetryableErrors []ErrorMatcher
	// contains filtered or unexported fields
}

type LogConfig struct {

	// Handler replaces the [slog.Handler] behind [Context.Logger] and
	// [StepContext.Logger]. It has the same role as [WithLogHandler]. The
	// SDK attaches the execution attributes (requestId, executionArn, and
	// tenantId when present) and each scope's operation attributes to the
	// new handler through its WithAttrs method, wraps it with replay
	// suppression, and adds the fields plugins return from
	// [Plugin.EnrichLogContext], exactly as it does for the handler given
	// at construction. nil keeps the current handler.
	Handler slog.Handler

	// ReplayLogMode replaces the treatment of records emitted during
	// replay. It has the same role as [WithReplayLogMode].
	// [ReplayLogModeUnchanged], the zero value, keeps the current mode.
	ReplayLogMode ReplayLogMode
	// contains filtered or unexported fields
}

type NestingMode int

type NonDeterministicReplayError struct {
	// Name is the operation name the current code passed.
	Name string

	// StepID is the positional ID where the mismatch was detected.
	StepID string

	// ExpectedType is the operation type the current code expects.
	ExpectedType string

	// ExpectedSubType is the sub-type the current code expects (may be
	// empty for operations that don't distinguish by sub-type).
	ExpectedSubType string

	// ExpectedName is the operation name the current code expects (may be
	// empty for unnamed operations).
	ExpectedName string

	// ActualType is the checkpointed operation's type.
	ActualType string

	// ActualSubType is the checkpointed operation's sub-type.
	ActualSubType string

	// ActualName is the checkpointed operation's name.
	ActualName string
	// contains filtered or unexported fields
}

type Operation struct {
	// Id is the operation's unique identifier.
	Id *string

	// Status is the operation's current status.
	Status OperationStatus

	// Type is the operation's kind.
	Type OperationType

	// SubType further qualifies the operation's kind.
	SubType *string

	// Name is the caller-supplied operation name.
	Name *string

	// ParentId identifies the parent operation for operations inside a
	// child context.
	ParentId *string

	// StartTimestamp is when the operation started.
	StartTimestamp *time.Time

	// EndTimestamp is when the operation reached a terminal status.
	EndTimestamp *time.Time

	// ExecutionDetails is set for EXECUTION operations.
	ExecutionDetails *ExecutionDetails

	// StepDetails is set for STEP operations.
	StepDetails *StepDetails

	// WaitDetails is set for WAIT operations.
	WaitDetails *WaitDetails

	// CallbackDetails is set for CALLBACK operations.
	CallbackDetails *CallbackDetails

	// ChainedInvokeDetails is set for CHAINED_INVOKE operations.
	ChainedInvokeDetails *ChainedInvokeDetails

	// ContextDetails is set for CONTEXT operations.
	ContextDetails *ContextDetails
}

type OperationAction string

type OperationChangeHookInfo struct {
	ExecutionArn      string
	UpdatedOperations map[string]OperationHookInfo
}

type OperationError struct {
	// Name is the operation's name as passed by the caller.
	Name string

	// ErrorType is the wire ErrorType of the escaping error, for example
	// "PaymentDeclinedError". It is empty for errors that record no cause.
	ErrorType string

	// Message is the escaping error's recorded message.
	Message string

	// ErrorData is the optional structured payload attached with
	// [WithErrorData]. It round-trips through checkpoints unchanged.
	ErrorData string

	// StackTrace holds the stack trace lines recorded for the failure, when
	// the recorder captured one. It is nil otherwise.
	StackTrace []string

	// Err is the stand-in for the recorded failure, built from ErrorType
	// and Message. It is the same value on the first invocation and on
	// replay. It is nil for errors that record no cause.
	Err error
}

type OperationHookInfo struct {
	ExecutionArn string
	ID           string
	Name         string
	Type         string
	SubType      string
	Status       PluginOperationStatus
	Attempt      int
	IsReplay     bool

	// ParentID is the ID of the parent context operation, if any. Empty
	// for top-level (root context) operations. A consumer that builds the
	// operation tree follows it.
	//
	// Every reported operation's parent is itself reported, so a consumer
	// can follow ParentID from any reported operation up to the root. Under
	// [WithPluginChildOperationsDepth] the operations nested inside an
	// operation at the configured depth are not reported; that operation
	// carries ChildrenOmitted so the consumer can tell the subtree was
	// truncated rather than absent.
	ParentID string

	// ChildrenOmitted reports that the operations nested inside this one
	// are omitted from plugin notifications: the operation lies at the
	// depth set by [WithPluginChildOperationsDepth], so no hook fires for
	// anything it contains, and no reported operation names it as
	// ParentID. False when no depth is set or the operation lies above it.
	// A consumer that finds no children for an operation with this field
	// set must treat the subtree as unreported, not as empty.
	ChildrenOmitted bool

	// StartTimestamp is when this operation began. Set on OnOperationStart
	// and OnOperationEnd; zero on hooks where not yet known.
	StartTimestamp time.Time

	// EndTimestamp is when this operation reached a terminal state. Set on
	// OnOperationEnd; zero on OnOperationStart.
	EndTimestamp time.Time

	// Result is the operation's serialized result (raw wire form), if any.
	// Set on OnOperationEnd for succeeded operations; empty otherwise.
	Result string

	// Error is the error the operation failed with, if any. Set on
	// OnOperationEnd for failed operations; nil otherwise.
	Error error
}

type OperationStatus string

type OperationType string

type OperationUpdate struct {
	// Id is the operation's unique identifier.
	Id *string

	// Type is the operation's kind.
	Type OperationType

	// Action is the state transition to apply.
	Action OperationAction

	// SubType further qualifies the operation's kind.
	SubType *string

	// Name is the caller-supplied operation name.
	Name *string

	// ParentId identifies the parent operation for operations inside a
	// child context.
	ParentId *string

	// Payload is the operation result for SUCCEED actions.
	Payload *string

	// Error carries failure details for FAIL and RETRY actions.
	Error *ErrorObject

	// StepOptions configures STEP operations.
	StepOptions *StepOptions

	// WaitOptions configures WAIT operations.
	WaitOptions *WaitOptions

	// CallbackOptions configures CALLBACK operations.
	CallbackOptions *CallbackOptions

	// ChainedInvokeOptions configures CHAINED_INVOKE operations.
	ChainedInvokeOptions *ChainedInvokeOptions

	// ContextOptions configures CONTEXT operations.
	ContextOptions *ContextOptions
}

type Plugin struct {
	// OnInvocationStart is called once at the start of each Lambda
	// invocation of the execution, before the user handler runs. It is
	// the first hook of the invocation: it fires before OnOperationChange
	// and before WrapInvocation. It fires on the first invocation and on
	// every later one; IsFirstInvocation on the info tells them apart.
	// The info's Operations map is a snapshot of every checkpointed
	// operation as the invocation begins. It is dispatched from the
	// goroutine that received the invocation, in the sense the Dispatch
	// section of [Plugin] defines: on that goroutine with one plugin
	// registered, on a goroutine the dispatch joins with several. It
	// never overlaps another invocation-level hook of the same plugin.
	OnInvocationStart func(ctx context.Context, info InvocationHookInfo)

	// OnInvocationEnd is called once when the invocation ends, with the
	// invocation's status: Succeeded or Failed when the execution has
	// finished, Pending when the invocation suspended on an operation that
	// completes later, and Retrying when the invocation returned an error
	// to Lambda and the service will invoke the execution again. See the
	// [PluginInvocationStatus] constants. It is the last hook of the
	// invocation: WrapInvocation and the hooks of every operation the
	// handler awaited have returned before it fires. On Succeeded it
	// fires only after the result has been recorded, so a plugin never
	// reports a success the execution has not committed. It fires on
	// every invocation, whether the handler completed, suspended, or
	// failed. It is dispatched from the goroutine that received the
	// invocation: on that goroutine with one plugin registered, on a
	// goroutine the dispatch joins with several.
	OnInvocationEnd func(ctx context.Context, info InvocationEndHookInfo)

	// OnOperationStart is called when a durable operation begins in this
	// invocation, before the operation's body, attempt hooks, and wrap
	// hooks, and before any hook of an operation nested inside it. Each
	// operation dispatches at most one start per invocation. An
	// operation that runs live reports [PluginOperationStarted] with
	// IsReplay false. An operation that is re-entered before it settled
	// reports its checkpointed status with IsReplay true. A [Step]
	// replayed from a terminal checkpoint reports that status with
	// IsReplay true and then dispatches OnOperationEnd with no hook in
	// between. For a succeeded Step the SDK decodes the checkpointed
	// result between the two; if decoding fails, the Step returns the
	// decoding error to its caller and dispatches no end. Every other
	// operation replayed from a terminal checkpoint dispatches only the
	// end, because its start was dispatched by the invocation that
	// recorded it. A Step whose retry is scheduled and not yet due
	// dispatches no hook until the attempt runs. Each operation's own
	// documentation states any further detail of its replayed events. It
	// is dispatched from the goroutine that runs the operation: on that
	// goroutine with one plugin registered, on a goroutine the dispatch
	// joins with several. Starts of concurrent operations may run in
	// parallel.
	OnOperationStart func(ctx context.Context, info OperationHookInfo)

	// OnOperationEnd is called when a durable operation reaches a
	// terminal status: Succeeded, Failed, TimedOut, Stopped, or
	// Cancelled. Each operation dispatches at most one end per
	// invocation, after OnOperationAttemptEnd of its final attempt and,
	// for a context operation, after its body has returned. A live operation
	// dispatches its end after its terminal checkpoint is recorded, with
	// IsReplay false. An operation that suspends the invocation has no
	// outcome yet and dispatches no end; the later invocation that
	// observes its terminal checkpoint dispatches the end with IsReplay
	// true and the checkpointed timestamps, result, and error. An
	// operation replayed from a terminal checkpoint dispatches the end
	// with IsReplay true on every invocation that replays it, with one
	// exception: a succeeded [Step] whose checkpointed result fails to
	// decode dispatches no end on that invocation (see OnOperationStart).
	// It is dispatched from the goroutine that runs the operation: on
	// that goroutine with one plugin registered, on a goroutine the
	// dispatch joins with several.
	OnOperationEnd func(ctx context.Context, info OperationHookInfo)

	// OnOperationAttemptStart is called before each attempt of a
	// retryable operation runs its body: a [Step] body or a
	// [WaitForCondition] check. It fires after OnOperationStart of the
	// operation and before WrapOperationAttemptFn. Attempts are numbered
	// from 1 and the numbering continues across invocations. Only a live
	// attempt fires it: an attempt whose outcome is checkpointed is not
	// run again, so a replayed operation dispatches no attempt hooks. It
	// is dispatched from the goroutine that runs the operation: on that
	// goroutine with one plugin registered, on a goroutine the dispatch
	// joins with several.
	OnOperationAttemptStart func(ctx context.Context, info AttemptHookInfo)

	// OnOperationAttemptEnd is called after each attempt of a retryable
	// operation has an outcome. With [PluginAttemptSucceeded] it fires
	// after the attempt's result is checkpointed and before
	// OnOperationEnd. With [PluginAttemptFailed] it fires when the body
	// returns an error, or when the result cannot be serialized or is
	// too large, before the retry decision: a retry that follows suspends
	// the invocation and the next attempt fires OnOperationAttemptStart
	// in a later invocation; a final failure fires OnOperationEnd. Like
	// OnOperationAttemptStart it fires only for live attempts. It is
	// dispatched from the goroutine that runs the operation: on that
	// goroutine with one plugin registered, on a goroutine the dispatch
	// joins with several.
	OnOperationAttemptEnd func(ctx context.Context, info AttemptEndHookInfo)

	// OnOperationChange is called at most once per invocation, after
	// OnInvocationStart and before WrapInvocation, when at least one
	// operation changed status externally between the previous invocation
	// and this one: a wait that elapsed, a callback that was resolved, a
	// chained invoke that finished. It does not fire on an invocation
	// with no such change, including the first. The info's
	// UpdatedOperations is the same map [InvocationHookInfo] carries
	// under that name; every entry has IsReplay set. It is dispatched
	// from the goroutine that received the invocation: on that goroutine
	// with one plugin registered, on a goroutine the dispatch joins with
	// several.
	OnOperationChange func(ctx context.Context, info OperationChangeHookInfo)

	// WrapInvocation wraps the user handler invocation. It fires once per
	// invocation, after OnInvocationStart and OnOperationChange and
	// before every operation-level hook; OnInvocationEnd fires after it
	// returns. The outer plugin (index 0) wraps first. fn must be called
	// exactly once; the context passed to fn is the parent of the
	// handler's [Context]. fn returns the handler's result and error,
	// which the hook must return unchanged; see the wrap-hook contract in
	// the [Plugin] documentation. It runs on the goroutine that received
	// the invocation however many plugins are registered.
	WrapInvocation func(ctx context.Context, info InvocationHookInfo, fn func(ctx context.Context) (any, error)) (any, error)

	// WrapOperationAttemptFn wraps the execution of an operation attempt
	// body: a [Step] body or a [WaitForCondition] check. It fires for
	// each live attempt, after OnOperationAttemptStart and before
	// OnOperationAttemptEnd, and never for a replayed operation. fn must
	// be called exactly once; the context passed to fn is the parent of
	// the body's [StepContext]. See the wrap-hook contract in the
	// [Plugin] documentation. It runs on the goroutine that runs the
	// operation however many plugins are registered; hooks of concurrent
	// operations may run in parallel.
	WrapOperationAttemptFn func(ctx context.Context, info AttemptHookInfo, fn func(ctx context.Context) (any, error)) (any, error)

	// WrapChildContextFn wraps the execution of a child-context function:
	// the body passed to [RunInChildContext], [RunInChildContextAsync],
	// or [Go], including a child under [WithChildVirtual]. It fires after
	// OnOperationStart of the child and before its OnOperationEnd, with
	// IsReplay false for a live child and IsReplay true for a child
	// re-entered before it settled or a virtual child replaying the
	// operations inside it. A child replayed from a terminal checkpoint
	// dispatches only its end and, in general, does not run its body, so
	// the hook does not fire. One such child does run its body: a
	// succeeded child whose result was too large to checkpoint runs its
	// body again to rebuild the result. That run is not wrapped, so the
	// hook does not fire for it either; its OnOperationEnd, with the
	// checkpointed timestamps, is dispatched before the body runs. [Map]
	// and [Parallel] items and [WaitForCallback] are context operations
	// too but do not fire it. fn must be called exactly once; the
	// context passed to fn is the parent of the child [Context]. See the
	// wrap-hook contract in the [Plugin] documentation. It runs on the
	// goroutine that runs the child body however many plugins are
	// registered.
	WrapChildContextFn func(ctx context.Context, info OperationHookInfo, fn func(ctx context.Context) (any, error)) (any, error)

	// EnrichLogContext returns additional key-value pairs to merge into
	// every log record emitted through [Context.Logger] and
	// [StepContext.Logger]. It is called once per record that the
	// logger emits, after replay suppression has been decided. Under
	// [ReplayLogModeSuppress], the default, a record written while the
	// context replays is dropped and the hook is not called for it. Under
	// [ReplayLogModeEmit] such a record is emitted with the attribute
	// replay=true, and the hook is called for it as for a live record.
	// ctx is the record's context: the one passed to a *Context logging
	// method such as [slog.Logger.InfoContext], else context.Background().
	// It runs on the goroutine that logs however many plugins are
	// registered, so it may run concurrently with itself and with every
	// other hook.
	//
	// Each returned entry becomes an attribute of the record unless its
	// key is already taken. Precedence, highest first: the SDK's own
	// fields (timestamp, level, message, requestId, executionArn,
	// tenantId, operationId, operationName, attempt, replay), then attributes the
	// user supplied with the record or through [slog.Logger.With], then
	// plugin fields. A plugin field under a taken key is dropped, so a
	// plugin cannot overwrite the SDK's identifiers. Keys are compared by
	// qualified path: a plugin field lands under the groups the logger has
	// opened with [slog.Logger.WithGroup], and collides only with an
	// attribute at that same path, with the children of an empty-key group
	// counting at the enclosing path. The SDK's own fields are top-level,
	// so under an open group a plugin field may use their names. A group
	// the logger opens after an attribute was attached at that same path
	// is also taken: the plugin fields would form a second object under
	// that key beside the attached one, so none are added to records
	// logged through that logger. When several plugins implement the
	// hook, their maps are merged in registration order and a later
	// plugin's value replaces an earlier one's under the same key. Fields
	// are added in key order. A hook that panics contributes no fields
	// and does not fail the log call or the invocation. When no plugin
	// implements the hook, no per-record work is done.
	EnrichLogContext func(ctx context.Context) map[string]any
}

type PluginAttemptOutcome string

type PluginInvocationStatus string

type PluginOperationStatus string

type PreviewConfig struct {

	// Mode is the base visibility. The zero value is [PreviewIncludeAll].
	Mode PreviewMode

	// Include lists fields shown under [PreviewExcludeAll]. It has no
	// effect under [PreviewIncludeAll], where every field is already
	// visible.
	Include []PreviewField

	// Exclude lists fields that are never shown. Exclude wins over
	// Include and over Mask, and nothing below an excluded field is
	// traversed.
	Exclude []PreviewField

	// Mask lists fields shown with their value replaced by MaskString. A
	// masked field is visible under either mode unless it is also
	// excluded. When the masked field holds an object or a slice, the whole
	// value is replaced by MaskString.
	Mask []PreviewField

	// MaskString replaces the value of masked fields. Empty means
	// [DefaultPreviewMaskString].
	MaskString string

	// MaxPreviewBytes caps the JSON size of the returned preview. Fields
	// are added in traversal order until the next one would exceed the
	// cap. Zero or negative means [DefaultPreviewMaxBytes].
	MaxPreviewBytes int

	// MaxDepth bounds how many nested objects and slices are traversed. The
	// root value is level 0, so with MaxDepth 1 a top-level field holding an
	// object or slice is omitted while scalar top-level fields are kept. A
	// masked field beyond the limit is still shown as MaskString. Zero or
	// negative means [DefaultPreviewMaxDepth].
	MaxDepth int
	// contains filtered or unexported fields
}

type PreviewField struct {

	// Name is the field name, or the dot-separated path from the root when
	// Match is [FieldMatchPath].
	Name string

	// Match is how Name is compared with a field's path. The zero value is
	// [FieldMatchAnywhere].
	Match FieldMatchMode
	// contains filtered or unexported fields
}

type PreviewMode int

type ReplayLogMode int

type ResultTooLargeError struct {
	// Name is the operation's name.
	Name string

	// SizeBytes is the serialized result's size.
	SizeBytes int

	// LimitBytes is the threshold that was exceeded.
	LimitBytes int
	// contains filtered or unexported fields
}

type RetryAttempt struct {

	// Err is the error from the attempt that just failed.
	Err error

	// Attempt is the 1-based number of the attempt that just failed,
	// inclusive of the first attempt.
	Attempt int

	// Elapsed is the time since the first attempt began. It is zero when
	// the SDK does not track it.
	Elapsed time.Duration
	// contains filtered or unexported fields
}

type RetryConfig struct {

	// MaxAttempts is the maximum number of total attempts, including the
	// first. The default is 3. It must not be negative.
	MaxAttempts int

	// InitialDelay is the delay before the first retry. The default is
	// 5 seconds. When set, it must be at least 1 second.
	InitialDelay time.Duration

	// MaxDelay caps the delay between retries. The default is 5 minutes.
	// When set, it must be at least 1 second.
	MaxDelay time.Duration

	// BackoffRate multiplies the delay after each attempt. The default
	// is 2. It must be a finite value and must not be negative.
	BackoffRate float64

	// Jitter is the jitter strategy applied to computed delays. The
	// default is [JitterFull]. When set, it must be one of the defined
	// [JitterStrategy] constants.
	Jitter JitterStrategy

	// RetryableErrors restricts retries to errors that at least one
	// matcher reports as retryable. When empty, every error is retryable.
	// A non-matching error is not retried: the step fails on that attempt
	// with the attempts made so far. Entries must not be nil.
	//
	// Build matchers with [ErrorIs] for sentinel errors, [ErrorAs] for
	// error types, and [ErrorContains] or [ErrorMatches] for message
	// patterns:
	//
	//	durable.RetryConfig{
	//		RetryableErrors: []durable.ErrorMatcher{
	//			durable.ErrorAs[*TransientError](),
	//			durable.ErrorIs(io.ErrUnexpectedEOF),
	//			durable.ErrorContains("throttl"),
	//		},
	//	}
	//
	// RetryableErrors applies to the strategy [NewRetryStrategy] builds
	// from this config. A hand-written [RetryStrategy] is not filtered; it
	// sees every failed attempt. To combine the two, have the hand-written
	// strategy delegate to the configured one, which then applies the
	// matchers, or apply an [ErrorMatcher] directly to [RetryAttempt.Err].
	RetryableErrors []ErrorMatcher
	// contains filtered or unexported fields
}

type RetryDecision struct {

	// Retry indicates whether the operation should be attempted again.
	Retry bool

	// Delay is how long to wait before the next attempt. It is ignored
	// when Retry is false.
	//
	// The SDK sends the delay as a whole number of seconds, rounding a
	// fractional delay up. A zero Delay selects [DefaultRetryDelay], so a
	// strategy that returns RetryDecision{Retry: true} without setting
	// Delay waits one second. A negative Delay is an error that fails the
	// step.
	Delay time.Duration
	// contains filtered or unexported fields
}

type RetryError struct {
	// Name is the retry group's name, or the empty string for an unnamed
	// group.
	Name string

	// Attempts is the number of times fn ran.
	Attempts int

	// ErrorType is the wire ErrorType of the final attempt's error.
	ErrorType string

	// Message is the final attempt's recorded error message.
	Message string

	// ErrorData is the payload attached with [WithErrorData], if any.
	ErrorData string

	// StackTrace holds recorded stack trace lines, when captured.
	StackTrace []string

	// Err is the final attempt's error.
	Err error
}

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

type RetryStrategy func(RetryAttempt) RetryDecision

type Serdes interface {
	Marshal(ctx context.Context, meta SerdesContext, v any) ([]byte, error)
	Unmarshal(ctx context.Context, meta SerdesContext, data []byte, v any) error
}

type SerdesConfig struct {

	// Serdes replaces the default serializer for operation results: steps,
	// child contexts, invokes, and condition state. It has the same role as
	// [WithSerdes].
	Serdes Serdes

	// CallbackDeserializer replaces the default deserializer for callback
	// payloads submitted by external systems. It has the same role as
	// [WithCallbackDeserializer]. Once set it cannot be cleared: to return
	// callbacks to the standard serdes, set Serdes and pass a
	// CallbackDeserializer that delegates to it.
	CallbackDeserializer Deserializer
	// contains filtered or unexported fields
}

type SerdesContext struct {

	// OperationID is the positional ID of the operation being serialized
	// (e.g., "1", "1-2-3").
	OperationID string

	// DurableExecutionArn is the ARN of the current durable execution.
	DurableExecutionArn string
	// contains filtered or unexported fields
}

type SerdesError struct {
	// Operation is the name of the durable operation whose serdes failed.
	Operation string

	// Direction is "marshal" or "unmarshal", indicating whether
	// serialization or deserialization failed.
	Direction string

	// Err is the underlying serdes failure.
	Err error
}

type Settled[O any] struct {

	// Value is the future's result. It is the zero value when Err is
	// non-nil.
	Value O

	// Err is the future's error, or nil if the future succeeded.
	//
	// After a checkpoint round trip (AllSettled runs in a child context),
	// Err is rebuilt from the serialized outcome: an SDK error type is
	// rebuilt as that type with its [OperationError] fields, so
	// [errors.As] matches it and a timed-out callback still matches
	// [ErrCallbackTimedOut]; any other error is a stand-in whose Error()
	// is "<ErrorType>: <message>". Fields outside [OperationError], such
	// as [StepError.Attempts], are zero after the round trip.
	Err error
	// contains filtered or unexported fields
}

type StepContext interface {
	context.Context

	// Logger returns the logger for the current step body, condition
	// check, or callback submitter. Its records carry the execution
	// attributes of the enclosing context, this operation's ID as
	// operationId, its name as operationName when it has one, and the
	// attempt number. The enclosing context's own operation attributes are
	// replaced, not repeated: a step inside a child context reports the
	// step, not the child.
	Logger() *slog.Logger

	// Attempt returns the 1-based attempt number of the current
	// execution of the user function. The first attempt is 1. It applies
	// to step bodies, to condition checks (where it is the poll attempt
	// number, the same value the wait strategy receives), and to callback
	// submitters (where it is the submitter's retry attempt).
	Attempt() int
	// contains filtered or unexported methods
}

type StepDetails struct {
	// Attempt is the current attempt number.
	Attempt int32

	// Result is the serialized step result, set on success.
	Result *string

	// Error carries failure details, set on failure or pending retry.
	Error *ErrorObject

	// NextAttemptTimestamp is when the next retry attempt is scheduled.
	// Set only while the step is pending.
	NextAttemptTimestamp *time.Time
}

type StepError struct {
	// Name is the step's name, or the empty string for unnamed steps.
	Name string

	// Attempts is the number of times the step body executed.
	Attempts int

	// ErrorType is the wire ErrorType of the final attempt's error.
	ErrorType string

	// Message is the final attempt's recorded error message.
	Message string

	// ErrorData is the payload attached with [WithErrorData], if any.
	ErrorData string

	// StackTrace holds recorded stack trace lines, when captured.
	StackTrace []string

	// Err is the stand-in for the final attempt's error.
	Err error
}

type StepInterruptedError struct {
	// Name is the step's name, or the empty string for unnamed steps.
	Name string
	// contains filtered or unexported fields
}

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

type StepOptions struct {
	// NextAttemptDelaySeconds is the delay before the next retry attempt.
	NextAttemptDelaySeconds *int32
}

type StepSemantics int

type Void struct{}

type WaitConfig[S any] struct {

	// MaxAttempts is the maximum number of checks, including the first.
	// Reaching it with the condition still unmet fails the operation with
	// a [*WaitForConditionError]. The default is 60. It must not be
	// negative.
	MaxAttempts int

	// InitialDelay is the delay before the second check. The default is
	// 5 seconds. When set, it must be at least 1 second.
	InitialDelay time.Duration

	// MaxDelay caps the delay between checks. The default is 5 minutes.
	// When set, it must be at least 1 second.
	MaxDelay time.Duration

	// BackoffRate multiplies the delay after each check. The default is
	// 1.5. It must be a finite value and must not be negative.
	BackoffRate float64

	// Jitter is the jitter strategy applied to computed delays. The
	// default is [JitterFull]. When set, it must be one of the defined
	// [JitterStrategy] constants.
	Jitter JitterStrategy

	// ShouldContinue reports whether to keep polling given the state the
	// latest check returned. When it returns false the condition is met:
	// the operation succeeds with that state, even on the final attempt.
	//
	// When nil, every check continues polling, so the operation can only
	// end by reaching MaxAttempts. Set it to make the wait succeed.
	ShouldContinue func(state S) bool
	// contains filtered or unexported fields
}

type WaitDecision struct {

	// Continue indicates whether to keep waiting and check again.
	Continue bool

	// Delay is how long to suspend before the next check. It is ignored
	// when Continue is false.
	Delay time.Duration

	// Err, when non-nil and Continue is false, signals that the
	// operation should fail with this error rather than succeed. Use it
	// to implement max-attempts or timeout strategies.
	Err error
	// contains filtered or unexported fields
}

type WaitDetails struct {
	// ScheduledEndTimestamp is when the wait completes.
	ScheduledEndTimestamp *time.Time
}

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

type WaitForConditionError struct {
	// Name is the operation's name.
	Name string

	// Attempts is the number of times the check function was called.
	Attempts int

	// ErrorType is the wire ErrorType of the check or strategy error.
	ErrorType string

	// Message is the recorded error message.
	Message string

	// ErrorData is the payload attached with [WithErrorData], if any.
	ErrorData string

	// StackTrace holds recorded stack trace lines, when captured.
	StackTrace []string

	// Err is the stand-in for the failure from the check function or wait
	// strategy.
	Err error
}

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

type WaitOptions struct {
	// WaitSeconds is the wait duration in seconds.
	WaitSeconds *int32
}

type WaitStrategy[S any] func(state S, attempt int) WaitDecision