@temelj/workflow 0.0.0-alpha.1

package/dist/types/message.mjs

@@ -0,0 +1 @@
+export {};

package/dist/types/observation.d.mts

@@ -0,0 +1,146 @@
+import { MessageId } from "./message-id.mjs";
+import { RunId } from "./run-id.mjs";
+import { CleanupRunsResult } from "./cleanup.mjs";
+import { ScheduleId, TickSchedulesResult } from "./schedule.mjs";
+import { StreamId } from "./stream-id.mjs";
+import { WorkflowStepAttemptRecord } from "./step-attempts.mjs";
+import { WorkerId } from "./worker-id.mjs";
+import { TelemetryContext } from "./telemetry.mjs";
+import { WorkflowLifecycleEvent, WorkflowRunRecord } from "./run.mjs";
+import { ChildWorkflowStartedEvent, EventRecord, MessageSentEvent, StreamEventKind, StreamFailedError } from "./events.mjs";
+import { StorageValue } from "@temelj/storage";
+import { EventHandler, EventPattern, Unsubscribe } from "@temelj/event";
+//#region src/types/observation.d.ts
+/** Describes the workflow run observation event contract. */
+type RunObservationEvent = WorkflowLifecycleEvent;
+/** Describes the workflow durable event observation event contract. */
+interface DurableEventObservationEvent {
+  readonly runId: RunId;
+  readonly event: EventRecord;
+  readonly events: readonly EventRecord[];
+}
+/** Describes the workflow step attempt observation event contract. */
+interface StepAttemptObservationEvent {
+  readonly runId: RunId;
+  readonly attempt: WorkflowStepAttemptRecord;
+}
+/** Describes the workflow message observation event contract. */
+interface MessageObservationEvent {
+  readonly runId: RunId;
+  readonly messageId: MessageId;
+  readonly payload?: StorageValue;
+  readonly timestamp?: Temporal.Instant;
+  readonly traceContext?: TelemetryContext;
+}
+/** Describes the workflow resume observation event contract. */
+interface ResumeObservationEvent {
+  readonly runId: RunId;
+  readonly messageId: MessageId;
+  readonly payload?: StorageValue;
+  readonly traceContext?: TelemetryContext;
+}
+/** Describes the workflow stream observation event contract. */
+interface StreamObservationEvent {
+  readonly runId: RunId;
+  readonly streamId: StreamId;
+  readonly streamName?: string;
+  readonly eventKind: StreamEventKind;
+  readonly timestamp: Temporal.Instant;
+  readonly stepId: string;
+  readonly stepName: string;
+  readonly index?: number;
+  readonly error?: StreamFailedError;
+}
+/** Describes a child workflow start observation event. */
+interface ChildWorkflowStartedObservationEvent {
+  readonly runId: RunId;
+  readonly event: ChildWorkflowStartedEvent;
+}
+/** Describes the workflow cleanup observation event contract. */
+interface CleanupObservationEvent {
+  readonly result: CleanupRunsResult;
+}
+/** Describes worker-side operation observations that are not durable run transitions. */
+interface WorkerOperationObservationEvent {
+  readonly workerId: WorkerId;
+  readonly runId?: RunId;
+  readonly operation: "poll" | "claim" | "heartbeat" | "lease_extension" | "lease_release";
+  readonly status: "success" | "failure" | "claimed" | "empty";
+  readonly timestamp: Temporal.Instant;
+  readonly run?: WorkflowRunRecord;
+  readonly error?: unknown;
+}
+/** Describes one recurring schedule fire that created a workflow run. */
+interface ScheduleRunCreatedObservationEvent {
+  readonly scheduleId: ScheduleId;
+  readonly runId: RunId;
+  readonly workflowName: string;
+  readonly workflowVersion?: string;
+  readonly fireAt: Temporal.Instant;
+  readonly timestamp: Temporal.Instant;
+}
+/** Describes one recurring schedule tick operation. */
+interface ScheduleTickObservationEvent {
+  readonly result: TickSchedulesResult;
+  readonly timestamp: Temporal.Instant;
+}
+/** Describes the workflow observation event map contract. */
+interface ObservationEventMap {
+  readonly "workflow:run-created": RunObservationEvent;
+  readonly "workflow:run-claimed": RunObservationEvent;
+  readonly "workflow:run-started": RunObservationEvent;
+  readonly "workflow:run-waiting": RunObservationEvent;
+  readonly "workflow:run-rescheduled": RunObservationEvent;
+  readonly "workflow:run-lease-released": RunObservationEvent;
+  readonly "workflow:run-manual-retry": RunObservationEvent;
+  readonly "workflow:run-permanently-failed": RunObservationEvent;
+  readonly "workflow:run-retrying": RunObservationEvent;
+  readonly "workflow:run-completed": RunObservationEvent;
+  readonly "workflow:run-failed": RunObservationEvent;
+  readonly "workflow:run-canceled": RunObservationEvent;
+  readonly "workflow:run-metadata-updated": RunObservationEvent;
+  readonly "workflow:durable-event-appended": DurableEventObservationEvent;
+  readonly "workflow:step-attempt-updated": StepAttemptObservationEvent;
+  readonly "workflow:message-sent": MessageObservationEvent;
+  readonly "workflow:hook-resumed": ResumeObservationEvent;
+  readonly "workflow:webhook-resumed": ResumeObservationEvent;
+  readonly "workflow:stream-updated": StreamObservationEvent;
+  readonly "workflow:child-workflow-started": ChildWorkflowStartedObservationEvent;
+  readonly "workflow:cleanup-completed": CleanupObservationEvent;
+  readonly "workflow:retention-applied": CleanupObservationEvent;
+  readonly "workflow:worker-operation": WorkerOperationObservationEvent;
+  readonly "workflow:schedule-ticked": ScheduleTickObservationEvent;
+  readonly "workflow:schedule-run-created": ScheduleRunCreatedObservationEvent;
+}
+/** Type used for workflow observation event pattern values. */
+type ObservationEventPattern = EventPattern<ObservationEventMap>;
+/** Type used for workflow observation event handler values. */
+type ObservationEventHandler<Pattern extends ObservationEventPattern = ObservationEventPattern> = EventHandler<ObservationEventMap, Pattern>;
+/** Type used for workflow observation unsubscribe values. */
+type ObservationUnsubscribe = Unsubscribe;
+/** Internal emitter facade used to publish workflow observation events. */
+interface ObservationEmitter {
+  readonly on: <Pattern extends ObservationEventPattern>(pattern: Pattern, handler: ObservationEventHandler<Pattern>) => () => void;
+  readonly once: <Pattern extends ObservationEventPattern>(pattern: Pattern, handler: ObservationEventHandler<Pattern>) => () => void;
+  readonly off: <Pattern extends ObservationEventPattern>(pattern: Pattern, handler: ObservationEventHandler<Pattern>) => void;
+  readonly listeners: {
+    (): readonly ObservationEventHandler[];
+    <Pattern extends ObservationEventPattern>(pattern: Pattern): readonly ObservationEventHandler<Pattern>[];
+  };
+  readonly clearListeners: (pattern?: ObservationEventPattern) => void;
+  readonly listenerCount: (pattern?: ObservationEventPattern) => number;
+  readonly emitRunEvent: (run: WorkflowRunRecord, previousRun?: WorkflowRunRecord) => void;
+  readonly emitRunMetadataUpdated: (run: WorkflowRunRecord, previousRun?: WorkflowRunRecord) => void;
+  readonly emitDurableEventAppended: (runId: RunId, event: EventRecord, events: readonly EventRecord[]) => void;
+  readonly emitMessageSent: (runId: RunId, event: MessageSentEvent) => void;
+  readonly emitHookResumed: (runId: RunId, messageId: MessageId, payload: StorageValue | undefined, traceContext: TelemetryContext | undefined) => void;
+  readonly emitWebhookResumed: (runId: RunId, messageId: MessageId, payload: StorageValue | undefined, traceContext: TelemetryContext | undefined) => void;
+  readonly emitChildWorkflowStarted: (event: ChildWorkflowStartedObservationEvent) => void;
+  readonly emitCleanupCompleted: (result: CleanupRunsResult) => void;
+  readonly emitRetentionApplied: (result: CleanupRunsResult) => void;
+  readonly emitWorkerOperation: (event: WorkerOperationObservationEvent) => void;
+  readonly emitScheduleTicked: (event: ScheduleTickObservationEvent) => void;
+  readonly emitScheduleRunCreated: (event: ScheduleRunCreatedObservationEvent) => void;
+}
+//#endregion
+export { ChildWorkflowStartedObservationEvent, CleanupObservationEvent, DurableEventObservationEvent, MessageObservationEvent, ObservationEmitter, ObservationEventHandler, ObservationEventMap, ObservationEventPattern, ObservationUnsubscribe, ResumeObservationEvent, RunObservationEvent, ScheduleRunCreatedObservationEvent, ScheduleTickObservationEvent, StepAttemptObservationEvent, StreamObservationEvent, WorkerOperationObservationEvent };

package/dist/types/observation.mjs

@@ -0,0 +1 @@
+export {};

package/dist/types/pagination.d.mts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+//#region src/types/pagination.d.ts
+declare const workflowCursorSchema: z.ZodString;
+declare const workflowPageDirectionSchema: z.ZodLiteral<"forward">;
+declare const workflowCursorKeyPartSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+declare const workflowCursorPayloadSchema: z.ZodObject<{
+  key: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+}, z.core.$strip>;
+/** Type used for workflow cursor values. */
+type Cursor = string;
+/** Type used for workflow page direction values. */
+type PageDirection = "forward";
+/** Options for workflow page. */
+interface PageOptions {
+  readonly cursor?: Cursor;
+  readonly limit?: number;
+  readonly direction?: PageDirection;
+}
+/** Type used for encoded workflow cursor payloads. */
+interface CursorPayload {
+  readonly key: readonly CursorKeyPart[];
+}
+/** Type used for sortable workflow cursor key parts. */
+type CursorKeyPart = string | number | boolean | null;
+/** Describes the workflow page contract. */
+interface WorkflowPage<TItem> {
+  readonly items: readonly TItem[];
+  readonly nextCursor?: Cursor;
+  readonly hasMore: boolean;
+}
+//#endregion
+export { Cursor, CursorKeyPart, CursorPayload, PageDirection, PageOptions, WorkflowPage, workflowCursorKeyPartSchema, workflowCursorPayloadSchema, workflowCursorSchema, workflowPageDirectionSchema };

package/dist/types/pagination.mjs

@@ -0,0 +1,13 @@
+import { z } from "zod";
+//#region src/types/pagination.ts
+const workflowCursorSchema = z.string({ error: "Workflow cursor is invalid" });
+const workflowPageDirectionSchema = z.literal("forward", { error: "Workflow page direction is invalid" });
+const workflowCursorKeyPartSchema = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+const workflowCursorPayloadSchema = z.object({ key: z.array(workflowCursorKeyPartSchema).nonempty() });
+//#endregion
+export { workflowCursorKeyPartSchema, workflowCursorPayloadSchema, workflowCursorSchema, workflowPageDirectionSchema };

package/dist/types/result.d.mts

@@ -0,0 +1,62 @@
+import { RunId } from "./run-id.mjs";
+import { Timeline } from "./timeline.mjs";
+import { WorkflowAttributePatch, WorkflowRunRecord, WorkflowRunStatus } from "./run.mjs";
+import { WorkflowErrorRecord } from "./error.mjs";
+import { EventRecord } from "./events.mjs";
+import { StorageValue } from "@temelj/storage";
+//#region src/types/result.d.ts
+/** Kind values for workflow execution results. */
+type ExecutionResultKind = "completed" | "waiting" | "failed";
+/** Base contract for workflow execution results. */
+interface ExecutionResultBase {
+  readonly kind: ExecutionResultKind;
+  readonly run: WorkflowRunRecord;
+}
+/** Result returned after a workflow execution attempt completes, waits, or fails. */
+type ExecutionResult<TOutput = unknown> = CompletedResult<TOutput> | WaitingResult | FailedResult;
+/** Execution result for a workflow run that completed during the attempt. */
+interface CompletedResult<TOutput> {
+  readonly kind: "completed";
+  readonly run: WorkflowRunRecord<StorageValue, TOutput>;
+  readonly output: TOutput;
+}
+/** Execution result for a workflow run that parked until a later time or message. */
+interface WaitingResult {
+  readonly kind: "waiting";
+  readonly run: WorkflowRunRecord;
+  readonly availableAt: Temporal.Instant;
+}
+/** Execution result for a workflow run that failed during the attempt. */
+interface FailedResult {
+  readonly kind: "failed";
+  readonly run: WorkflowRunRecord;
+  readonly error: WorkflowErrorRecord;
+}
+/** Engine-level handle for inspecting and controlling a workflow run. */
+interface WorkflowHandle<TOutput = unknown> {
+  readonly runId: RunId;
+  readonly workflowName: string;
+  readonly workflowVersion?: string;
+  getRun(): Promise<WorkflowRunRecord>;
+  status(): Promise<WorkflowRunStatus>;
+  events(): Promise<readonly EventRecord[]>;
+  timeline(): Promise<Timeline>;
+  result(): Promise<ExecutionResult<TOutput>>;
+  setMetadata(metadata: unknown): Promise<WorkflowRunRecord>;
+  setAttributes(attributes: WorkflowAttributePatch): Promise<WorkflowRunRecord>;
+  cancel(): Promise<WorkflowRunRecord>;
+}
+/** Operations backing a workflow run handle facade. */
+interface HandleOperations {
+  getTimeline(runId: RunId): Promise<Timeline>;
+  setMetadata(runId: RunId, metadata: unknown): Promise<WorkflowRunRecord>;
+  setAttributes(runId: RunId, attributes: WorkflowAttributePatch): Promise<WorkflowRunRecord>;
+  cancel(runId: RunId): Promise<WorkflowRunRecord>;
+}
+/** Options for polling a client run handle until the run reaches a terminal result. */
+interface ResultOptions {
+  readonly pollInterval?: Temporal.Duration;
+  readonly timeout?: Temporal.Duration;
+}
+//#endregion
+export { CompletedResult, ExecutionResult, ExecutionResultBase, ExecutionResultKind, FailedResult, HandleOperations, ResultOptions, WaitingResult, WorkflowHandle };

package/dist/types/result.mjs

@@ -0,0 +1 @@
+export {};

package/dist/types/retry.d.mts

@@ -0,0 +1,48 @@
+//#region src/types/retry.d.ts
+/** Retry policy for workflow runs after retryable workflow failures. */
+interface WorkflowRetryConfig {
+  readonly maximumAttempts?: number;
+  readonly initialInterval?: Temporal.Duration;
+  readonly backoffCoefficient?: number;
+  readonly maximumInterval?: Temporal.Duration;
+}
+/** Retry policy after duration values and defaults have been normalized. */
+interface WorkflowResolvedRetryConfig {
+  readonly maximumAttempts: number;
+  readonly initialInterval?: Temporal.Duration;
+  readonly backoffCoefficient: number;
+  readonly maximumInterval?: Temporal.Duration;
+}
+/** Retry policy for durable task attempts. */
+type WorkflowStepRetryConfig = WorkflowRetryConfig;
+/** Step retry policy after duration values and defaults have been normalized. */
+type WorkflowResolvedStepRetryConfig = WorkflowResolvedRetryConfig;
+/** Resolved retry policy used after a worker cannot find a workflow implementation. */
+interface WorkflowResolvedMissingImplementationRetryConfig {
+  readonly initialInterval: Temporal.Duration;
+  readonly backoffCoefficient: number;
+  readonly maximumInterval?: Temporal.Duration;
+  readonly maximumAttempts: number;
+}
+/** Required default values used to complete missing-implementation retry options. */
+interface WorkflowMissingImplementationRetryDefaults {
+  readonly initialInterval: Temporal.Duration;
+  readonly backoffCoefficient: number;
+  readonly maximumAttempts: number;
+}
+/** Required default values used to complete workflow and step retry options. */
+interface WorkflowResolvedRetryDefaults {
+  readonly maximumAttempts: number;
+  readonly backoffCoefficient: number;
+}
+/** Parsed retry policy before runtime defaults are applied. */
+type WorkflowParsedRetryConfig = WorkflowRetryConfig;
+/** Retry policy used when a worker cannot find an implementation for a claimed run. */
+interface WorkflowMissingImplementationRetryConfig {
+  readonly initialInterval?: Temporal.Duration;
+  readonly backoffCoefficient?: number;
+  readonly maximumInterval?: Temporal.Duration;
+  readonly maximumAttempts?: number;
+}
+//#endregion
+export { WorkflowMissingImplementationRetryConfig, WorkflowMissingImplementationRetryDefaults, WorkflowParsedRetryConfig, WorkflowResolvedMissingImplementationRetryConfig, WorkflowResolvedRetryConfig, WorkflowResolvedRetryDefaults, WorkflowResolvedStepRetryConfig, WorkflowRetryConfig, WorkflowStepRetryConfig };

package/dist/types/retry.mjs

@@ -0,0 +1 @@
+export {};

package/dist/types/run-id.d.mts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+//#region src/types/run-id.d.ts
+declare const runIdSchema: z.ZodString;
+/** Non-empty identifier used for workflow runs. */
+type RunId = string;
+//#endregion
+export { RunId, runIdSchema };

package/dist/types/run-id.mjs

@@ -0,0 +1,5 @@
+import { z } from "zod";
+//#region src/types/run-id.ts
+const runIdSchema = z.string().refine((value) => value.trim().length > 0, "Expected an ID");
+//#endregion
+export { runIdSchema };

package/dist/types/run-list.d.mts

@@ -0,0 +1,43 @@
+import { PageOptions } from "./pagination.mjs";
+import { WorkflowListStepAttemptsOptions } from "./step-attempts.mjs";
+import { WorkflowAttributeValue, WorkflowRunRetryReason, WorkflowRunStatus, WorkflowRunTransitionReason } from "./run.mjs";
+//#region src/types/run-list.d.ts
+/** Filters for listing stored workflow runs. */
+interface WorkflowListRunsOptions {
+  readonly status?: WorkflowRunStatus | readonly WorkflowRunStatus[];
+  readonly workflowName?: string;
+  readonly workflowVersion?: string;
+  readonly idempotencyKey?: string;
+  readonly workerId?: string;
+  readonly parentRunId?: string;
+  readonly parentStepId?: string;
+  readonly parentStepName?: string;
+  readonly parentStepAttempt?: number;
+  readonly lastTransitionReason?: WorkflowRunTransitionReason | readonly WorkflowRunTransitionReason[];
+  readonly createdAtFrom?: Temporal.Instant;
+  readonly createdAtTo?: Temporal.Instant;
+  readonly updatedAtFrom?: Temporal.Instant;
+  readonly updatedAtTo?: Temporal.Instant;
+  readonly finishedAtFrom?: Temporal.Instant;
+  readonly finishedAtTo?: Temporal.Instant;
+  readonly startedAtFrom?: Temporal.Instant;
+  readonly startedAtTo?: Temporal.Instant;
+  readonly availableAtFrom?: Temporal.Instant;
+  readonly availableAtTo?: Temporal.Instant;
+  readonly leaseExpiresAtFrom?: Temporal.Instant;
+  readonly leaseExpiresAtTo?: Temporal.Instant;
+  readonly retryReason?: WorkflowRunRetryReason | readonly WorkflowRunRetryReason[];
+  readonly retryAtFrom?: Temporal.Instant;
+  readonly retryAtTo?: Temporal.Instant;
+  readonly cleanupFinishedAtBefore?: Temporal.Instant;
+  readonly attributes?: Readonly<Record<string, WorkflowAttributeValue>>;
+  readonly attributeExists?: string | readonly string[];
+  readonly attributeMissing?: string | readonly string[];
+  readonly limit?: number;
+}
+/** Paginated filters for listing stored workflow runs. */
+type WorkflowListRunsPageOptions = WorkflowListRunsOptions & PageOptions;
+/** Paginated filters for listing materialized step attempts. */
+type WorkflowListStepAttemptsPageOptions = WorkflowListStepAttemptsOptions & PageOptions;
+//#endregion
+export { WorkflowListRunsOptions, WorkflowListRunsPageOptions, WorkflowListStepAttemptsPageOptions };

package/dist/types/run-list.mjs

@@ -0,0 +1 @@
+export {};

package/dist/types/run-options.d.mts

@@ -0,0 +1,86 @@
+import { RunId } from "./run-id.mjs";
+import { StepId } from "./step-id.mjs";
+import { WorkflowDefinition } from "./definition.mjs";
+import "./run.mjs";
+//#region src/types/run-options.d.ts
+/** Callback used to resolve the workflow version stored on a new run. */
+type WorkflowVersionResolver = (workflowName: string, definition: WorkflowDefinition<unknown, unknown, unknown>) => string | undefined | Promise<string | undefined>;
+/** Options that control workflow run creation and scheduling. */
+interface WorkflowStartOptions {
+  readonly id?: string;
+  readonly idempotencyKey?: string;
+  readonly workflowVersion?: string;
+  readonly workflowVersionResolver?: WorkflowVersionResolver;
+  readonly context?: unknown;
+  readonly parent?: WorkflowRunParentOptions;
+  readonly availableAt?: Temporal.Instant;
+  readonly deadlineAt?: Temporal.Instant;
+}
+/** Options for creating a single delayed workflow run at the next interval boundary. */
+interface ScheduleNextOptions {
+  readonly id?: string;
+  readonly every: Temporal.Duration;
+  readonly idempotencyKey: string;
+  readonly workflowVersion?: string;
+  readonly workflowVersionResolver?: WorkflowVersionResolver;
+  readonly context?: unknown;
+  readonly parent?: WorkflowRunParentOptions;
+  readonly deadlineAt?: Temporal.Instant;
+  readonly from?: Temporal.Instant;
+}
+/** Resolved schedule-next options split into schedule metadata and run-start options. */
+interface ResolvedScheduleNextOptions {
+  readonly schedule: ScheduleNextOptions & {
+    readonly from: Temporal.Instant;
+  };
+  readonly start: WorkflowStartOptions;
+}
+/** Single item in a batch workflow-start request. */
+interface WorkflowBatchStartItem<TRawInput = unknown> {
+  readonly input: TRawInput;
+  readonly options?: WorkflowStartOptions;
+}
+/** Parent workflow metadata stored on a child workflow run. */
+interface WorkflowRunParentOptions {
+  readonly runId: RunId;
+  readonly stepId?: StepId;
+  readonly stepName?: string;
+  readonly stepAttempt?: number;
+}
+/** Options for executing or resuming a workflow run. */
+interface WorkflowExecutionOptions {
+  readonly start?: WorkflowStartOptions;
+  readonly signal?: AbortSignal;
+}
+/** Options for creating a new run from an existing run record. */
+interface WorkflowRerunOptions {
+  readonly workflowName?: string;
+  readonly workflowVersion?: string;
+  readonly workflowVersionResolver?: WorkflowVersionResolver;
+  readonly start?: WorkflowStartOptions;
+}
+/** Options for moving a run back to pending at a new availability time. */
+interface WorkflowRescheduleRunOptions {
+  readonly availableAt?: Temporal.Instant;
+}
+/** Options for releasing an expired worker lease from a run. */
+interface WorkflowReleaseStaleLeaseOptions {
+  readonly availableAt?: Temporal.Instant;
+}
+/** Options for retrying a failed workflow run. */
+interface WorkflowRetryFailedRunOptions {
+  readonly availableAt?: Temporal.Instant;
+  readonly force?: boolean;
+}
+/** Options for marking a run as permanently failed. */
+interface WorkflowMarkRunPermanentlyFailedOptions {
+  readonly reason: string;
+}
+/** Options for resuming workflow execution. */
+interface WorkflowResumeOptions {
+  readonly signal?: AbortSignal;
+}
+/** Typed argument tuple used by runnable workflow wrappers. */
+type WorkflowRunArguments<TRawInput, TOptions> = [unknown] extends [TRawInput] ? [input: TRawInput, options?: TOptions] : [undefined] extends [TRawInput] ? [input?: TRawInput, options?: TOptions] : [input: TRawInput, options?: TOptions];
+//#endregion
+export { ResolvedScheduleNextOptions, ScheduleNextOptions, WorkflowBatchStartItem, WorkflowExecutionOptions, WorkflowMarkRunPermanentlyFailedOptions, WorkflowReleaseStaleLeaseOptions, WorkflowRerunOptions, WorkflowRescheduleRunOptions, WorkflowResumeOptions, WorkflowRetryFailedRunOptions, WorkflowRunArguments, WorkflowRunParentOptions, WorkflowStartOptions, WorkflowVersionResolver };

package/dist/types/run-options.mjs

@@ -0,0 +1 @@
+export {};