@fluidgrids/workflows 2026.1028.2 → 2026.1030.1

package/dist/{types-DV-HX_Gt.d.ts → types-Bv2i4cBX.d.cts}

@@ -1,4 +1,4 @@
-import { J as JsonObject, E as ErrorType, a as Json } from './types-BGoPzgcl.js';
+import { J as JsonObject, E as ErrorType, a as Json } from './types-V7jEEUaL.cjs';
 
 /**
  * The durable-function history contract (PLAN-B C-HIST, C-CMD, C-ABI):
@@ -13,6 +13,25 @@ import { J as JsonObject, E as ErrorType, a as Json } from './types-BGoPzgcl.js'
 
 /** Version of the runtime ABI and of the history file format. */
 declare const HISTORY_PROTOCOL = 1;
+/**
+ * The runtime compatibility release of this SDK (the runtime train of
+ * PLAN-B19 critique 4.5). R1 is the Phase B core runtime; R2 adds local
+ * activities, handler drain, run handles by workflow id and the R2 history
+ * fields. Release 3 (Phase C, C-R1) adds updates, custom and default queries,
+ * dynamic workflows, user activities, search attributes, interceptors with
+ * header propagation and sinks. A history recorded by release N replays under
+ * every release >= N; the service and the workers pin the release whose
+ * histories they accept.
+ */
+declare const RUNTIME_RELEASE = 3;
+/**
+ * What the runtime of this release can answer (C-ABI-H, reported as
+ * `FluidgridsRuntimeAbi.capabilities`). A bundle built before C-R1 reports no
+ * capabilities, and the service refuses updates and custom queries for it
+ * (DC4) instead of delivering requests the bundle would ignore.
+ */
+declare const RUNTIME_CAPABILITIES: readonly ["updates", "queries", "dynamic"];
+type RuntimeCapability = (typeof RUNTIME_CAPABILITIES)[number];
 /** Every value of the `type` column of `workflow_run_events`, UPPER_SNAKE (DB4). */
 declare const EVENT_TYPES: readonly ["WORKFLOW_STARTED", "WORKFLOW_TASK_SCHEDULED", "WORKFLOW_TASK_STARTED", "WORKFLOW_TASK_COMPLETED", "WORKFLOW_TASK_FAILED", "WORKFLOW_TASK_TIMED_OUT", "ACTIVITY_SCHEDULED", "ACTIVITY_STARTED", "ACTIVITY_HEARTBEAT", "ACTIVITY_COMPLETED", "ACTIVITY_FAILED", "ACTIVITY_TIMED_OUT", "ACTIVITY_CANCEL_REQUESTED", "ACTIVITY_CANCELLED", "ACTIVITY_PAUSED", "ACTIVITY_UNPAUSED", "ACTIVITY_RESET", "ACTIVITY_OPTIONS_UPDATED", "TIMER_STARTED", "TIMER_FIRED", "TIMER_CANCELLED", "SIGNAL_RECEIVED", "UPDATE_ADMITTED", "UPDATE_ACCEPTED", "UPDATE_COMPLETED", "CHILD_RUN_INITIATED", "CHILD_RUN_STARTED", "CHILD_RUN_COMPLETED", "CHILD_RUN_FAILED", "CHILD_RUN_CANCELLED", "CHILD_RUN_TERMINATED", "CHILD_RUN_TIMED_OUT", "EXTERNAL_RUN_CANCEL_REQUESTED", "EXTERNAL_RUN_CANCEL_RESOLVED", "EXTERNAL_RUN_SIGNALED", "SIDE_EFFECT_RECORDED", "LOCAL_ACTIVITY_COMPLETED", "LOCAL_ACTIVITY_FAILED", "SEARCH_ATTRIBUTES_UPSERTED", "CONTEXT_UPSERTED", "MARKER_RECORDED", "WORKFLOW_CANCEL_REQUESTED", "WORKFLOW_RESET", "VERSIONING_OVERRIDE_SET", "WORKFLOW_COMPLETED", "WORKFLOW_FAILED", "WORKFLOW_CANCELLED", "WORKFLOW_TERMINATED", "WORKFLOW_TIMED_OUT", "WORKFLOW_CONTINUED_AS_NEW"];
 type RunEventType = (typeof EVENT_TYPES)[number];
@@ -23,7 +42,11 @@ type CommandType = (typeof COMMAND_TYPES)[number];
 declare const PHASE_B_CORE_COMMANDS: ReadonlySet<CommandType>;
 /** Commands of the Phase B parity releases (defined now, enabled by the service per release). */
 declare const PHASE_B_PARITY_COMMANDS: ReadonlySet<CommandType>;
-/** Commands that are defined but refused in Phase B (`UNSUPPORTED_COMMAND`). */
+/**
+ * Commands of Phase C. They were refused throughout Phase B; from C-R1 the
+ * C-GATE feature set decides (`c.updates`, `c.searchAttributes`), and the
+ * deprecated release levels of `isCommandEnabled` still refuse them.
+ */
 declare const PHASE_C_COMMANDS: ReadonlySet<CommandType>;
 /** Commands that end the run; one may appear, and only last in a batch. */
 declare const TERMINAL_COMMANDS: ReadonlySet<CommandType>;
@@ -106,7 +129,11 @@ type Headers = Record<string, string>;
 interface CommandBase {
     headers?: Headers;
 }
-/** Signal and cancel targets. `workflowKey`/`workflowId` addressing is parity (11 §2.1). */
+/**
+ * Signal and cancel targets. `workflowKey`/`workflowId` addressing is parity
+ * (11 §2.1): it reaches the open run of that business id, following the
+ * continue-as-new chain; `firstRunId` pins the chain whose first run it names.
+ */
 type RunTarget = {
     runId: string;
 } | {
@@ -116,16 +143,63 @@ type RunTarget = {
 } | {
     workflowKey: string;
     workflowId: string;
+    firstRunId?: string;
 };
-interface ScheduleActivityCommand extends CommandBase {
+/** `idReusePolicy` of a start (11 §2.1): what a closed run with the same workflow id allows. */
+declare const WORKFLOW_ID_REUSE_POLICIES: readonly ["ALLOW_DUPLICATE", "ALLOW_DUPLICATE_FAILED_ONLY", "REJECT_DUPLICATE"];
+type WorkflowIdReusePolicy = (typeof WORKFLOW_ID_REUSE_POLICIES)[number];
+/** `idConflictPolicy` of a start (11 §2.1): what an open run with the same workflow id does. */
+declare const WORKFLOW_ID_CONFLICT_POLICIES: readonly ["FAIL", "USE_EXISTING", "TERMINATE_EXISTING"];
+type WorkflowIdConflictPolicy = (typeof WORKFLOW_ID_CONFLICT_POLICIES)[number];
+/** `versioningBehavior` of a version or a run (11 §2.27). */
+declare const VERSIONING_BEHAVIORS: readonly ["PINNED", "AUTO_UPGRADE"];
+type VersioningBehavior = (typeof VERSIONING_BEHAVIORS)[number];
+/** `timeoutType` of `WORKFLOW_TIMED_OUT` and `CHILD_RUN_TIMED_OUT` (11 §2.20). */
+declare const WORKFLOW_TIMEOUT_TYPES: readonly ["WORKFLOW_RUN", "WORKFLOW_EXECUTION"];
+type WorkflowTimeoutType = (typeof WORKFLOW_TIMEOUT_TYPES)[number];
+/**
+ * The run-level retry policy of a DURABLE_FN run (11 §2.17), in milliseconds.
+ * A run that fails with a retryable failure, or whose run timeout expires,
+ * is started again as a new run of the same chain, up to `maxAttempts`
+ * attempts in total (absent: unlimited, bounded by the execution timeout).
+ */
+interface RunRetryPolicy {
+    maxAttempts?: number;
+    /** Delay before the second attempt. */
+    initialDelayMs: number;
+    backoffMultiplier?: number;
+    maxDelayMs?: number;
+    /** Allow-list on `errorType`. */
+    retryOnErrorTypes?: ErrorType[];
+    /** Deny-list on the free-form `Failure.type`; wins over the allow-list. */
+    nonRetryableErrorTypes?: string[];
+}
+/** The three workflow timeouts of a run (11 §2.20), in milliseconds. */
+interface WorkflowTimeouts {
+    executionTimeout?: number;
+    runTimeout?: number;
+    workflowTaskTimeout?: number;
+}
+/** The longest fairness key (11 §2.11). */
+declare const FAIRNESS_KEY_MAX_LENGTH = 255;
+/** The range of a fairness weight (11 §2.11); the default is 1. */
+declare const FAIRNESS_WEIGHT_MIN = 0.1;
+declare const FAIRNESS_WEIGHT_MAX = 10;
+/** The name of a user activity (C-CMD-C). */
+declare const ACTIVITY_NAME_PATTERN = "^[A-Za-z_][A-Za-z0-9_.-]{0,127}$";
+/** The name of a task queue (C-CMD-C); `managed` is the platform's queue. */
+declare const TASK_QUEUE_NAME_PATTERN = "^[a-z0-9][a-z0-9-]{0,62}$";
+/** At most this many connections a user activity may name. */
+declare const MAX_ACTIVITY_CONNECTIONS = 16;
+/** UTF-8 bytes of the JSON of a command's `headers` map, at most. */
+declare const MAX_HEADERS_BYTES: number;
+/** At most this many sink calls one workflow task reports. */
+declare const MAX_SINK_CALLS = 256;
+/** What both kinds of `SCHEDULE_ACTIVITY` carry. */
+interface ScheduleActivityBase extends CommandBase {
     type: 'SCHEDULE_ACTIVITY';
     activityId: string;
-    kind: 'node';
-    nodeType: string;
-    nodeVersion?: string;
-    operation: string;
     args: Json;
-    connection?: string;
     retry: RetryPolicy;
     startToCloseTimeout?: number;
     scheduleToCloseTimeout?: number;
@@ -134,8 +208,34 @@ interface ScheduleActivityCommand extends CommandBase {
     cancellationType?: ActivityCancellationType;
     priority?: number;
     summary?: string;
+    /** Fairness within the queue (11 §2.11, Phase C); default the workspace id. */
+    fairnessKey?: string;
+    /** 0.1 to 10; default 1. */
+    fairnessWeight?: number;
+}
+/** A canvas node operation run as an activity (`ctx.run`). */
+interface ScheduleNodeActivityCommand extends ScheduleActivityBase {
+    kind: 'node';
+    nodeType: string;
+    nodeVersion?: string;
+    operation: string;
+    connection?: string;
     runOn?: string;
 }
+/**
+ * A user activity (`ctx.activity`, Phase C, C-CMD-C): a function a
+ * self-hosted worker polling `taskQueue` implements. It has no node type,
+ * operation or `runOn`.
+ */
+interface ScheduleUserActivityCommand extends ScheduleActivityBase {
+    kind: 'user';
+    activityName: string;
+    taskQueue: string;
+    /** Connection names the worker may resolve per attempt (H2), at most 16. */
+    connections?: string[];
+}
+/** `SCHEDULE_ACTIVITY`, a `oneOf` on `kind` (C-CMD-C). */
+type ScheduleActivityCommand = ScheduleNodeActivityCommand | ScheduleUserActivityCommand;
 interface RequestCancelActivityCommand extends CommandBase {
     type: 'REQUEST_CANCEL_ACTIVITY';
     activityId: string;
@@ -164,7 +264,15 @@ interface ChildRunOptions {
     runTimeout?: number;
     workflowTaskTimeout?: number;
     startDelay?: number;
-    [key: string]: Json | undefined;
+    /** Run-level retry of the child (11 §2.17). */
+    retry?: RunRetryPolicy;
+    versioningBehavior?: VersioningBehavior;
+    idReusePolicy?: WorkflowIdReusePolicy;
+    idConflictPolicy?: WorkflowIdConflictPolicy;
+    /** Fairness of the child's tasks (11 §2.11, Phase C); inherited by default. */
+    fairnessKey?: string;
+    fairnessWeight?: number;
+    [key: string]: Json | RunRetryPolicy | undefined;
 }
 interface StartChildRunCommand extends CommandBase {
     type: 'START_CHILD_RUN';
@@ -216,6 +324,10 @@ interface RecordLocalActivityCommand extends CommandBase {
     result?: Json;
     failure?: Failure;
     attempts: number;
+    /** The node operation that ran (R2), for the History tab and replay matching. */
+    nodeType?: string;
+    operation?: string;
+    summary?: string;
 }
 interface ContinueAsNewCommand extends CommandBase {
     type: 'CONTINUE_AS_NEW';
@@ -258,15 +370,28 @@ declare const DEFAULT_HISTORY_LIMIT: HistoryLimit;
 declare const CONTINUE_AS_NEW_SUGGESTED_RATIO = 0.8;
 /** Fraction of the cap at which the next command throws `HistoryLimitExceeded`. */
 declare const HISTORY_LIMIT_EXCEEDED_RATIO = 0.95;
-/** What a task knows about its run (C-ABI `WorkflowInfoSnapshot`). */
+/**
+ * What a task knows about its run (C-ABI `WorkflowInfoSnapshot`). From SDK R2
+ * the runtime reads `workflowId`, `runAttempt`, `lastResult`, `lastFailure`,
+ * `summary`, `details`, the memo (`context`), the timeouts, `retry`,
+ * `priority` and `versioningBehavior` from `WORKFLOW_STARTED` when the event
+ * carries them, so a replay sees what the first execution saw; the lease
+ * values here are the fallback for histories written before R2.
+ */
 interface WorkflowInfoSnapshot {
     runId: string;
     workspaceId: string;
     workflowKey?: string;
     version?: number | string;
     buildId?: string;
+    /** The column name of the workflow id (11 §2.1). */
     businessId?: string;
+    /** The caller-chosen workflow id (`businessId`), else the first run's id. */
+    workflowId?: string;
+    /** Run-level retry attempt, 1-based (same value as `runAttempt`). */
     attempt?: number;
+    /** Run-level retry attempt, 1-based (11 §2.17). */
+    runAttempt?: number;
     taskQueue?: string;
     parentRunId?: string | null;
     rootRunId?: string | null;
@@ -286,11 +411,58 @@ interface WorkflowInfoSnapshot {
     priority?: number;
     summary?: string;
     details?: string;
+    /** The run's memo (11 §2.22); `memo` is the same value under its Temporal name. */
     context?: JsonObject;
+    memo?: JsonObject;
+    versioningBehavior?: VersioningBehavior;
+    /** The run-level retry policy of the chain. */
+    retry?: RunRetryPolicy;
+    /** The run's search attributes at the start (11 §2.8, Phase C). */
+    searchAttributes?: JsonObject;
+    /** Fairness of the run's tasks (11 §2.11, Phase C). */
+    fairnessKey?: string;
+    fairnessWeight?: number;
 }
-/** A built-in query (11 §2.21). Custom queries are Phase C. */
+/** A built-in query (11 §2.21); any other name is a custom query (Phase C). */
 type BuiltInQueryName = '__stack_trace' | '__enhanced_stack_trace' | '__metadata';
 declare const BUILT_IN_QUERIES: readonly BuiltInQueryName[];
+/**
+ * A pending update the lease delivers to a workflow task (C-ABI-H). The
+ * request is not in history until the task accepts it (`UPDATE_ACCEPTED`);
+ * `admitted` marks one that history already holds as `UPDATE_ADMITTED`
+ * (update-with-start, reset re-application), which the runtime delivers from
+ * that event instead.
+ */
+interface UpdateRequest {
+    updateId: string;
+    name: string;
+    args?: Json;
+    admitted?: boolean;
+    headers?: Headers;
+}
+/** A query a task answers (11 §2.21). Built-in names need no handler. */
+interface QueryRequest {
+    queryId: string;
+    name: string;
+    args?: Json;
+}
+/**
+ * The answer to one query. `rejected` means no handler took the name (the
+ * service answers `VALIDATION`); `error` without `rejected` means the handler
+ * threw or the replay failed.
+ */
+interface QueryResult {
+    queryId: string;
+    value?: Json;
+    error?: string;
+    rejected?: boolean;
+}
+/** One call workflow code made to a worker-side sink (11 §2.31); never on replay. */
+interface SinkCall {
+    sink: string;
+    fn: string;
+    args: Json[];
+}
 /** The input of one workflow task (C-ABI). */
 interface WorkflowTaskRequest {
     protocol: number;
@@ -300,27 +472,63 @@ interface WorkflowTaskRequest {
     history: RunEventRecord[];
     /** The task's start time; the clock for new side effects only. */
     nowMs: number;
-    localActivityResults?: Array<{
-        localActivityId: string;
-        result?: Json;
-        failure?: Failure;
-        attempts: number;
-    }>;
-    queries?: Array<{
-        queryId: string;
-        name: BuiltInQueryName;
-        args?: Json;
-    }>;
-}
-/** A local activity the task wants run before it can continue (parity). */
+    localActivityResults?: LocalActivityResult[];
+    /** Pending updates the lease delivers (C-ABI-H, Phase C). */
+    updates?: UpdateRequest[];
+    /** Queries to answer once the history is replayed. */
+    queries?: QueryRequest[];
+    /**
+     * The bundle features (C-FEATURES, the names of `code.features`) the
+     * workspace enables for this task, from its flags (Phase C). From C-R1 the
+     * runtime reads `interceptors`: a `task` of a bundle that exports
+     * interceptors fails with `UNSUPPORTED_COMMAND` unless it is listed, so
+     * turning `fluidgrids.run-control` off stops interceptors from running even
+     * for a bundle pushed while it was on. Absent means none.
+     */
+    features?: string[];
+}
+/** The result of one local activity, as the worker passes it back into the task (C-ABI). */
+interface LocalActivityResult {
+    localActivityId: string;
+    result?: Json;
+    failure?: Failure;
+    /** Attempts run so far, the last one included. */
+    attempts: number;
+}
+/** The largest `startToCloseTimeout` of a local activity, and its default (11 §2.12). */
+declare const LOCAL_ACTIVITY_MAX_TIMEOUT_MS = 30000;
+/**
+ * A local activity the task wants run before it can continue (parity, 11
+ * §2.12). The worker runs attempt `attempt` (after waiting `backoffMs` when
+ * it is a retry) inside the task's budget, then runs the same task again with
+ * the outcome in `localActivityResults`. The runtime decides with
+ * `computeRetryDelay` whether a failure is final; a retryable one is
+ * requested again with the next attempt. A worker that cannot fit the wait
+ * and the attempt into the remaining budget answers with a non-retryable
+ * `TIMEOUT` failure of type `LocalActivityBudgetExceeded` instead.
+ */
 interface LocalActivityRequest {
     localActivityId: string;
+    kind: 'node';
     nodeType: string;
+    nodeVersion?: string;
     operation: string;
     args: Json;
     connection?: string;
-    retry?: RetryPolicy;
-    startToCloseTimeout?: number;
+    retry: RetryPolicy;
+    /** Milliseconds; at most {@link LOCAL_ACTIVITY_MAX_TIMEOUT_MS}. */
+    startToCloseTimeout: number;
+    /** The attempt to run, 1-based. */
+    attempt: number;
+    /** Milliseconds to wait before this attempt (0 for the first). */
+    backoffMs: number;
+    summary?: string;
+}
+/** Signal or update handlers still running when the workflow finished (11 §2.18). */
+interface UnfinishedHandler {
+    kind: 'signal' | 'update';
+    name: string;
+    count: number;
 }
 interface TaskLogLine {
     level: 'debug' | 'info' | 'warn' | 'error';
@@ -333,11 +541,9 @@ interface WorkflowTaskResult {
     outcome: 'commands' | 'failed' | 'localActivityRequested';
     commands: WorkflowCommand[];
     localActivityRequests?: LocalActivityRequest[];
-    queryResults?: Array<{
-        queryId: string;
-        value?: Json;
-        error?: string;
-    }>;
+    queryResults?: QueryResult[];
+    /** Sink calls of the open activation, at most {@link MAX_SINK_CALLS} (Phase C). */
+    sinkCalls?: SinkCall[];
     failure?: {
         cause: WorkflowTaskFailureCause;
         message: string;
@@ -347,6 +553,11 @@ interface WorkflowTaskResult {
     };
     logs: TaskLogLine[];
     stackTrace?: string;
+    /**
+     * Handlers still running when this task's terminal command was issued, with
+     * policy `WARN_AND_ABANDON` (R2). Never set on replay.
+     */
+    unfinishedHandlers?: UnfinishedHandler[];
 }
 /**
  * The event each command appends (C-CMD). `REJECT_UPDATE` appends nothing: a
@@ -377,4 +588,4 @@ declare function isCommandEvent(event: {
     payload: JsonObject;
 }): boolean;
 
-export { type StartTimerCommand as $, ACTIVITY_CANCELLATION_TYPES as A, BUILT_IN_QUERIES as B, type ChildCancellationType as C, DEFAULT_HISTORY_LIMIT as D, ERROR_TYPES as E, type Failure as F, PHASE_B_PARITY_COMMANDS as G, HISTORY_LIMIT_EXCEEDED_RATIO as H, INPUT_EVENTS as I, PHASE_C_COMMANDS as J, type RecordLocalActivityCommand as K, type LocalActivityRequest as L, type RecordMarkerCommand as M, type RecordSideEffectCommand as N, type RejectUpdateCommand as O, type ParentClosePolicy as P, type RequestCancelActivityCommand as Q, type RetryPolicy as R, type RequestCancelExternalRunCommand as S, type RunEventDraft as T, type RunEventRecord as U, type RunEventType as V, type WorkflowCommand as W, type RunTarget as X, type ScheduleActivityCommand as Y, type SignalRunCommand as Z, type StartChildRunCommand as _, type WorkflowTaskFailureCause as a, TASK_FAILURE_CAUSES as a0, TERMINAL_COMMANDS as a1, TERMINAL_EVENTS as a2, type TaskLogLine as a3, type UpsertContextCommand as a4, type UpsertSearchAttributesCommand as a5, type WorkflowInfoSnapshot as a6, type WorkflowTaskRequest as a7, type WorkflowTaskResult as a8, isCommandEvent as a9, isInputEvent as aa, type AcceptUpdateCommand as b, type ActivityCancellationType as c, type BuiltInQueryName as d, CHILD_CANCELLATION_TYPES as e, COMMAND_EVENTS as f, COMMAND_EVENT_TYPES as g, COMMAND_TYPES as h, CONTINUE_AS_NEW_SUGGESTED_RATIO as i, type CancelTimerCommand as j, type CancelWorkflowCommand as k, type ChildRunOptions as l, type CommandType as m, type CompleteUpdateCommand as n, type CompleteWorkflowCommand as o, type ContinueAsNewCommand as p, EVENT_TYPES as q, EXECUTION_KINDS as r, type ExecutionKind as s, type FailWorkflowCommand as t, type FailureSource as u, HISTORY_PROTOCOL as v, type Headers as w, type HistoryLimit as x, PARENT_CLOSE_POLICIES as y, PHASE_B_CORE_COMMANDS as z };
+export { PARENT_CLOSE_POLICIES as $, ACTIVITY_CANCELLATION_TYPES as A, BUILT_IN_QUERIES as B, type ChildCancellationType as C, DEFAULT_HISTORY_LIMIT as D, ERROR_TYPES as E, type Failure as F, FAIRNESS_WEIGHT_MAX as G, FAIRNESS_WEIGHT_MIN as H, type FailWorkflowCommand as I, type FailureSource as J, HISTORY_LIMIT_EXCEEDED_RATIO as K, HISTORY_PROTOCOL as L, type Headers as M, type HistoryLimit as N, INPUT_EVENTS as O, type ParentClosePolicy as P, type QueryResult as Q, type RunEventRecord as R, LOCAL_ACTIVITY_MAX_TIMEOUT_MS as S, type TaskLogLine as T, type UnfinishedHandler as U, type LocalActivityRequest as V, type WorkflowCommand as W, type LocalActivityResult as X, MAX_ACTIVITY_CONNECTIONS as Y, MAX_HEADERS_BYTES as Z, MAX_SINK_CALLS as _, type WorkflowTaskFailureCause as a, PHASE_B_CORE_COMMANDS as a0, PHASE_B_PARITY_COMMANDS as a1, PHASE_C_COMMANDS as a2, RUNTIME_CAPABILITIES as a3, RUNTIME_RELEASE as a4, type RecordLocalActivityCommand as a5, type RecordMarkerCommand as a6, type RecordSideEffectCommand as a7, type RejectUpdateCommand as a8, type RequestCancelActivityCommand as a9, type WorkflowTaskResult as aA, type WorkflowTimeoutType as aB, type WorkflowTimeouts as aC, isCommandEvent as aD, isInputEvent as aE, type RequestCancelExternalRunCommand as aa, type RunEventDraft as ab, type RunEventType as ac, type RunTarget as ad, type RuntimeCapability as ae, type ScheduleActivityCommand as af, type ScheduleNodeActivityCommand as ag, type ScheduleUserActivityCommand as ah, type SignalRunCommand as ai, type SinkCall as aj, type StartChildRunCommand as ak, type StartTimerCommand as al, TASK_FAILURE_CAUSES as am, TASK_QUEUE_NAME_PATTERN as an, TERMINAL_COMMANDS as ao, TERMINAL_EVENTS as ap, type UpsertContextCommand as aq, type UpsertSearchAttributesCommand as ar, VERSIONING_BEHAVIORS as as, type VersioningBehavior as at, WORKFLOW_ID_CONFLICT_POLICIES as au, WORKFLOW_ID_REUSE_POLICIES as av, WORKFLOW_TIMEOUT_TYPES as aw, type WorkflowIdConflictPolicy as ax, type WorkflowIdReusePolicy as ay, type WorkflowTaskRequest as az, type WorkflowInfoSnapshot as b, type UpdateRequest as c, type QueryRequest as d, type RetryPolicy as e, type RunRetryPolicy as f, ACTIVITY_NAME_PATTERN as g, type AcceptUpdateCommand as h, type ActivityCancellationType as i, type BuiltInQueryName as j, CHILD_CANCELLATION_TYPES as k, COMMAND_EVENTS as l, COMMAND_EVENT_TYPES as m, COMMAND_TYPES as n, CONTINUE_AS_NEW_SUGGESTED_RATIO as o, type CancelTimerCommand as p, type CancelWorkflowCommand as q, type ChildRunOptions as r, type CommandType as s, type CompleteUpdateCommand as t, type CompleteWorkflowCommand as u, type ContinueAsNewCommand as v, EVENT_TYPES as w, EXECUTION_KINDS as x, type ExecutionKind as y, FAIRNESS_KEY_MAX_LENGTH as z };