autocore

type AbortCause string

type AbortError struct {
	Cause AbortCause
	Err   error
}

type ActivityContext interface {
	context.Context
	Logger() *slog.Logger
	WorkflowKey() WorkflowKey
	// IdempotencyKey returns the opaque idempotency key of this activity execution.
	IdempotencyKey() string
}

type ActivityExecutionDisposition string

type ActivityExecutionResult string

type ActivityName[I, O proto.Message] string

type ActivityPollPredicate[O proto.Message] func(ctx ActivityContext, output O, config []byte) (bool, error)

type CancelWorkflowOptions struct {
	WorkflowKey WorkflowKey
}

type Channel[O proto.Message] interface {
	Selectable
	Receive() (O, error)
	Name() string
}

type ChildFuture[O proto.Message] interface {
	Future[O]
	WorkflowID() WorkflowID
}

type ChildWorkflowOptions struct {
	// Metadata is extra information about the child workflow execution, available
	// to interceptors. It is not inherited from the parent: a child that needs the
	// parent's metadata is given it explicitly here. Mirrors
	// ExecuteWorkflowOptions.Metadata.
	Metadata proto.Message
}

type Client interface {
	// ExecuteWorkflow executes the named workflow.
	// Do not use this method directly, use the ExecuteWorkflow function.
	ExecuteWorkflow(ctx context.Context, name string, input proto.Message, opts *ExecuteWorkflowOptions) (*ExecuteWorkflowResult, error)
	CancelWorkflow(ctx context.Context, opts *CancelWorkflowOptions) error
	// SendToWorkflow puts a value on one of the target workflow's channels.
	// Returns ErrWorkflowNotFound if no such workflow exists, ErrWorkflowNotRunning
	// if it is already terminal, and ErrSignalLimitExceeded once it has spent its
	// signal history budget. The latter two are permanent for that workflow.
	//
	// TODO: I think we want to align the name here with the workflow context.
	// Maybe SendMessageToWorkflow and ReceiveMessage (instead of ReceiveChannel)?
	// Not sure yet.
	SendToWorkflow(ctx context.Context, opts *SendToWorkflowOptions) error
	// GetWorkflowInfo returns a read-only snapshot of a workflow's execution
	// state and terminal result. Returns ErrWorkflowNotFound if no workflow
	// exists for the key.
	GetWorkflowInfo(ctx context.Context, key WorkflowKey) (*WorkflowInfo, error)
	// GetWorkflowMetadata returns the marshaled opaque metadata supplied via
	// ExecuteWorkflowOptions.Metadata when the workflow was created, or nil when
	// none was supplied. Returns ErrWorkflowNotFound if no workflow exists for
	// the key.
	GetWorkflowMetadata(ctx context.Context, key WorkflowKey) ([]byte, error)
}

type Config struct {
	Log                   *slog.Logger
	MeterProvider         otelmetric.MeterProvider
	TracerProvider        oteltrace.TracerProvider
	ErrCapturer           errz.ErrCapturer
	Validator             protovalidate.Validator
	RedisClient           rueidis.Client
	RedisKeyPrefix        string
	InstanceID            int64
	MigrationCentralDBCfg pgtool.DBConnConfig
	CentralDBCfg          pgtool.DBConnConfig
	Registry              *Registry

	// Workflow worker pool size.
	WorkflowPoolSize      int
	MaxSuspendedWorkflows int

	// Activity worker pool size.
	ActivityPoolSize int
}

type Dropper interface {
	Drop()
}

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

type ExecuteActivityOption func(*executeActivityOptions)

type ExecuteInlineActivityOption func(*executeInlineActivityOptions)

type ExecuteWorkflowOptions struct {
	ExternalNamespaceID ExternalNamespaceID
	// IdempotencyKey deduplicates workflow creation within the namespace. Required,
	// 1-255 bytes; the engine's reserved prefix is rejected. A user that wants a
	// workflow per call must mint a key that cannot collide, rather than leaving
	// this empty.
	IdempotencyKey string
	// ScheduleToCompleteTimeout overrides the engine's default per-workflow
	// schedule-to-complete deadline. Zero uses the engine default; a positive
	// value overrides it. The deadline cannot be disabled per workflow.
	ScheduleToCompleteTimeout time.Duration
	// Metadata is extra information about the workflow execution, available to interceptors.
	Metadata proto.Message
}

type ExecuteWorkflowResult struct {
	WorkflowKey   WorkflowKey
	AlreadyExists bool
}

type ExternalNamespaceID = persistence.ExternalNamespaceID

type Future[O proto.Message] interface {
	Selectable
	Get() (O, error)
}

type ReadinessAnnouncer interface {
	// Announce registers this instance as ready in the shared store.
	Announce(ctx context.Context) error
	// ReadyCount returns the number of ready instances with hysteresis applied.
	ReadyCount(ctx context.Context) int32
	// Deregister removes this instance from the ready set.
	Deregister(ctx context.Context) error
	// GC removes expired entries from the backing store.
	GC(ctx context.Context)
}

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

type ReadinessTrackerOption func(*ReadinessTracker)

type RegisterActivityOption[O proto.Message] func(r *Registry, name string)

type RegisterWorkflowOption func(r *Registry, name string)

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

type RetryPolicy = persistence.RetryPolicy

type Selectable interface {
	// ReadyAt reports whether the operation can be consumed without blocking
	// and, when it can, the sequence id of the history event that made it ready,
	// or 0 when no event did.
	//
	// Ids are comparable across operations and stable across a replay: an
	// operation that is not ready can only become ready at a higher id than one
	// that already is. Among several ready operations the lowest id is therefore
	// the one that became ready first, and a replay picks the same operation as
	// the live execution did even though it has seen more of the history.
	//
	// While a workflow is terminating, an operation that had not completed before
	// the cancellation reports the cancellation event's id.
	ReadyAt() (SequenceID, bool)
}

type Selector interface {
	AddCase(source Selectable, fn func()) Selector
	Select()
	HasPending() bool
}

type SendToWorkflowOptions struct {
	WorkflowKey    WorkflowKey
	IdempotencyKey string // user-supplied dedup key; required, 1-255 bytes, reserved prefix rejected
	ChannelName    string
	Payload        proto.Message
}

type SequenceID = persistence.SequenceID

type ShardID = persistence.ShardID

type SignalID = persistence.SignalID

type SignalPromotionContext struct {
	ShardID        ShardID
	WorkflowID     WorkflowID
	SignalID       SignalID
	IdempotencyKey string
	SignalType     SignalType
	SignalName     string
	Payload        []byte
	CreatedAt      time.Time
}

type SignalType = persistence.SignalType

type TimerFuture interface {
	Future[*emptypb.Empty]
	Dropper
}

type TypedWorkflowInfo[O proto.Message] struct {
	WorkflowKey    WorkflowKey
	Name           string
	IdempotencyKey string
	State          WorkflowState
	CreatedAt      time.Time
	UpdatedAt      time.Time
	Output         O
	Error          string
}

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

type WorkerManagerOption func(*WorkerManager)

type WorkflowContext interface {
	Logger() *slog.Logger
	Replaying() bool
	Now() time.Time
	NewSelector() Selector
	// Sleep blocks the workflow until the duration elapses. Returns ErrCanceled
	// if the workflow is canceled while sleeping. Cancellation is cooperative:
	// the caller chooses whether to propagate the error or ignore it. If the
	// underlying context is canceled, Sleep panics with
	// the classified abort, so the round ends without persisting completion and
	// the workflow_task is retried within the abort budget.
	Sleep(d time.Duration) error
	NewTimer(d time.Duration) TimerFuture
	WorkflowKey() WorkflowKey
	// Deadline is when the workflow's schedule-to-complete timeout elapses: the
	// instant the engine times it out. Read from the creation event, so it is the
	// same value on every replay round. A child workflow reports its parent's
	// deadline, so a whole spawn tree shares the root's.
	Deadline() time.Time
	// contains filtered or unexported methods
}

type WorkflowExecutionResult string

type WorkflowID = persistence.WorkflowID

type WorkflowInfo struct {
	WorkflowKey    WorkflowKey
	Name           string
	IdempotencyKey string
	State          WorkflowState
	CreatedAt      time.Time
	UpdatedAt      time.Time
	Output         []byte
	Error          string
}

type WorkflowKey struct {
	ShardID    ShardID
	WorkflowID WorkflowID
}

type WorkflowName[I, O proto.Message] string

type WorkflowState = persistence.WorkflowExecutionState