@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/electronicSignatureManager-Ds-KEVTq.d.ts

@@ -0,0 +1,2786 @@
+import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, d as DoneActorEvent, f as ErrorActorEvent, g as IsNotNever, h as InputFrom, i as ActorRefFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, t as ActionFunction, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+import { _ as QesTermsResponse, a as ElectronicSignatureConfig, c as ElectronicSignatureFileDataHolder, d as ElectronicSignatureVariant, i as ConsentKey, l as ElectronicSignatureInput, o as ElectronicSignatureContext, r as ConsentChecks, s as ElectronicSignatureDocument, u as ElectronicSignatureProviderTerms, v as SignedDocument, y as UnsignedDocsResponse } from "./types-D0gekt4U.js";
+//#region src/modules/electronic-signature/electronicSignatureStateMachine.d.ts
+declare const electronicSignatureMachine: StateMachine<ElectronicSignatureContext, {
+  type: "LOAD";
+} | {
+  type: "SELECT_FILE";
+  fileName: string;
+  fileSize: number;
+  fileUrl: string;
+} | {
+  type: "REPLACE_FILE";
+} | {
+  type: "CONFIRM_FILE";
+} | {
+  type: "SET_CONSENT";
+  name: ConsentKey;
+  checked: boolean;
+} | {
+  type: "VIEW_DOCUMENT";
+  url: string;
+} | {
+  type: "CLOSE_DOCUMENT_VIEW";
+} | {
+  type: "VIEW_APPLICATION_FORM";
+} | {
+  type: "CLOSE_APPLICATION_FORM";
+} | {
+  type: "SIGN";
+} | {
+  type: "FINISH";
+} | {
+  type: "RETRY";
+} | {
+  type: "CLOSE";
+}, {
+  [x: string]: ActorRefFromLogic<PromiseActorLogic<QesTermsResponse, {
+    languageCode: string;
+  }, EventObject>> | ActorRefFromLogic<PromiseActorLogic<UnsignedDocsResponse, void, EventObject>> | ActorRefFromLogic<PromiseActorLogic<SignedDocument[], {
+    documents: ElectronicSignatureDocument[];
+    sequential: boolean;
+    variant: ElectronicSignatureVariant;
+  }, EventObject>> | ActorRefFromLogic<PromiseActorLogic<{
+    preSignedUrl: string;
+  }, void, EventObject>> | ActorRefFromLogic<PromiseActorLogic<void, {
+    preSignedUrl: string;
+    fileDataHolder: ElectronicSignatureFileDataHolder;
+  }, EventObject>> | undefined;
+}, Values<{
+  fetchQesTerms: {
+    src: "fetchQesTerms";
+    logic: PromiseActorLogic<QesTermsResponse, {
+      languageCode: string;
+    }, EventObject>;
+    id: string | undefined;
+  };
+  fetchSignedDocs: {
+    src: "fetchSignedDocs";
+    logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+    id: string | undefined;
+  };
+  fetchUnsignedDocs: {
+    src: "fetchUnsignedDocs";
+    logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+    id: string | undefined;
+  };
+  signDocuments: {
+    src: "signDocuments";
+    logic: PromiseActorLogic<SignedDocument[], {
+      documents: ElectronicSignatureDocument[];
+      sequential: boolean;
+      variant: ElectronicSignatureVariant;
+    }, EventObject>;
+    id: string | undefined;
+  };
+  generateUploadUrl: {
+    src: "generateUploadUrl";
+    logic: PromiseActorLogic<{
+      preSignedUrl: string;
+    }, void, EventObject>;
+    id: string | undefined;
+  };
+  uploadFile: {
+    src: "uploadFile";
+    logic: PromiseActorLogic<void, {
+      preSignedUrl: string;
+      fileDataHolder: ElectronicSignatureFileDataHolder;
+    }, EventObject>;
+    id: string | undefined;
+  };
+}>, Values<{
+  setDocuments: {
+    type: "setDocuments";
+    params: NonReducibleUnknown;
+  };
+  setSignedDocuments: {
+    type: "setSignedDocuments";
+    params: NonReducibleUnknown;
+  };
+  setSignedDocumentsFromResponse: {
+    type: "setSignedDocumentsFromResponse";
+    params: NonReducibleUnknown;
+  };
+  setProviderTerms: {
+    type: "setProviderTerms";
+    params: NonReducibleUnknown;
+  };
+  setFile: {
+    type: "setFile";
+    params: NonReducibleUnknown;
+  };
+  setUploadUrl: {
+    type: "setUploadUrl";
+    params: NonReducibleUnknown;
+  };
+  updateConsent: {
+    type: "updateConsent";
+    params: NonReducibleUnknown;
+  };
+  setViewingDocument: {
+    type: "setViewingDocument";
+    params: NonReducibleUnknown;
+  };
+  clearViewingDocument: {
+    type: "clearViewingDocument";
+    params: NonReducibleUnknown;
+  };
+  showApplicationForm: {
+    type: "showApplicationForm";
+    params: NonReducibleUnknown;
+  };
+  hideApplicationForm: {
+    type: "hideApplicationForm";
+    params: NonReducibleUnknown;
+  };
+}>, Values<{
+  errorFromUpload: {
+    type: "errorFromUpload";
+    params: unknown;
+  };
+  errorFromTerms: {
+    type: "errorFromTerms";
+    params: unknown;
+  };
+  errorFromSigning: {
+    type: "errorFromSigning";
+    params: unknown;
+  };
+  errorFromSignedDocs: {
+    type: "errorFromSignedDocs";
+    params: unknown;
+  };
+  shouldUpload: {
+    type: "shouldUpload";
+    params: unknown;
+  };
+  shouldFetchProviderTerms: {
+    type: "shouldFetchProviderTerms";
+    params: unknown;
+  };
+  hasProviderTerms: {
+    type: "hasProviderTerms";
+    params: unknown;
+  };
+  hasUploadUrl: {
+    type: "hasUploadUrl";
+    params: unknown;
+  };
+  allConsented: {
+    type: "allConsented";
+    params: unknown;
+  };
+  hasDocuments: {
+    type: "hasDocuments";
+    params: unknown;
+  };
+  hasSignedDocuments: {
+    type: "hasSignedDocuments";
+    params: unknown;
+  };
+  hasSignedDocumentsAndDownload: {
+    type: "hasSignedDocumentsAndDownload";
+    params: unknown;
+  };
+  hasValidProviderTerms: {
+    type: "hasValidProviderTerms";
+    params: unknown;
+  };
+  isProviderTermsFlow: {
+    type: "isProviderTermsFlow";
+    params: unknown;
+  };
+  isRetryableProviderFailure: {
+    type: "isRetryableProviderFailure";
+    params: unknown;
+  };
+  allSigned: {
+    type: "allSigned";
+    params: unknown;
+  };
+  allSignedAndProviderTerms: {
+    type: "allSignedAndProviderTerms";
+    params: unknown;
+  };
+  allSignedAndDownload: {
+    type: "allSignedAndDownload";
+    params: unknown;
+  };
+}>, never, "error" | "signing" | "idle" | "uploading" | "fetchingTerms" | "fetchingDocs" | "reviewing" | "closed" | "uploadingFile" | "generatingUploadUrl" | "signError" | "processing" | "fetchingSignedDocs" | "successDownload" | "success" | "finished", string, {
+  config: ElectronicSignatureConfig;
+  fileDataHolder: ElectronicSignatureFileDataHolder;
+  getFileData?: never;
+} | {
+  config: ElectronicSignatureConfig;
+  getFileData: () => ArrayBuffer | null;
+  fileDataHolder?: never;
+}, NonReducibleUnknown, EventObject, MetaObject, {
+  readonly id: "electronicSignature";
+  readonly initial: "idle";
+  readonly context: ({ input }: {
+    spawn: {
+      <TSrc extends "fetchQesTerms" | "fetchSignedDocs" | "fetchUnsignedDocs" | "signDocuments" | "generateUploadUrl" | "uploadFile">(logic: TSrc, ...[options]: ({
+        src: "fetchQesTerms";
+        logic: PromiseActorLogic<QesTermsResponse, {
+          languageCode: string;
+        }, EventObject>;
+        id: string | undefined;
+      } extends (infer T) ? T extends {
+        src: "fetchQesTerms";
+        logic: PromiseActorLogic<QesTermsResponse, {
+          languageCode: string;
+        }, EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "fetchSignedDocs";
+        logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+        id: string | undefined;
+      } extends (infer T_1) ? T_1 extends {
+        src: "fetchSignedDocs";
+        logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never) | ({
+        src: "fetchUnsignedDocs";
+        logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+        id: string | undefined;
+      } extends (infer T_2) ? T_2 extends {
+        src: "fetchUnsignedDocs";
+        logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+        id: string | undefined;
+      } ? T_2 extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T_2["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T_2["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_2 in RequiredActorOptions<T_2>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_2>>> : never : never : never) | ({
+        src: "signDocuments";
+        logic: PromiseActorLogic<SignedDocument[], {
+          documents: ElectronicSignatureDocument[];
+          sequential: boolean;
+          variant: ElectronicSignatureVariant;
+        }, EventObject>;
+        id: string | undefined;
+      } extends (infer T_3) ? T_3 extends {
+        src: "signDocuments";
+        logic: PromiseActorLogic<SignedDocument[], {
+          documents: ElectronicSignatureDocument[];
+          sequential: boolean;
+          variant: ElectronicSignatureVariant;
+        }, EventObject>;
+        id: string | undefined;
+      } ? T_3 extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T_3["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T_3["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_3 in RequiredActorOptions<T_3>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_3>>> : never : never : never) | ({
+        src: "generateUploadUrl";
+        logic: PromiseActorLogic<{
+          preSignedUrl: string;
+        }, void, EventObject>;
+        id: string | undefined;
+      } extends (infer T_4) ? T_4 extends {
+        src: "generateUploadUrl";
+        logic: PromiseActorLogic<{
+          preSignedUrl: string;
+        }, void, EventObject>;
+        id: string | undefined;
+      } ? T_4 extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T_4["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T_4["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_4 in RequiredActorOptions<T_4>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_4>>> : never : never : never) | ({
+        src: "uploadFile";
+        logic: PromiseActorLogic<void, {
+          preSignedUrl: string;
+          fileDataHolder: ElectronicSignatureFileDataHolder;
+        }, EventObject>;
+        id: string | undefined;
+      } extends (infer T_5) ? T_5 extends {
+        src: "uploadFile";
+        logic: PromiseActorLogic<void, {
+          preSignedUrl: string;
+          fileDataHolder: ElectronicSignatureFileDataHolder;
+        }, EventObject>;
+        id: string | undefined;
+      } ? T_5 extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T_5["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T_5["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_5 in RequiredActorOptions<T_5>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_5>>> : never : never : never)): ActorRefFromLogic<GetConcreteByKey<Values<{
+        fetchQesTerms: {
+          src: "fetchQesTerms";
+          logic: PromiseActorLogic<QesTermsResponse, {
+            languageCode: string;
+          }, EventObject>;
+          id: string | undefined;
+        };
+        fetchSignedDocs: {
+          src: "fetchSignedDocs";
+          logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+          id: string | undefined;
+        };
+        fetchUnsignedDocs: {
+          src: "fetchUnsignedDocs";
+          logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+          id: string | undefined;
+        };
+        signDocuments: {
+          src: "signDocuments";
+          logic: PromiseActorLogic<SignedDocument[], {
+            documents: ElectronicSignatureDocument[];
+            sequential: boolean;
+            variant: ElectronicSignatureVariant;
+          }, EventObject>;
+          id: string | undefined;
+        };
+        generateUploadUrl: {
+          src: "generateUploadUrl";
+          logic: PromiseActorLogic<{
+            preSignedUrl: string;
+          }, void, EventObject>;
+          id: string | undefined;
+        };
+        uploadFile: {
+          src: "uploadFile";
+          logic: PromiseActorLogic<void, {
+            preSignedUrl: string;
+            fileDataHolder: ElectronicSignatureFileDataHolder;
+          }, EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
+    };
+    input: {
+      config: ElectronicSignatureConfig;
+      fileDataHolder: ElectronicSignatureFileDataHolder;
+      getFileData?: never;
+    } | {
+      config: ElectronicSignatureConfig;
+      getFileData: () => ArrayBuffer | null;
+      fileDataHolder?: never;
+    };
+    self: ActorRef<MachineSnapshot<ElectronicSignatureContext, {
+      type: "LOAD";
+    } | {
+      type: "SELECT_FILE";
+      fileName: string;
+      fileSize: number;
+      fileUrl: string;
+    } | {
+      type: "REPLACE_FILE";
+    } | {
+      type: "CONFIRM_FILE";
+    } | {
+      type: "SET_CONSENT";
+      name: ConsentKey;
+      checked: boolean;
+    } | {
+      type: "VIEW_DOCUMENT";
+      url: string;
+    } | {
+      type: "CLOSE_DOCUMENT_VIEW";
+    } | {
+      type: "VIEW_APPLICATION_FORM";
+    } | {
+      type: "CLOSE_APPLICATION_FORM";
+    } | {
+      type: "SIGN";
+    } | {
+      type: "FINISH";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CLOSE";
+    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "SELECT_FILE";
+      fileName: string;
+      fileSize: number;
+      fileUrl: string;
+    } | {
+      type: "REPLACE_FILE";
+    } | {
+      type: "CONFIRM_FILE";
+    } | {
+      type: "SET_CONSENT";
+      name: ConsentKey;
+      checked: boolean;
+    } | {
+      type: "VIEW_DOCUMENT";
+      url: string;
+    } | {
+      type: "CLOSE_DOCUMENT_VIEW";
+    } | {
+      type: "VIEW_APPLICATION_FORM";
+    } | {
+      type: "CLOSE_APPLICATION_FORM";
+    } | {
+      type: "SIGN";
+    } | {
+      type: "FINISH";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CLOSE";
+    }, AnyEventObject>;
+  }) => {
+    config: ElectronicSignatureConfig;
+    fileDataHolder: ElectronicSignatureFileDataHolder;
+    documents: never[];
+    signedDocuments: never[];
+    fileName: null;
+    fileSize: null;
+    fileUrl: null;
+    preSignedUrl: null;
+    consentChecks: Partial<Record<ConsentKey, boolean>>;
+    providerTerms: null;
+    viewingDocumentUrl: null;
+    viewingApplicationForm: false;
+    errorMessage: string;
+    errorSource: null;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: readonly [{
+          readonly target: "uploading";
+          readonly guard: "shouldUpload";
+        }, {
+          readonly target: "fetchingTerms";
+          readonly guard: "shouldFetchProviderTerms";
+        }, {
+          readonly target: "fetchingDocs";
+        }];
+      };
+    };
+    readonly uploading: {
+      readonly on: {
+        readonly SELECT_FILE: {
+          readonly target: "reviewing";
+          readonly actions: "setFile";
+        };
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly reviewing: {
+      readonly on: {
+        readonly REPLACE_FILE: {
+          readonly target: "uploading";
+          readonly actions: ActionFunction<ElectronicSignatureContext, {
+            type: "REPLACE_FILE";
+          }, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        };
+        readonly CONFIRM_FILE: readonly [{
+          readonly target: "uploadingFile";
+          readonly guard: "hasUploadUrl";
+        }, {
+          readonly target: "generatingUploadUrl";
+        }];
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly generatingUploadUrl: {
+      readonly invoke: {
+        readonly id: "generateUploadUrl";
+        readonly src: "generateUploadUrl";
+        readonly onDone: {
+          readonly target: "uploadingFile";
+          readonly actions: "setUploadUrl";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        };
+      };
+    };
+    readonly uploadingFile: {
+      readonly invoke: {
+        readonly id: "uploadFile";
+        readonly src: "uploadFile";
+        readonly input: ({ context }: {
+          context: ElectronicSignatureContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          };
+          self: ActorRef<MachineSnapshot<ElectronicSignatureContext, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, AnyEventObject>;
+        }) => {
+          preSignedUrl: string;
+          fileDataHolder: ElectronicSignatureFileDataHolder;
+        };
+        readonly onDone: readonly [{
+          readonly target: "fetchingTerms";
+          readonly guard: "shouldFetchProviderTerms";
+        }, {
+          readonly target: "fetchingDocs";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        };
+      };
+    };
+    readonly fetchingTerms: {
+      readonly invoke: {
+        readonly id: "fetchQesTerms";
+        readonly src: "fetchQesTerms";
+        readonly input: ({ context }: {
+          context: ElectronicSignatureContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          };
+          self: ActorRef<MachineSnapshot<ElectronicSignatureContext, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, AnyEventObject>;
+        }) => {
+          languageCode: string;
+        };
+        readonly onDone: readonly [{
+          readonly target: "fetchingDocs";
+          readonly guard: "hasValidProviderTerms";
+          readonly actions: "setProviderTerms";
+        }, {
+          readonly target: "signError";
+          readonly actions: ActionFunction<ElectronicSignatureContext, DoneActorEvent<QesTermsResponse, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+        readonly onError: readonly [{
+          readonly target: "error";
+          readonly guard: "isRetryableProviderFailure";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "signError";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+      };
+    };
+    readonly fetchingDocs: {
+      readonly invoke: {
+        readonly id: "fetchUnsignedDocs";
+        readonly src: "fetchUnsignedDocs";
+        readonly onDone: readonly [{
+          readonly target: "signing";
+          readonly guard: "hasDocuments";
+          readonly actions: "setDocuments";
+        }, {
+          readonly target: "signError";
+          readonly guard: "isProviderTermsFlow";
+          readonly actions: ActionFunction<ElectronicSignatureContext, DoneActorEvent<UnsignedDocsResponse, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "error";
+          readonly actions: ActionFunction<ElectronicSignatureContext, DoneActorEvent<UnsignedDocsResponse, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+        readonly onError: readonly [{
+          readonly target: "error";
+          readonly guard: "isRetryableProviderFailure";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "signError";
+          readonly guard: "isProviderTermsFlow";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "error";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+      };
+    };
+    readonly signing: {
+      readonly on: {
+        readonly SET_CONSENT: {
+          readonly actions: "updateConsent";
+        };
+        readonly VIEW_DOCUMENT: {
+          readonly actions: "setViewingDocument";
+        };
+        readonly CLOSE_DOCUMENT_VIEW: {
+          readonly actions: "clearViewingDocument";
+        };
+        readonly VIEW_APPLICATION_FORM: {
+          readonly guard: "hasProviderTerms";
+          readonly actions: "showApplicationForm";
+        };
+        readonly CLOSE_APPLICATION_FORM: {
+          readonly actions: "hideApplicationForm";
+        };
+        readonly SIGN: {
+          readonly target: "processing";
+          readonly guard: "allConsented";
+        };
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly processing: {
+      readonly invoke: {
+        readonly id: "signDocuments";
+        readonly src: "signDocuments";
+        readonly input: ({ context }: {
+          context: ElectronicSignatureContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          };
+          self: ActorRef<MachineSnapshot<ElectronicSignatureContext, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, AnyEventObject>;
+        }) => {
+          documents: ElectronicSignatureDocument[];
+          sequential: boolean;
+          variant: ElectronicSignatureVariant;
+        };
+        readonly onDone: readonly [{
+          readonly target: "fetchingSignedDocs";
+          readonly guard: "allSignedAndProviderTerms";
+        }, {
+          readonly target: "successDownload";
+          readonly guard: "allSignedAndDownload";
+          readonly actions: "setSignedDocuments";
+        }, {
+          readonly target: "success";
+          readonly guard: "allSigned";
+          readonly actions: "setSignedDocuments";
+        }, {
+          readonly target: "signError";
+          readonly actions: ActionFunction<ElectronicSignatureContext, DoneActorEvent<SignedDocument[], string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+        readonly onError: readonly [{
+          readonly target: "error";
+          readonly guard: "isRetryableProviderFailure";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "signError";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+      };
+    };
+    readonly fetchingSignedDocs: {
+      readonly invoke: {
+        readonly id: "fetchSignedDocs";
+        readonly src: "fetchSignedDocs";
+        readonly onDone: readonly [{
+          readonly target: "successDownload";
+          readonly guard: "hasSignedDocumentsAndDownload";
+          readonly actions: "setSignedDocumentsFromResponse";
+        }, {
+          readonly target: "success";
+          readonly guard: "hasSignedDocuments";
+          readonly actions: "setSignedDocumentsFromResponse";
+        }, {
+          readonly target: "signError";
+          readonly actions: ActionFunction<ElectronicSignatureContext, DoneActorEvent<UnsignedDocsResponse, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+        readonly onError: readonly [{
+          readonly target: "error";
+          readonly guard: "isRetryableProviderFailure";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "signError";
+          readonly actions: ActionFunction<ElectronicSignatureContext, ErrorActorEvent<unknown, string>, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+      };
+    };
+    readonly success: {
+      readonly after: {
+        readonly 3000: "finished";
+      };
+    };
+    readonly successDownload: {
+      readonly on: {
+        readonly FINISH: {
+          readonly target: "finished";
+        };
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly signError: {
+      readonly after: {
+        readonly 3000: "finished";
+      };
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: readonly [{
+          readonly target: "uploading";
+          readonly guard: "errorFromUpload";
+          readonly actions: ActionFunction<ElectronicSignatureContext, {
+            type: "RETRY";
+          }, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "fetchingTerms";
+          readonly guard: "errorFromTerms";
+          readonly actions: ActionFunction<ElectronicSignatureContext, {
+            type: "RETRY";
+          }, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "processing";
+          readonly guard: "errorFromSigning";
+          readonly actions: ActionFunction<ElectronicSignatureContext, {
+            type: "RETRY";
+          }, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "fetchingSignedDocs";
+          readonly guard: "errorFromSignedDocs";
+          readonly actions: ActionFunction<ElectronicSignatureContext, {
+            type: "RETRY";
+          }, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "fetchingDocs";
+          readonly actions: ActionFunction<ElectronicSignatureContext, {
+            type: "RETRY";
+          }, {
+            type: "LOAD";
+          } | {
+            type: "SELECT_FILE";
+            fileName: string;
+            fileSize: number;
+            fileUrl: string;
+          } | {
+            type: "REPLACE_FILE";
+          } | {
+            type: "CONFIRM_FILE";
+          } | {
+            type: "SET_CONSENT";
+            name: ConsentKey;
+            checked: boolean;
+          } | {
+            type: "VIEW_DOCUMENT";
+            url: string;
+          } | {
+            type: "CLOSE_DOCUMENT_VIEW";
+          } | {
+            type: "VIEW_APPLICATION_FORM";
+          } | {
+            type: "CLOSE_APPLICATION_FORM";
+          } | {
+            type: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, Values<{
+            fetchQesTerms: {
+              src: "fetchQesTerms";
+              logic: PromiseActorLogic<QesTermsResponse, {
+                languageCode: string;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            fetchSignedDocs: {
+              src: "fetchSignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: PromiseActorLogic<UnsignedDocsResponse, void, EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                sequential: boolean;
+                variant: ElectronicSignatureVariant;
+              }, EventObject>;
+              id: string | undefined;
+            };
+            generateUploadUrl: {
+              src: "generateUploadUrl";
+              logic: PromiseActorLogic<{
+                preSignedUrl: string;
+              }, void, EventObject>;
+              id: string | undefined;
+            };
+            uploadFile: {
+              src: "uploadFile";
+              logic: PromiseActorLogic<void, {
+                preSignedUrl: string;
+                fileDataHolder: ElectronicSignatureFileDataHolder;
+              }, EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly closed: {
+      readonly type: "final";
+    };
+  };
+}>;
+type ElectronicSignatureMachine = typeof electronicSignatureMachine;
+//#endregion
+//#region src/modules/electronic-signature/electronicSignatureActor.d.ts
+type ElectronicSignatureActor = ActorRefFrom<ElectronicSignatureMachine>;
+type CreateElectronicSignatureActorOptions = ElectronicSignatureInput;
+//#endregion
+//#region src/modules/electronic-signature/electronicSignatureManager.d.ts
+type ElectronicSignatureLoadingState = {
+  status: 'loading';
+};
+type ElectronicSignatureUploadingState = {
+  status: 'uploading';
+  fileName: string | null;
+};
+type ElectronicSignatureReviewingState = {
+  status: 'reviewing';
+  fileName: string;
+  fileUrl: string;
+};
+type ElectronicSignatureSigningState = {
+  status: 'signing';
+  variant: ElectronicSignatureVariant;
+  documents: ElectronicSignatureDocument[];
+  consentChecks: ConsentChecks;
+  allConsented: boolean;
+  providerTerms: ElectronicSignatureProviderTerms | null;
+  viewingDocumentUrl: string | null;
+  viewingApplicationForm: boolean;
+};
+type ElectronicSignatureProcessingState = {
+  status: 'processing';
+};
+type ElectronicSignatureSuccessState = {
+  status: 'success';
+  signedDocuments: SignedDocument[];
+  downloadDocument: boolean;
+};
+/** Recoverable: SDK shows Try Again; `onError` does NOT fire. */
+type ElectronicSignatureErrorState = {
+  status: 'error';
+  errorMessage: string;
+};
+/** Signing failed: SDK shows error screen for 3s then auto-finishes. */
+type ElectronicSignatureSignErrorState = {
+  status: 'signError';
+  errorMessage: string;
+};
+type ElectronicSignatureFinishedState = {
+  status: 'finished';
+};
+type ElectronicSignatureClosedState = {
+  status: 'closed';
+};
+type ElectronicSignatureState = ElectronicSignatureLoadingState | ElectronicSignatureUploadingState | ElectronicSignatureReviewingState | ElectronicSignatureSigningState | ElectronicSignatureProcessingState | ElectronicSignatureSuccessState | ElectronicSignatureErrorState | ElectronicSignatureSignErrorState | ElectronicSignatureFinishedState | ElectronicSignatureClosedState;
+/**
+ * Creates an electronic-signature manager around a pre-built actor.
+ *
+ * The manager reads the file-data holder from the actor's input-derived
+ * context, guaranteeing that `selectFile()` and the upload actor use the same
+ * in-memory bytes. This supports actors created from `.provide()` machine
+ * variants without exposing the actor through the manager.
+ */
+declare function createElectronicSignatureManagerFromActor(actor: ElectronicSignatureActor): Manager<ElectronicSignatureState> & {
+  load(): void;
+  setConsent(name: ConsentKey, checked: boolean): void;
+  selectFile(fileName: string, fileData: ArrayBuffer, fileUrl: string): void;
+  replaceFile(): void;
+  confirmFile(): void;
+  viewDocument(url: string): void;
+  closeDocumentView(): void;
+  viewApplicationForm(): void;
+  closeApplicationForm(): void;
+  sign(): void;
+  finish(): void;
+  retry(): void;
+  close(): void;
+};
+declare function createElectronicSignatureManager(options: {
+  config: CreateElectronicSignatureActorOptions['config'];
+}): Manager<ElectronicSignatureState> & {
+  load(): void;
+  setConsent(name: ConsentKey, checked: boolean): void;
+  selectFile(fileName: string, fileData: ArrayBuffer, fileUrl: string): void;
+  replaceFile(): void;
+  confirmFile(): void;
+  viewDocument(url: string): void;
+  closeDocumentView(): void;
+  viewApplicationForm(): void;
+  closeApplicationForm(): void;
+  sign(): void;
+  finish(): void;
+  retry(): void;
+  close(): void;
+};
+type ElectronicSignatureManager = ReturnType<typeof createElectronicSignatureManagerFromActor>;
+//#endregion
+export { ElectronicSignatureActor as a, createElectronicSignatureManagerFromActor as i, ElectronicSignatureState as n, electronicSignatureMachine as o, createElectronicSignatureManager as r, ElectronicSignatureManager as t };