durable

type APIError struct {
	StatusCode int
	Code       string
	Message    string
}

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

type ActiveOperation struct {
	ContextID string
	ParentID  string
	Attempt   int
	Mode      DurableExecutionMode
}

type BatchCompletionReason string

type BatchItem struct {
	Result any             `json:"result,omitempty"`
	Error  *ErrorObject    `json:"error,omitempty"`
	Index  int             `json:"index"`
	Status BatchItemStatus `json:"status"`
}

type BatchItemStatus string

type BatchResult struct {
	All              []BatchItem           `json:"all"`
	CompletionReason BatchCompletionReason `json:"completionReason"`
}

type BatchResultSerdes struct{}

type CallbackDetails struct {
	CallbackID                string       `json:"CallbackId,omitempty"`
	Result                    string       `json:"Result,omitempty"`
	Error                     *ErrorObject `json:"Error,omitempty"`
	ScheduledTimeoutTimestamp *time.Time   `json:"ScheduledTimeoutTimestamp,omitempty"`
}

type CallbackOptions struct {
	TimeoutSeconds          int `json:"TimeoutSeconds,omitempty"`
	HeartbeatTimeoutSeconds int `json:"HeartbeatTimeoutSeconds,omitempty"`
}

type ChainedInvokeDetails struct {
	Result string       `json:"Result,omitempty"`
	Error  *ErrorObject `json:"Error,omitempty"`
}

type ChainedInvokeOptions struct {
	FunctionName string `json:"FunctionName,omitempty"`
}

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

type CheckpointRequest struct {
	DurableExecutionArn string
	CheckpointToken     string
	Updates             []OperationUpdate
}

type CheckpointResponse struct {
	CheckpointToken   string
	NewExecutionState *ExecutionState
}

type ChildConfig struct {
	Serdes           Serdes
	SubType          OperationSubType
	SummaryGenerator func(value any) string
	ErrorMapper      func(error) error
}

type ChildFunc func(ctx context.Context, child *DurableContext) (any, error)

type CompletionConfig struct {
	MinSuccessful              *int
	ToleratedFailureCount      *int
	ToleratedFailurePercentage *float64
}

type ConcurrencyConfig struct {
	MaxConcurrency   int
	TopLevelSubType  OperationSubType
	IterationSubType OperationSubType
	SummaryGenerator func(result *BatchResult) string
	Serdes           Serdes
	ItemSerdes       Serdes
	CompletionConfig *CompletionConfig
}

type ConcurrentExecutionItem struct {
	ID    string `json:"id"`
	Data  any    `json:"data,omitempty"`
	Index int    `json:"index"`
	Name  string `json:"name,omitempty"`
}

type ConcurrentExecutor func(item ConcurrentExecutionItem, childContext *DurableContext) (any, error)

type ContextDetails struct {
	Result         string       `json:"Result,omitempty"`
	ReplayChildren bool         `json:"ReplayChildren,omitempty"`
	Error          *ErrorObject `json:"Error,omitempty"`
}

type ContextOptions struct {
	ReplayChildren bool `json:"ReplayChildren,omitempty"`
}

type CreateCallbackConfig struct {
	Timeout          *Duration
	HeartbeatTimeout *Duration
	Serdes           Serdes
}

type CreateCallbackResult struct {
	Promise    *Future[any]
	CallbackID string
}

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

type DurableExecutionClient interface {
	GetExecutionState(input GetExecutionStateRequest) (GetExecutionStateResponse, error)
	Checkpoint(input CheckpointRequest) (CheckpointResponse, error)
}

type DurableExecutionConfig struct {
	Client    DurableExecutionClient
	Logger    Logger
	RequestID string
	TenantID  string
}

type DurableExecutionHandler func(ctx context.Context, event any, dctx *DurableContext) (any, error)

type DurableExecutionMode string

type DurableOperationError struct {
	Type    string
	Message string
	Cause   error
	Data    string
}

type Duration struct {
	Days    int `json:"days,omitempty"`
	Hours   int `json:"hours,omitempty"`
	Minutes int `json:"minutes,omitempty"`
	Seconds int `json:"seconds,omitempty"`
}

type ErrorObject struct {
	ErrorType    string   `json:"ErrorType,omitempty"`
	ErrorMessage string   `json:"ErrorMessage,omitempty"`
	ErrorData    string   `json:"ErrorData,omitempty"`
	StackTrace   []string `json:"StackTrace,omitempty"`
}

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

type ExecutionDetails struct {
	InputPayload string `json:"InputPayload,omitempty"`
}

type ExecutionState struct {
	Operations []Operation `json:"Operations"`
	NextMarker string      `json:"NextMarker,omitempty"`
}

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

type GetExecutionStateRequest struct {
	DurableExecutionArn string
	CheckpointToken     string
	Marker              string
	MaxItems            int
}

type GetExecutionStateResponse struct {
	Operations []Operation
	NextMarker string
}

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

type InvocationInput struct {
	DurableExecutionArn   string         `json:"DurableExecutionArn"`
	CheckpointToken       string         `json:"CheckpointToken"`
	InitialExecutionState ExecutionState `json:"InitialExecutionState"`
}

type InvocationOutput struct {
	Status InvocationStatus `json:"Status"`
	Result string           `json:"Result,omitempty"`
	Error  *ErrorObject     `json:"Error,omitempty"`
}

type InvocationStatus string

type InvokeConfig struct {
	PayloadSerdes Serdes
	ResultSerdes  Serdes
}

type JSONSerdes struct{}

type Logger interface {
	Debugf(format string, args ...any)
	Infof(format string, args ...any)
	Warnf(format string, args ...any)
	Errorf(format string, args ...any)
}

type MapConfig struct {
	MaxConcurrency   int
	ItemNamer        func(item any, index int) string
	Serdes           Serdes
	ItemSerdes       Serdes
	CompletionConfig *CompletionConfig
}

type MapFunc func(context *DurableContext, item any, index int, array []any) (any, error)

type NamedParallelBranch struct {
	Name string
	Func ParallelFunc
}

type NopLogger struct{}

type Operation struct {
	ID       string           `json:"Id,omitempty"`
	ParentID string           `json:"ParentId,omitempty"`
	Name     string           `json:"Name,omitempty"`
	Type     OperationType    `json:"Type,omitempty"`
	SubType  OperationSubType `json:"SubType,omitempty"`
	Status   OperationStatus  `json:"Status,omitempty"`

	ExecutionDetails     *ExecutionDetails     `json:"ExecutionDetails,omitempty"`
	StepDetails          *StepDetails          `json:"StepDetails,omitempty"`
	WaitDetails          *WaitDetails          `json:"WaitDetails,omitempty"`
	CallbackDetails      *CallbackDetails      `json:"CallbackDetails,omitempty"`
	ChainedInvokeDetails *ChainedInvokeDetails `json:"ChainedInvokeDetails,omitempty"`
	ContextDetails       *ContextDetails       `json:"ContextDetails,omitempty"`

	StartTimestamp *time.Time `json:"StartTimestamp,omitempty"`
}

type OperationAction string

type OperationLifecycleState string

type OperationMetadata struct {
	StepID   string
	Name     string
	Type     OperationType
	SubType  OperationSubType
	ParentID string
}

type OperationStatus string

type OperationSubType string

type OperationType string

type OperationUpdate struct {
	ID       string           `json:"Id,omitempty"`
	ParentID string           `json:"ParentId,omitempty"`
	Name     string           `json:"Name,omitempty"`
	Type     OperationType    `json:"Type,omitempty"`
	SubType  OperationSubType `json:"SubType,omitempty"`
	Action   OperationAction  `json:"Action,omitempty"`

	Payload string       `json:"Payload,omitempty"`
	Error   *ErrorObject `json:"Error,omitempty"`

	StepOptions          *StepOptions          `json:"StepOptions,omitempty"`
	WaitOptions          *WaitOptions          `json:"WaitOptions,omitempty"`
	CallbackOptions      *CallbackOptions      `json:"CallbackOptions,omitempty"`
	ChainedInvokeOptions *ChainedInvokeOptions `json:"ChainedInvokeOptions,omitempty"`
	ContextOptions       *ContextOptions       `json:"ContextOptions,omitempty"`
}

type ParallelConfig struct {
	MaxConcurrency   int
	Serdes           Serdes
	ItemSerdes       Serdes
	CompletionConfig *CompletionConfig
}

type ParallelFunc func(context *DurableContext) (any, error)

type PassThroughSerdes struct{}

type RetryDecision struct {
	ShouldRetry bool
	Delay       Duration
}

type RetryStrategy func(err error, attempt int) RetryDecision

type Serdes interface {
	Serialize(value any, ctx SerdesContext) (string, error)
	Deserialize(data string, ctx SerdesContext) (any, error)
}

type SerdesContext struct {
	EntityID            string
	DurableExecutionArn string
}

type StepConfig struct {
	RetryStrategy RetryStrategy
	Semantics     StepSemantics
	Serdes        Serdes
}

type StepContext struct {
	Logger Logger
}

type StepDetails struct {
	Result               string       `json:"Result,omitempty"`
	Error                *ErrorObject `json:"Error,omitempty"`
	Attempt              int          `json:"Attempt,omitempty"`
	NextAttemptTimestamp *time.Time   `json:"NextAttemptTimestamp,omitempty"`
}

type StepFunc func(ctx context.Context, stepCtx StepContext) (any, error)

type StepOptions struct {
	NextAttemptDelaySeconds int `json:"NextAttemptDelaySeconds,omitempty"`
}

type StepSemantics string

type TerminationDetails struct {
	Reason  TerminationReason
	Message string
	Error   error
}

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

type TerminationReason string

type UnrecoverableError interface {
	error
	TerminationReason() TerminationReason
	InvocationLevel() bool
	ExecutionLevel() bool
}

type WaitDetails struct {
	ScheduledEndTimestamp *time.Time `json:"ScheduledEndTimestamp,omitempty"`
}

type WaitForCallbackConfig struct {
	Timeout          *Duration
	HeartbeatTimeout *Duration
	RetryStrategy    RetryStrategy
	Serdes           Serdes
}

type WaitForCallbackContext struct {
	Logger Logger
}

type WaitForCallbackSubmitterFunc func(callbackID string, ctx WaitForCallbackContext) error

type WaitForConditionCheckFunc func(state any, ctx WaitForConditionContext) (any, error)

type WaitForConditionConfig struct {
	WaitStrategy WaitForConditionWaitStrategyFunc
	InitialState any
	Serdes       Serdes
}

type WaitForConditionContext struct {
	Logger Logger
}

type WaitForConditionDecision struct {
	ShouldContinue bool
	Delay          Duration
}

type WaitForConditionWaitStrategyFunc func(state any, attempt int) WaitForConditionDecision

type WaitOptions struct {
	WaitSeconds int `json:"WaitSeconds,omitempty"`
}

type WrappedHandler func(ctx context.Context, input InvocationInput) (InvocationOutput, error)