@temporalio/workflow 0.22.0 → 1.0.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/workflow",
-  "version": "0.22.0",
+  "version": "1.0.0-rc.1",
   "description": "Temporal.io SDK Workflow sub-package",
   "keywords": [
     "temporal",
@@ -15,16 +15,18 @@
   "author": "Roey Berman <roey@temporal.io>",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
-  "files": [
-    "lib"
-  ],
   "scripts": {},
   "dependencies": {
-    "@temporalio/internal-workflow-common": "^0.22.0",
-    "@temporalio/proto": "^0.22.0"
+    "@temporalio/common": "^1.0.0-rc.1",
+    "@temporalio/internal-workflow-common": "^1.0.0-rc.1",
+    "@temporalio/proto": "^1.0.0-rc.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "3aa1f14982bd170d21b728cbf016dc4f1b595a76"
+  "files": [
+    "src",
+    "lib"
+  ],
+  "gitHead": "723de0fbc7a04e68084ec99453578e7027eb3803"
 }

package/src/alea.ts

@@ -0,0 +1,88 @@
+// A port of an algorithm by Johannes Baagøe <baagoe@baagoe.com>, 2010
+// http://baagoe.com/en/RandomMusings/javascript/
+// https://github.com/nquinlan/better-random-numbers-for-javascript-mirror
+// Original work is under MIT license -
+
+// Copyright (C) 2010 by Johannes Baagøe <baagoe@baagoe.org>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// Taken and modified from https://github.com/davidbau/seedrandom/blob/released/lib/alea.js
+
+class Alea {
+  public c: number;
+  public s0: number;
+  public s1: number;
+  public s2: number;
+
+  constructor(seed: number[]) {
+    const mash = new Mash();
+    // Apply the seeding algorithm from Baagoe.
+    this.c = 1;
+    this.s0 = mash.mash([32]);
+    this.s1 = mash.mash([32]);
+    this.s2 = mash.mash([32]);
+    this.s0 -= mash.mash(seed);
+    if (this.s0 < 0) {
+      this.s0 += 1;
+    }
+    this.s1 -= mash.mash(seed);
+    if (this.s1 < 0) {
+      this.s1 += 1;
+    }
+    this.s2 -= mash.mash(seed);
+    if (this.s2 < 0) {
+      this.s2 += 1;
+    }
+  }
+
+  public next(): number {
+    const t = 2091639 * this.s0 + this.c * 2.3283064365386963e-10; // 2^-32
+    this.s0 = this.s1;
+    this.s1 = this.s2;
+    return (this.s2 = t - (this.c = t | 0));
+  }
+}
+
+export type RNG = () => number;
+
+export function alea(seed: number[]): RNG {
+  const xg = new Alea(seed);
+  return xg.next.bind(xg);
+}
+
+export class Mash {
+  private n = 0xefc8249d;
+
+  public mash(data: number[]): number {
+    let { n } = this;
+    for (let i = 0; i < data.length; i++) {
+      n += data[i];
+      let h = 0.02519603282416938 * n;
+      n = h >>> 0;
+      h -= n;
+      h *= n;
+      n = h >>> 0;
+      h -= n;
+      n += h * 0x100000000; // 2^32
+    }
+    this.n = n;
+    return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
+  }
+}

package/src/cancellation-scope.ts

@@ -0,0 +1,205 @@
+import { CancelledFailure, IllegalStateError } from '@temporalio/common';
+import type { AsyncLocalStorage as ALS } from 'async_hooks';
+import { untrackPromise } from './stack-helpers';
+
+// AsyncLocalStorage is injected via vm module into global scope.
+// In case Workflow code is imported in Node.js context, replace with an empty class.
+export const AsyncLocalStorage: new <T>() => ALS<T> = (globalThis as any).AsyncLocalStorage ?? class {};
+
+/** Magic symbol used to create the root scope - intentionally not exported */
+const NO_PARENT = Symbol('NO_PARENT');
+
+/**
+ * Option for constructing a CancellationScope
+ */
+export interface CancellationScopeOptions {
+  /**
+   * Time in milliseconds before the scope cancellation is automatically requested
+   */
+  timeout?: number;
+
+  /**
+   * If false, prevent outer cancellation from propagating to inner scopes, Activities, timers, and Triggers, defaults to true.
+   * (Scope still propagates CancelledFailure thrown from within).
+   */
+  cancellable: boolean;
+  /**
+   * An optional CancellationScope (useful for running background tasks).
+   * The `NO_PARENT` symbol is reserved for the root scope.
+   */
+  parent?: CancellationScope | typeof NO_PARENT;
+}
+
+/**
+ * In the SDK, Workflows are represented internally by a tree of scopes where the `execute` function runs in the root scope.
+ * Cancellation propagates from outer scopes to inner ones and is handled by catching {@link CancelledFailure}s
+ * thrown by cancellable operations (see below).
+ *
+ * Scopes are created using the `CancellationScope` constructor or the static helper methods
+ * {@link cancellable}, {@link nonCancellable} and {@link withTimeout}.
+ *
+ * When a `CancellationScope` is cancelled, it will propagate cancellation any child scopes and any cancellable
+ * operations created within it, such as:
+ *
+ * - Activities
+ * - Child Workflows
+ * - Timers (created with the {@link sleep} function)
+ * - {@link Trigger}s
+ *
+ * @example
+ *
+ * ```ts
+ * await CancellationScope.cancellable(async () => {
+ *   const promise = someActivity();
+ *   CancellationScope.current().cancel(); // Cancels the activity
+ *   await promise; // Throws `ActivityFailure` with `cause` set to `CancelledFailure`
+ * });
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const scope = new CancellationScope();
+ * const promise = scope.run(someActivity);
+ * scope.cancel(); // Cancels the activity
+ * await promise; // Throws `ActivityFailure` with `cause` set to `CancelledFailure`
+ * ```
+ */
+export class CancellationScope {
+  /**
+   * Time in milliseconds before the scope cancellation is automatically requested
+   */
+  protected readonly timeout?: number;
+
+  /**
+   * If false, prevent outer cancellation from propagating to inner scopes, Activities, timers, and Triggers, defaults to true.
+   * (Scope still propagates CancelledFailure thrown from within)
+   */
+  public readonly cancellable: boolean;
+  /**
+   * An optional CancellationScope (useful for running background tasks), defaults to {@link CancellationScope.current}()
+   */
+  public readonly parent?: CancellationScope;
+
+  /**
+   * Rejected when scope cancellation is requested
+   */
+  public readonly cancelRequested: Promise<never>;
+
+  #cancelRequested = false;
+
+  // Typescript does not understand that the Promise executor runs synchronously in the constructor
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  protected readonly reject: (reason?: any) => void;
+
+  constructor(options?: CancellationScopeOptions) {
+    this.timeout = options?.timeout;
+    this.cancellable = options?.cancellable ?? true;
+    this.cancelRequested = new Promise((_, reject) => {
+      // Typescript does not understand that the Promise executor runs synchronously
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      this.reject = (err) => {
+        this.#cancelRequested = true;
+        reject(err);
+      };
+    });
+    untrackPromise(this.cancelRequested);
+    // Avoid unhandled rejections
+    untrackPromise(this.cancelRequested.catch(() => undefined));
+    if (options?.parent !== NO_PARENT) {
+      this.parent = options?.parent || CancellationScope.current();
+      this.#cancelRequested = this.parent.#cancelRequested;
+      this.parent.cancelRequested.catch((err) => {
+        this.reject(err);
+      });
+    }
+  }
+
+  public get consideredCancelled(): boolean {
+    return this.#cancelRequested && this.cancellable;
+  }
+  /**
+   * Activate the scope as current and run  `fn`
+   *
+   * Any timers, Activities, Triggers and CancellationScopes created in the body of `fn`
+   * automatically link their cancellation to this scope.
+   *
+   * @return the result of `fn`
+   */
+  run<T>(fn: () => Promise<T>): Promise<T> {
+    return storage.run(this, this.runInContext.bind(this, fn) as () => Promise<T>);
+  }
+
+  /**
+   * Method that runs a function in AsyncLocalStorage context.
+   *
+   * Could have been written as anonymous function, made into a method for improved stack traces.
+   */
+  protected async runInContext<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.timeout) {
+      untrackPromise(
+        sleep(this.timeout).then(
+          () => this.cancel(),
+          () => {
+            // scope was already cancelled, ignore
+          }
+        )
+      );
+    }
+    return await fn();
+  }
+
+  /**
+   * Request to cancel the scope and linked children
+   */
+  cancel(): void {
+    this.reject(new CancelledFailure('Cancellation scope cancelled'));
+  }
+
+  /**
+   * Get the current "active" scope
+   */
+  static current(): CancellationScope {
+    return storage.getStore() ?? ROOT_SCOPE;
+  }
+
+  /** Alias to `new CancellationScope({ cancellable: true }).run(fn)` */
+  static cancellable<T>(fn: () => Promise<T>): Promise<T> {
+    return new this({ cancellable: true }).run(fn);
+  }
+
+  /** Alias to `new CancellationScope({ cancellable: false }).run(fn)` */
+  static nonCancellable<T>(fn: () => Promise<T>): Promise<T> {
+    return new this({ cancellable: false }).run(fn);
+  }
+
+  /** Alias to `new CancellationScope({ cancellable: true, timeout }).run(fn)` */
+  static withTimeout<T>(timeout: number, fn: () => Promise<T>): Promise<T> {
+    return new this({ cancellable: true, timeout }).run(fn);
+  }
+}
+
+/**
+ * This is exported so it can be disposed in the worker interface
+ */
+export const storage = new AsyncLocalStorage<CancellationScope>();
+
+export class RootCancellationScope extends CancellationScope {
+  cancel(): void {
+    this.reject(new CancelledFailure('Workflow cancelled'));
+  }
+}
+
+/** There can only be one of these */
+export const ROOT_SCOPE = new RootCancellationScope({ cancellable: true, parent: NO_PARENT });
+
+/** This function is here to avoid a circular dependency between this module and workflow.ts */
+let sleep = (_: number | string): Promise<void> => {
+  throw new IllegalStateError('Workflow has not been properly initialized');
+};
+
+export function registerSleepImplementation(fn: typeof sleep): void {
+  sleep = fn;
+}

package/src/errors.ts

@@ -0,0 +1,30 @@
+export { WorkflowExecutionAlreadyStartedError } from '@temporalio/common';
+
+/**
+ * Base class for all workflow errors
+ */
+export class WorkflowError extends Error {
+  public readonly name: string = 'WorkflowError';
+}
+
+/**
+ * Thrown in workflow when it tries to do something that non-deterministic such as construct a WeakMap()
+ */
+export class DeterminismViolationError extends WorkflowError {
+  public readonly name: string = 'DeterminismViolationError';
+}
+
+function looksLikeError(err: unknown): err is { name: string; cause?: unknown } {
+  return typeof err === 'object' && err != null && Object.prototype.hasOwnProperty.call(err, 'name');
+}
+
+/**
+ * Returns whether provided `err` is caused by cancellation
+ */
+export function isCancellation(err: unknown): boolean {
+  if (!looksLikeError(err)) return false;
+  return (
+    err.name === 'CancelledFailure' ||
+    ((err.name === 'ActivityFailure' || err.name === 'ChildWorkflowFailure') && isCancellation(err.cause))
+  );
+}

package/src/index.ts

@@ -0,0 +1,91 @@
+/**
+ * This library provides tools required for authoring workflows.
+ *
+ * ## Usage
+ * See the {@link https://docs.temporal.io/typescript/hello-world#workflows | tutorial} for writing your first workflow.
+ *
+ * ### Timers
+ *
+ * The recommended way of scheduling timers is by using the {@link sleep} function. We've replaced `setTimeout` and
+ * `clearTimeout` with deterministic versions so these are also usable but have a limitation that they don't play well
+ * with {@link https://docs.temporal.io/typescript/workflow-scopes-and-cancellation | cancellation scopes}.
+ *
+ * <!--SNIPSTART typescript-sleep-workflow-->
+ * <!--SNIPEND-->
+ *
+ * ### Activities
+ *
+ * To schedule Activities, use {@link proxyActivities} to obtain an Activity function and call.
+ *
+ * <!--SNIPSTART typescript-schedule-activity-workflow-->
+ * <!--SNIPEND-->
+ *
+ * ### Signals and Queries
+ *
+ * To add signal handlers to a Workflow, add a signals property to the exported `workflow` object. Signal handlers can
+ * return either `void` or `Promise<void>`, you may schedule activities and timers from a signal handler.
+ *
+ * To add query handlers to a Workflow, add a queries property to the exported `workflow` object. Query handlers must
+ * **not** mutate any variables or generate any commands (like Activities or Timers), they run synchronously and thus
+ * **must** return a `Promise`.
+ *
+ * #### Implementation
+ *
+ * <!--SNIPSTART typescript-workflow-signal-implementation-->
+ * <!--SNIPEND-->
+ *
+ * ### Deterministic built-ins
+ * It is safe to call `Math.random()` and `Date()` in workflow code as they are replaced with deterministic versions. We
+ * also provide a deterministic {@link uuid4} function for convenience.
+ *
+ * ### [Cancellation and scopes](https://docs.temporal.io/typescript/workflow-scopes-and-cancellation)
+ * - {@link CancellationScope}
+ * - {@link Trigger}
+ *
+ * ### [Sinks](https://docs.temporal.io/typescript/sinks)
+ * - {@link Sinks}
+ *
+ * @module
+ */
+
+export {
+  ActivityFailure,
+  ApplicationFailure,
+  CancelledFailure,
+  ChildWorkflowFailure,
+  defaultPayloadConverter,
+  PayloadConverter,
+  rootCause,
+  ServerFailure,
+  TemporalFailure,
+  TerminatedFailure,
+  TimeoutFailure,
+} from '@temporalio/common';
+export {
+  ActivityCancellationType,
+  ActivityFunction,
+  ActivityInterface, // eslint-disable-line deprecation/deprecation
+  ActivityOptions,
+  RetryPolicy,
+  UntypedActivities,
+} from '@temporalio/internal-workflow-common';
+export * from '@temporalio/internal-workflow-common/lib/errors';
+export * from '@temporalio/internal-workflow-common/lib/interfaces';
+export * from '@temporalio/internal-workflow-common/lib/workflow-handle';
+export * from '@temporalio/internal-workflow-common/lib/workflow-options';
+export { AsyncLocalStorage, CancellationScope, CancellationScopeOptions, ROOT_SCOPE } from './cancellation-scope';
+export * from './errors';
+export * from './interceptors';
+export {
+  ChildWorkflowCancellationType,
+  ChildWorkflowOptions,
+  ContinueAsNew,
+  ContinueAsNewOptions,
+  ParentClosePolicy,
+  ParentWorkflowInfo,
+  WorkflowInfo,
+} from './interfaces';
+export { Sink, SinkCall, SinkFunction, Sinks } from './sinks';
+export { Trigger } from './trigger';
+export * from './workflow';
+export { ChildWorkflowHandle, ExternalWorkflowHandle } from './workflow-handle';

package/src/interceptors.ts

@@ -0,0 +1,239 @@
+/**
+ * Type definitions and generic helpers for interceptors.
+ *
+ * The Workflow specific interceptors are defined here.
+ *
+ * @module
+ */
+
+import { WorkflowExecution } from '@temporalio/common';
+import { ActivityOptions, Headers, LocalActivityOptions, Next, Timestamp } from '@temporalio/internal-workflow-common';
+import type { coresdk } from '@temporalio/proto';
+import { ChildWorkflowOptionsWithDefaults, ContinueAsNewOptions } from './interfaces';
+
+export { Next, Headers };
+
+/** Input for WorkflowInboundCallsInterceptor.execute */
+export interface WorkflowExecuteInput {
+  readonly args: unknown[];
+  readonly headers: Headers;
+}
+
+/** Input for WorkflowInboundCallsInterceptor.handleSignal */
+export interface SignalInput {
+  readonly signalName: string;
+  readonly args: unknown[];
+  readonly headers: Headers;
+}
+
+/** Input for WorkflowInboundCallsInterceptor.handleQuery */
+export interface QueryInput {
+  readonly queryId: string;
+  readonly queryName: string;
+  readonly args: unknown[];
+  readonly headers: Headers;
+}
+
+/**
+ * Implement any of these methods to intercept Workflow inbound calls like execution, and signal and query handling.
+ */
+export interface WorkflowInboundCallsInterceptor {
+  /**
+   * Called when Workflow execute method is called
+   *
+   * @return result of the Workflow execution
+   */
+  execute?: (input: WorkflowExecuteInput, next: Next<this, 'execute'>) => Promise<unknown>;
+
+  /** Called when signal is delivered to a Workflow execution */
+  handleSignal?: (input: SignalInput, next: Next<this, 'handleSignal'>) => Promise<void>;
+
+  /**
+   * Called when a Workflow is queried
+   *
+   * @return result of the query
+   */
+  handleQuery?: (input: QueryInput, next: Next<this, 'handleQuery'>) => Promise<unknown>;
+}
+
+/** Input for WorkflowOutboundCallsInterceptor.scheduleActivity */
+export interface ActivityInput {
+  readonly activityType: string;
+  readonly args: unknown[];
+  readonly options: ActivityOptions;
+  readonly headers: Headers;
+  readonly seq: number;
+}
+
+/** Input for WorkflowOutboundCallsInterceptor.scheduleLocalActivity */
+export interface LocalActivityInput {
+  readonly activityType: string;
+  readonly args: unknown[];
+  readonly options: LocalActivityOptions;
+  readonly headers: Headers;
+  readonly seq: number;
+  readonly originalScheduleTime?: Timestamp;
+  readonly attempt: number;
+}
+
+/** Input for WorkflowOutboundCallsInterceptor.startChildWorkflowExecution */
+export interface StartChildWorkflowExecutionInput {
+  readonly workflowType: string;
+  readonly options: ChildWorkflowOptionsWithDefaults;
+  readonly headers: Headers;
+  readonly seq: number;
+}
+
+/** Input for WorkflowOutboundCallsInterceptor.startTimer */
+export interface TimerInput {
+  readonly durationMs: number;
+  readonly seq: number;
+}
+
+/**
+ * Same as ContinueAsNewOptions but workflowType must be defined
+ */
+export type ContinueAsNewInputOptions = ContinueAsNewOptions & Required<Pick<ContinueAsNewOptions, 'workflowType'>>;
+
+/** Input for WorkflowOutboundCallsInterceptor.continueAsNew */
+export interface ContinueAsNewInput {
+  readonly args: unknown[];
+  readonly headers: Headers;
+  readonly options: ContinueAsNewInputOptions;
+}
+
+/** Input for WorkflowOutboundCallsInterceptor.signalWorkflow */
+export interface SignalWorkflowInput {
+  readonly seq: number;
+  readonly signalName: string;
+  readonly args: unknown[];
+  readonly headers: Headers;
+  readonly target:
+    | {
+        readonly type: 'external';
+        readonly workflowExecution: WorkflowExecution;
+      }
+    | {
+        readonly type: 'child';
+        readonly childWorkflowId: string;
+      };
+}
+
+/**
+ * Implement any of these methods to intercept Workflow code calls to the Temporal APIs, like scheduling an activity and starting a timer
+ */
+export interface WorkflowOutboundCallsInterceptor {
+  /**
+   * Called when Workflow schedules an Activity
+   *
+   * @return result of the activity execution
+   */
+  scheduleActivity?: (input: ActivityInput, next: Next<this, 'scheduleActivity'>) => Promise<unknown>;
+
+  /**
+   * Called when Workflow schedules a local Activity
+   *
+   * @return result of the activity execution
+   */
+  scheduleLocalActivity?: (input: LocalActivityInput, next: Next<this, 'scheduleLocalActivity'>) => Promise<unknown>;
+
+  /**
+   * Called when Workflow starts a timer
+   */
+  startTimer?: (input: TimerInput, next: Next<this, 'startTimer'>) => Promise<void>;
+
+  /**
+   * Called when Workflow calls continueAsNew
+   */
+  continueAsNew?: (input: ContinueAsNewInput, next: Next<this, 'continueAsNew'>) => Promise<never>;
+
+  /**
+   * Called when Workflow signals a child or external Workflow
+   */
+  signalWorkflow?: (input: SignalWorkflowInput, next: Next<this, 'signalWorkflow'>) => Promise<void>;
+
+  /**
+   * Called when Workflow starts a child workflow execution, the interceptor function returns 2 promises:
+   *
+   * - The first resolves with the `runId` when the child workflow has started or rejects if failed to start.
+   * - The second resolves with the workflow result when the child workflow completes or rejects on failure.
+   */
+  startChildWorkflowExecution?: (
+    input: StartChildWorkflowExecutionInput,
+    next: Next<this, 'startChildWorkflowExecution'>
+  ) => Promise<[Promise<string>, Promise<unknown>]>;
+}
+
+/** Input for WorkflowInternalsInterceptor.concludeActivation */
+export interface ConcludeActivationInput {
+  commands: coresdk.workflow_commands.IWorkflowCommand[];
+}
+
+/** Output for WorkflowInternalsInterceptor.concludeActivation */
+export type ConcludeActivationOutput = ConcludeActivationInput;
+
+/** Input for WorkflowInternalsInterceptor.activate */
+export interface ActivateInput {
+  activation: coresdk.workflow_activation.IWorkflowActivation;
+  batchIndex: number;
+}
+
+/** Input for WorkflowInternalsInterceptor.dispose */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface DisposeInput {}
+
+/**
+ * Interceptor for the internals of the Workflow runtime.
+ *
+ * Use to manipulate or trace Workflow activations.
+ *
+ * @experimental
+ */
+export interface WorkflowInternalsInterceptor {
+  /**
+   * Called when the Workflow runtime runs a WorkflowActivationJob.
+   */
+  activate?(input: ActivateInput, next: Next<this, 'activate'>): void;
+
+  /**
+   * Called after all `WorkflowActivationJob`s have been processed for an activation.
+   *
+   * Can manipulate the commands generated by the Workflow
+   */
+  concludeActivation?(input: ConcludeActivationInput, next: Next<this, 'concludeActivation'>): ConcludeActivationOutput;
+
+  /**
+   * Called before disposing the Workflow isolate context.
+   *
+   * Implement this method to perform any resource cleanup.
+   */
+  dispose?(input: DisposeInput, next: Next<this, 'dispose'>): Promise<void>;
+}
+
+/**
+ * A mapping from interceptor type to an optional list of interceptor implementations
+ */
+export interface WorkflowInterceptors {
+  inbound?: WorkflowInboundCallsInterceptor[];
+  outbound?: WorkflowOutboundCallsInterceptor[];
+  internals?: WorkflowInternalsInterceptor[];
+}
+
+/**
+ * A function that returns {@link WorkflowInterceptors} and takes no arguments.
+ *
+ * Workflow interceptor modules should export an `interceptors` function of this type.
+ *
+ * @example
+ *
+ * ```ts
+ * export function interceptors(): WorkflowInterceptors {
+ *   return {
+ *     inbound: [],   // Populate with list of interceptor implementations
+ *     outbound: [],  // Populate with list of interceptor implementations
+ *     internals: [], // Populate with list of interceptor implementations
+ *   };
+ * }
+ * ```
+ */
+export type WorkflowInterceptorsFactory = () => WorkflowInterceptors;