@incodetech/core 0.0.0-dev-20260409-a38d5e8 → 0.0.0-dev-20260409-09dfd52

package/dist/workflow.d.ts

@@ -0,0 +1,813 @@
+import { t as Manager } from "./Manager-DcPMRgTm.js";
+import { t as AnyStateMachine } from "./StateMachine-BBuIgsHT.js";
+import { n as GetFinishStatusFn, t as FinishStatus } from "./flowCompletionService-gxt5reFV.js";
+import { i as WorkflowModuleRegistry, n as RunChildModuleEvent, r as RunChildModuleInput } from "./types-CjsEZRcz.js";
+import * as xstate131 from "xstate";
+
+//#region src/modules/workflow/types.d.ts
+/** Possible node types returned by the workflow server. */
+type WorkflowNodeType = 'MODULE' | 'FINISH' | 'ASYNC_RESOLUTION';
+/** A workflow node returned by the server, representing a single step in the workflow. */
+type WorkflowNode = {
+  /** Unique node identifier */
+  id: string;
+  /** The type of node: MODULE (run a module), FINISH (workflow done), or ASYNC_RESOLUTION (server processing async) */
+  nodeType: WorkflowNodeType;
+  /** The module key (e.g., 'PHONE', 'SELFIE', 'CUSTOM_MODULE') */
+  moduleKey: string;
+  /** Server-provided configuration for this module step */
+  moduleConfiguration: Record<string, unknown>;
+  /** Node status from the server */
+  status: string;
+  /** The workflow ID this node belongs to */
+  workflowId: string;
+};
+/** Workflow configuration returned by GET /omni/workflow/info. */
+type WorkflowConfig = {
+  /** Workflow identifier */
+  id: string;
+  /** Workflow name */
+  name: string;
+  /** Whether desktop users should be redirected to mobile */
+  redirectDesktopToMobile: boolean;
+  /** Whether to hide the SMS option in redirect screen */
+  disableSmsOption?: boolean;
+  /** Whether to show "Continue on Desktop" option */
+  addContinueToDesktop?: boolean;
+  /** Whether QR phishing resistance is enabled */
+  qrPhishingResistance?: boolean;
+  /** Whether to disable the unsupported browser screen */
+  disableUnsupportedBrowserScreen?: boolean;
+  /** Whether OAuth2 is secured */
+  oauth2Secured?: boolean;
+  /** Whether digital signature (deepsight) is enabled */
+  ds?: boolean;
+  /** Whether to merge recordings across document sides (ID capture) */
+  mergeSessionRecordings?: boolean;
+  /** Whether age estimation is enabled (ID capture, Selfie) */
+  ageAssurance?: boolean;
+};
+/**
+ * Consumer-provided callback for handling custom workflow modules.
+ * Called when the workflow reaches a CUSTOM_MODULE node.
+ * The consumer must call either `onSuccess` or `onError` to advance the workflow.
+ */
+type CustomModuleCallback = (data: {
+  /** Call when the custom module succeeds. Advances the workflow. */
+  onSuccess: (message?: string) => void;
+  /** Call when the custom module fails. Still advances the workflow (matching SDK 1 behavior). */
+  onError: (message?: string) => void;
+  /** The session's interview ID */
+  interviewId: string;
+  /** The node ID of the custom module */
+  nodeId: string;
+  /** The callback name configured in the workflow dashboard */
+  name: string;
+}) => void;
+//#endregion
+//#region src/modules/workflow/workflowManager.d.ts
+type WorkflowIdleState = {
+  status: 'idle';
+};
+type WorkflowLoadingState = {
+  status: 'loading';
+};
+type WorkflowReadyState = {
+  status: 'ready';
+  workflowConfig: WorkflowConfig;
+  currentNode: WorkflowNode;
+  config: Record<string, unknown>;
+  moduleState: unknown;
+};
+type WorkflowFinishedState = {
+  status: 'finished';
+  workflowConfig: WorkflowConfig;
+  finishStatus: FinishStatus;
+};
+type WorkflowAsyncResolutionState = {
+  status: 'asyncResolution';
+  workflowConfig: WorkflowConfig;
+  currentNode: WorkflowNode;
+};
+type WorkflowClosedState = {
+  status: 'closed';
+};
+type WorkflowErrorState = {
+  status: 'error';
+  error: string;
+  errorCode?: number;
+};
+type WorkflowState = WorkflowIdleState | WorkflowLoadingState | WorkflowReadyState | WorkflowFinishedState | WorkflowAsyncResolutionState | WorkflowClosedState | WorkflowErrorState;
+type CreateWorkflowManagerOptions = {
+  /** Optional consumer callback for custom workflow modules. */
+  customModuleCallback?: CustomModuleCallback;
+  /** Interview ID from the session. Required for custom module processing. */
+  interviewId?: string;
+  /** Whether the device is a desktop. Determines desktop-to-mobile redirect injection. Defaults to true. */
+  isDesktop?: boolean;
+};
+/**
+ * Creates a workflow manager for server-driven onboarding flows.
+ *
+ * Only one orchestrator (Flow or Workflow) should be active per session.
+ * Each session token maps to a single orchestrator run. To start a new
+ * workflow, create a new session and call `setup()` with the new token
+ * before creating a new manager.
+ */
+declare function createWorkflowManager(options?: CreateWorkflowManagerOptions): Manager<WorkflowState> & {
+  /** Start loading the workflow configuration and first node from the backend. */
+  load(): void;
+  /**
+   * Signal that the current module has completed successfully.
+   * Call this from your UI component's `onFinish` callback.
+   */
+  completeModule(): void;
+  /**
+   * Skip all remaining modules and go straight to the completion step.
+   * Used when the workflow was completed externally (e.g., via redirect to mobile).
+   */
+  completeFlow(): void;
+  /**
+   * Signal that the current module encountered an error.
+   * Transitions the workflow to a terminal error state.
+   */
+  errorModule(error: string): void;
+  /** Get the current module's configuration, including the `ds` flag from the workflow config. */
+  getModuleConfig<T$1 = Record<string, unknown>>(): T$1 | undefined;
+};
+type WorkflowManager = ReturnType<typeof createWorkflowManager>;
+//#endregion
+//#region src/modules/workflow/workflowActors.d.ts
+type LoadWorkflowInput = {
+  isDesktop: boolean;
+};
+type LoadingResult = {
+  workflowConfig: WorkflowConfig;
+  currentNode: WorkflowNode;
+  firstNode: WorkflowNode | undefined;
+  isInjectedNode: boolean;
+};
+type ProcessNextNodeInput = {
+  isInjectedNode: boolean;
+  firstNode: WorkflowNode | undefined;
+  currentNodeModuleKey: string | undefined;
+  workflowConfigId: string | undefined;
+  workflowRedirectDesktopToMobile: boolean;
+  workflowDisableSmsOption: boolean;
+  workflowAddContinueToDesktop: boolean;
+  workflowQrPhishingResistance: boolean;
+  isDesktop: boolean;
+};
+type ProcessingResult = {
+  nextNode: WorkflowNode;
+  isInjectedNode: boolean;
+};
+type HandleCustomModuleInput = {
+  currentNode: WorkflowNode;
+  interviewId: string;
+  customModuleCallback: CustomModuleCallback | undefined;
+};
+type ResolveModuleInput = {
+  moduleKey: string;
+  registeredModules: WorkflowModuleRegistry;
+};
+//#endregion
+//#region src/modules/workflow/workflowStateMachine.d.ts
+type WorkflowContext = {
+  workflowConfig: WorkflowConfig | undefined;
+  currentNode: WorkflowNode | undefined;
+  firstNode: WorkflowNode | undefined;
+  resolvedMachine: AnyStateMachine | undefined;
+  error: string | undefined;
+  errorCode: number | undefined;
+  registeredModules: WorkflowModuleRegistry;
+  finishStatus: FinishStatus | undefined;
+  customModuleCallback: CustomModuleCallback | undefined;
+  interviewId: string;
+  isDesktop: boolean;
+  isInjectedNode: boolean;
+  getFinishStatus: GetFinishStatusFn;
+};
+type WorkflowInput = {
+  modules: WorkflowModuleRegistry;
+  customModuleCallback?: CustomModuleCallback;
+  getFinishStatus?: GetFinishStatusFn;
+  /** Interview ID from the session. Required for custom module processing. */
+  interviewId?: string;
+  /** Whether the device is a desktop. Determines desktop-to-mobile redirect injection. Defaults to true. */
+  isDesktop?: boolean;
+};
+declare const workflowMachine: xstate131.StateMachine<WorkflowContext, {
+  type: "LOAD";
+} | {
+  type: "MODULE_COMPLETE";
+} | {
+  type: "MODULE_ERROR";
+  error: unknown;
+} | {
+  type: "COMPLETE_FLOW";
+}, {
+  [x: string]: xstate131.ActorRefFromLogic<xstate131.CallbackActorLogic<RunChildModuleEvent, RunChildModuleInput, xstate131.EventObject>> | xstate131.ActorRefFromLogic<xstate131.PromiseActorLogic<LoadingResult, LoadWorkflowInput, xstate131.EventObject>> | xstate131.ActorRefFromLogic<xstate131.PromiseActorLogic<ProcessingResult, ProcessNextNodeInput, xstate131.EventObject>> | xstate131.ActorRefFromLogic<xstate131.PromiseActorLogic<WorkflowNode, HandleCustomModuleInput, xstate131.EventObject>> | xstate131.ActorRefFromLogic<xstate131.PromiseActorLogic<AnyStateMachine, ResolveModuleInput, xstate131.EventObject>> | xstate131.ActorRefFromLogic<xstate131.PromiseActorLogic<FinishStatus, {
+    getFinishStatus: GetFinishStatusFn;
+    workflowId: string | undefined;
+  }, xstate131.EventObject>> | undefined;
+}, xstate131.Values<{
+  runChildModule: {
+    src: "runChildModule";
+    logic: xstate131.CallbackActorLogic<RunChildModuleEvent, RunChildModuleInput, xstate131.EventObject>;
+    id: string | undefined;
+  };
+  loadWorkflow: {
+    src: "loadWorkflow";
+    logic: xstate131.PromiseActorLogic<LoadingResult, LoadWorkflowInput, xstate131.EventObject>;
+    id: string | undefined;
+  };
+  processNextNode: {
+    src: "processNextNode";
+    logic: xstate131.PromiseActorLogic<ProcessingResult, ProcessNextNodeInput, xstate131.EventObject>;
+    id: string | undefined;
+  };
+  handleCustomModule: {
+    src: "handleCustomModule";
+    logic: xstate131.PromiseActorLogic<WorkflowNode, HandleCustomModuleInput, xstate131.EventObject>;
+    id: string | undefined;
+  };
+  resolveModule: {
+    src: "resolveModule";
+    logic: xstate131.PromiseActorLogic<AnyStateMachine, ResolveModuleInput, xstate131.EventObject>;
+    id: string | undefined;
+  };
+  notifyBackend: {
+    src: "notifyBackend";
+    logic: xstate131.PromiseActorLogic<FinishStatus, {
+      getFinishStatus: GetFinishStatusFn;
+      workflowId: string | undefined;
+    }, xstate131.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate131.Values<{
+  setError: {
+    type: "setError";
+    params: xstate131.NonReducibleUnknown;
+  };
+  setLoadingResult: {
+    type: "setLoadingResult";
+    params: xstate131.NonReducibleUnknown;
+  };
+  setNextNode: {
+    type: "setNextNode";
+    params: xstate131.NonReducibleUnknown;
+  };
+  setCustomModuleResult: {
+    type: "setCustomModuleResult";
+    params: xstate131.NonReducibleUnknown;
+  };
+  setResolvedMachine: {
+    type: "setResolvedMachine";
+    params: xstate131.NonReducibleUnknown;
+  };
+  setFinishStatus: {
+    type: "setFinishStatus";
+    params: xstate131.NonReducibleUnknown;
+  };
+  setModuleError: {
+    type: "setModuleError";
+    params: xstate131.NonReducibleUnknown;
+  };
+}>, xstate131.Values<{
+  isModuleNode: {
+    type: "isModuleNode";
+    params: unknown;
+  };
+  isFinishNode: {
+    type: "isFinishNode";
+    params: unknown;
+  };
+  isAsyncResolutionNode: {
+    type: "isAsyncResolutionNode";
+    params: unknown;
+  };
+  isCustomModule: {
+    type: "isCustomModule";
+    params: unknown;
+  };
+}>, never, "error" | "idle" | "closed" | "finished" | "loading" | "resolvingModule" | "completing" | "asyncResolution" | "handlingCustomModule" | "runningModule" | "processingNode", string, WorkflowInput, xstate131.NonReducibleUnknown, xstate131.EventObject, xstate131.MetaObject, {
+  readonly id: "workflow";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "runChildModule" | "loadWorkflow" | "processNextNode" | "handleCustomModule" | "resolveModule" | "notifyBackend">(logic: TSrc, ...[options]: ({
+        src: "runChildModule";
+        logic: xstate131.CallbackActorLogic<RunChildModuleEvent, RunChildModuleInput, xstate131.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "runChildModule";
+        logic: xstate131.CallbackActorLogic<RunChildModuleEvent, RunChildModuleInput, xstate131.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate131.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate131.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate131.RequiredActorOptions<T>]: unknown }) | undefined], xstate131.IsNotNever<xstate131.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "loadWorkflow";
+        logic: xstate131.PromiseActorLogic<LoadingResult, LoadWorkflowInput, xstate131.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "loadWorkflow";
+        logic: xstate131.PromiseActorLogic<LoadingResult, LoadWorkflowInput, xstate131.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate131.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate131.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate131.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate131.IsNotNever<xstate131.RequiredActorOptions<T_1>>> : never : never : never) | ({
+        src: "processNextNode";
+        logic: xstate131.PromiseActorLogic<ProcessingResult, ProcessNextNodeInput, xstate131.EventObject>;
+        id: string | undefined;
+      } extends infer T_2 ? T_2 extends {
+        src: "processNextNode";
+        logic: xstate131.PromiseActorLogic<ProcessingResult, ProcessNextNodeInput, xstate131.EventObject>;
+        id: string | undefined;
+      } ? T_2 extends {
+        src: TSrc;
+      } ? xstate131.ConditionalRequired<[options?: ({
+        id?: T_2["id"] | undefined;
+        systemId?: string;
+        input?: xstate131.InputFrom<T_2["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_2 in xstate131.RequiredActorOptions<T_2>]: unknown }) | undefined], xstate131.IsNotNever<xstate131.RequiredActorOptions<T_2>>> : never : never : never) | ({
+        src: "handleCustomModule";
+        logic: xstate131.PromiseActorLogic<WorkflowNode, HandleCustomModuleInput, xstate131.EventObject>;
+        id: string | undefined;
+      } extends infer T_3 ? T_3 extends {
+        src: "handleCustomModule";
+        logic: xstate131.PromiseActorLogic<WorkflowNode, HandleCustomModuleInput, xstate131.EventObject>;
+        id: string | undefined;
+      } ? T_3 extends {
+        src: TSrc;
+      } ? xstate131.ConditionalRequired<[options?: ({
+        id?: T_3["id"] | undefined;
+        systemId?: string;
+        input?: xstate131.InputFrom<T_3["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_3 in xstate131.RequiredActorOptions<T_3>]: unknown }) | undefined], xstate131.IsNotNever<xstate131.RequiredActorOptions<T_3>>> : never : never : never) | ({
+        src: "resolveModule";
+        logic: xstate131.PromiseActorLogic<AnyStateMachine, ResolveModuleInput, xstate131.EventObject>;
+        id: string | undefined;
+      } extends infer T_4 ? T_4 extends {
+        src: "resolveModule";
+        logic: xstate131.PromiseActorLogic<AnyStateMachine, ResolveModuleInput, xstate131.EventObject>;
+        id: string | undefined;
+      } ? T_4 extends {
+        src: TSrc;
+      } ? xstate131.ConditionalRequired<[options?: ({
+        id?: T_4["id"] | undefined;
+        systemId?: string;
+        input?: xstate131.InputFrom<T_4["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_4 in xstate131.RequiredActorOptions<T_4>]: unknown }) | undefined], xstate131.IsNotNever<xstate131.RequiredActorOptions<T_4>>> : never : never : never) | ({
+        src: "notifyBackend";
+        logic: xstate131.PromiseActorLogic<FinishStatus, {
+          getFinishStatus: GetFinishStatusFn;
+          workflowId: string | undefined;
+        }, xstate131.EventObject>;
+        id: string | undefined;
+      } extends infer T_5 ? T_5 extends {
+        src: "notifyBackend";
+        logic: xstate131.PromiseActorLogic<FinishStatus, {
+          getFinishStatus: GetFinishStatusFn;
+          workflowId: string | undefined;
+        }, xstate131.EventObject>;
+        id: string | undefined;
+      } ? T_5 extends {
+        src: TSrc;
+      } ? xstate131.ConditionalRequired<[options?: ({
+        id?: T_5["id"] | undefined;
+        systemId?: string;
+        input?: xstate131.InputFrom<T_5["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_5 in xstate131.RequiredActorOptions<T_5>]: unknown }) | undefined], xstate131.IsNotNever<xstate131.RequiredActorOptions<T_5>>> : never : never : never)): xstate131.ActorRefFromLogic<xstate131.GetConcreteByKey<xstate131.Values<{
+        runChildModule: {
+          src: "runChildModule";
+          logic: xstate131.CallbackActorLogic<RunChildModuleEvent, RunChildModuleInput, xstate131.EventObject>;
+          id: string | undefined;
+        };
+        loadWorkflow: {
+          src: "loadWorkflow";
+          logic: xstate131.PromiseActorLogic<LoadingResult, LoadWorkflowInput, xstate131.EventObject>;
+          id: string | undefined;
+        };
+        processNextNode: {
+          src: "processNextNode";
+          logic: xstate131.PromiseActorLogic<ProcessingResult, ProcessNextNodeInput, xstate131.EventObject>;
+          id: string | undefined;
+        };
+        handleCustomModule: {
+          src: "handleCustomModule";
+          logic: xstate131.PromiseActorLogic<WorkflowNode, HandleCustomModuleInput, xstate131.EventObject>;
+          id: string | undefined;
+        };
+        resolveModule: {
+          src: "resolveModule";
+          logic: xstate131.PromiseActorLogic<AnyStateMachine, ResolveModuleInput, xstate131.EventObject>;
+          id: string | undefined;
+        };
+        notifyBackend: {
+          src: "notifyBackend";
+          logic: xstate131.PromiseActorLogic<FinishStatus, {
+            getFinishStatus: GetFinishStatusFn;
+            workflowId: string | undefined;
+          }, xstate131.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate131.AnyActorLogic>(src: TLogic, ...[options]: xstate131.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate131.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate131.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate131.IsNotNever<xstate131.RequiredLogicInput<TLogic>>>): xstate131.ActorRefFromLogic<TLogic>;
+    };
+    input: WorkflowInput;
+    self: xstate131.ActorRef<xstate131.MachineSnapshot<WorkflowContext, {
+      type: "LOAD";
+    } | {
+      type: "MODULE_COMPLETE";
+    } | {
+      type: "MODULE_ERROR";
+      error: unknown;
+    } | {
+      type: "COMPLETE_FLOW";
+    }, Record<string, xstate131.AnyActorRef | undefined>, xstate131.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "MODULE_COMPLETE";
+    } | {
+      type: "MODULE_ERROR";
+      error: unknown;
+    } | {
+      type: "COMPLETE_FLOW";
+    }, xstate131.AnyEventObject>;
+  }) => {
+    workflowConfig: undefined;
+    currentNode: undefined;
+    firstNode: undefined;
+    resolvedMachine: undefined;
+    error: undefined;
+    errorCode: undefined;
+    registeredModules: WorkflowModuleRegistry;
+    finishStatus: undefined;
+    customModuleCallback: CustomModuleCallback | undefined;
+    interviewId: string;
+    isDesktop: boolean;
+    isInjectedNode: false;
+    getFinishStatus: GetFinishStatusFn;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: "loading";
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly id: "loadWorkflow";
+        readonly src: "loadWorkflow";
+        readonly input: ({
+          context
+        }: {
+          context: WorkflowContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          };
+          self: xstate131.ActorRef<xstate131.MachineSnapshot<WorkflowContext, {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          }, Record<string, xstate131.AnyActorRef>, xstate131.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          }, xstate131.AnyEventObject>;
+        }) => {
+          isDesktop: boolean;
+        };
+        readonly onDone: readonly [{
+          readonly target: "resolvingModule";
+          readonly guard: "isModuleNode";
+          readonly actions: "setLoadingResult";
+        }, {
+          readonly target: "completing";
+          readonly guard: "isFinishNode";
+          readonly actions: "setLoadingResult";
+        }, {
+          readonly target: "asyncResolution";
+          readonly guard: "isAsyncResolutionNode";
+          readonly actions: "setLoadingResult";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly resolvingModule: {
+      readonly always: readonly [{
+        readonly target: "handlingCustomModule";
+        readonly guard: "isCustomModule";
+      }];
+      readonly invoke: {
+        readonly id: "resolveModule";
+        readonly src: "resolveModule";
+        readonly input: ({
+          context
+        }: {
+          context: WorkflowContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          };
+          self: xstate131.ActorRef<xstate131.MachineSnapshot<WorkflowContext, {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          }, Record<string, xstate131.AnyActorRef>, xstate131.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          }, xstate131.AnyEventObject>;
+        }) => {
+          moduleKey: string;
+          registeredModules: WorkflowModuleRegistry;
+        };
+        readonly onDone: {
+          readonly target: "runningModule";
+          readonly actions: "setResolvedMachine";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly runningModule: {
+      readonly invoke: {
+        readonly id: "currentModule";
+        readonly src: "runChildModule";
+        readonly input: ({
+          context
+        }: {
+          context: WorkflowContext;
+        }) => {
+          machine: AnyStateMachine | undefined;
+          config: {
+            ds: boolean | undefined;
+          };
+        };
+      };
+      readonly on: {
+        readonly MODULE_COMPLETE: "processingNode";
+        readonly MODULE_ERROR: {
+          readonly target: "error";
+          readonly actions: "setModuleError";
+        };
+        readonly COMPLETE_FLOW: "completing";
+      };
+    };
+    readonly handlingCustomModule: {
+      readonly invoke: {
+        readonly id: "customModule";
+        readonly src: "handleCustomModule";
+        readonly input: ({
+          context
+        }: {
+          context: WorkflowContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          };
+          self: xstate131.ActorRef<xstate131.MachineSnapshot<WorkflowContext, {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          }, Record<string, xstate131.AnyActorRef>, xstate131.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          }, xstate131.AnyEventObject>;
+        }) => {
+          currentNode: WorkflowNode;
+          interviewId: string;
+          customModuleCallback: CustomModuleCallback | undefined;
+        };
+        readonly onDone: readonly [{
+          readonly target: "resolvingModule";
+          readonly guard: "isModuleNode";
+          readonly actions: "setCustomModuleResult";
+        }, {
+          readonly target: "completing";
+          readonly guard: "isFinishNode";
+          readonly actions: "setCustomModuleResult";
+        }, {
+          readonly target: "asyncResolution";
+          readonly guard: "isAsyncResolutionNode";
+          readonly actions: "setCustomModuleResult";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly processingNode: {
+      readonly invoke: {
+        readonly id: "processNext";
+        readonly src: "processNextNode";
+        readonly input: ({
+          context
+        }: {
+          context: WorkflowContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          };
+          self: xstate131.ActorRef<xstate131.MachineSnapshot<WorkflowContext, {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          }, Record<string, xstate131.AnyActorRef>, xstate131.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          }, xstate131.AnyEventObject>;
+        }) => {
+          isInjectedNode: boolean;
+          firstNode: WorkflowNode | undefined;
+          currentNodeModuleKey: string | undefined;
+          workflowConfigId: string | undefined;
+          workflowRedirectDesktopToMobile: boolean;
+          workflowDisableSmsOption: boolean;
+          workflowAddContinueToDesktop: boolean;
+          workflowQrPhishingResistance: boolean;
+          isDesktop: boolean;
+        };
+        readonly onDone: readonly [{
+          readonly target: "resolvingModule";
+          readonly guard: "isModuleNode";
+          readonly actions: "setNextNode";
+          readonly reenter: true;
+        }, {
+          readonly target: "completing";
+          readonly guard: "isFinishNode";
+          readonly actions: "setNextNode";
+        }, {
+          readonly target: "asyncResolution";
+          readonly guard: "isAsyncResolutionNode";
+          readonly actions: "setNextNode";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly completing: {
+      readonly invoke: {
+        readonly id: "notifyBackend";
+        readonly src: "notifyBackend";
+        readonly input: ({
+          context
+        }: {
+          context: WorkflowContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          };
+          self: xstate131.ActorRef<xstate131.MachineSnapshot<WorkflowContext, {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          }, Record<string, xstate131.AnyActorRef>, xstate131.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "MODULE_COMPLETE";
+          } | {
+            type: "MODULE_ERROR";
+            error: unknown;
+          } | {
+            type: "COMPLETE_FLOW";
+          }, xstate131.AnyEventObject>;
+        }) => {
+          getFinishStatus: GetFinishStatusFn;
+          workflowId: string | undefined;
+        };
+        readonly onDone: {
+          readonly target: "finished";
+          readonly actions: "setFinishStatus";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly asyncResolution: {
+      readonly type: "final";
+    };
+    readonly closed: {
+      readonly type: "final";
+    };
+    readonly error: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+export { type CreateWorkflowManagerOptions, type CustomModuleCallback, type WorkflowConfig, type WorkflowFinishedState, type WorkflowManager, type WorkflowNode, type WorkflowReadyState, type WorkflowState, createWorkflowManager, workflowMachine };