autocore

type AbortCause string

type AbortError struct {
	Cause AbortCause
	Err   error
}

type ActivityContext interface {
	context.Context
	Logger() *slog.Logger
	WorkflowID() WorkflowID
}

type ActivityExecutionDisposition string

type ActivityExecutionResult string

type ActivityName[I, O proto.Message] string

type CancelWorkflowOptions struct {
	WorkflowKey persistence.WorkflowKey
}

type Case interface {
	IsReadier
}

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

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
	// 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)
}

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 Engine struct {
	// contains filtered or unexported fields
}

type ExecuteActivityOption func(*executeActivityOptions)

type ExecuteInlineActivityOption func(*executeInlineActivityOptions)

type ExecuteWorkflowOptions struct {
	ExternalNamespaceID persistence.ExternalNamespaceID
	IdentityKey         string
}

type ExecuteWorkflowResult struct {
	WorkflowKey   persistence.WorkflowKey
	AlreadyExists bool
}

type ExternalNamespaceID = persistence.ExternalNamespaceID

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

type IsReadier interface {
	IsReady() bool
}

type Notifier interface {
	NotifyWorkflowTask(ctx context.Context, shardID persistence.ShardID)
	NotifySignal(ctx context.Context, shardID persistence.ShardID)
}

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 Registry struct {
	// contains filtered or unexported fields
}

type RetryPolicy = persistence.RetryPolicy

type Selector interface {
	AddCase(c Case, fn func()) Selector
	AddDefault(fn func()) Selector
	Select()
	HasPending() bool
}

type SendToWorkflowOptions struct {
	WorkflowKey persistence.WorkflowKey
	IdentityKey string // caller-provided dedup key; auto-generated if empty
	ChannelName string
	Payload     proto.Message
}

type ShardAcquiredCallback func(ctx context.Context, shardID persistence.ShardID, fenceID persistence.FenceID)

type ShardLostCallback func(ctx context.Context, shardID persistence.ShardID, cause error)

type ShardSubscriber interface {
	SubscribeShard(ctx context.Context, shardID persistence.ShardID)
	UnsubscribeShard(ctx context.Context, shardID persistence.ShardID)
	Run(ctx context.Context)
}

type TimerFuture Future[*emptypb.Empty]

type TypedWorkflowInfo[O proto.Message] struct {
	WorkflowKey WorkflowKey
	Name        string
	IdentityKey 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 (e.g. shard fence loss),
	// Sleep panics with terminateError so the workflow round terminates
	// without persisting completion.
	Sleep(d time.Duration) error
	NewTimer(d time.Duration) TimerFuture
	WorkflowID() WorkflowID
	// contains filtered or unexported methods
}

type WorkflowExecutionResult string

type WorkflowID = persistence.WorkflowID

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

type WorkflowKey = persistence.WorkflowKey

type WorkflowName[I, O proto.Message] string

type WorkflowState = persistence.WorkflowExecutionState