@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/index-DZoqeAo9.d.ts

@@ -0,0 +1,1177 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import * as xstate978 from "xstate";
+
+//#region src/modules/electronic-signature/types.d.ts
+type ElectronicSignatureVariant = 'ae' | 'qe';
+type ElectronicSignatureConfig = {
+  variant?: ElectronicSignatureVariant;
+  uploadDocument?: boolean;
+  downloadDocument?: boolean;
+};
+type ElectronicSignatureDocument = {
+  documentRef: string;
+  documentUrl: string;
+};
+type SignedDocument = {
+  signedDocumentUrl: string;
+};
+declare const AE_CONSENT_KEYS: readonly ["terms", "signElectronically", "signDisplayed"];
+declare const QE_CONSENT_KEYS: readonly ["issuance", "qesAcknowledgement", "qscdConfirmation", "termsAgreement", "documentsReviewed"];
+type AeConsentKey = (typeof AE_CONSENT_KEYS)[number];
+type QeConsentKey = (typeof QE_CONSENT_KEYS)[number];
+type ConsentKey = AeConsentKey | QeConsentKey;
+type ConsentChecks = Partial<Record<ConsentKey, boolean>>;
+declare function getConsentKeys(variant: ElectronicSignatureVariant): readonly ConsentKey[];
+declare function getDefaultConsentChecks(variant: ElectronicSignatureVariant): ConsentChecks;
+declare function areAllConsented(checks: ConsentChecks): boolean;
+type UnsignedDocsResponse = {
+  documents: ElectronicSignatureDocument[];
+};
+type ElectronicSignatureErrorSource = 'upload' | 'fetchDocs' | 'signing';
+type ElectronicSignatureContext = {
+  config: ElectronicSignatureConfig;
+  getFileData: () => ArrayBuffer | null;
+  documents: ElectronicSignatureDocument[];
+  signedDocuments: SignedDocument[];
+  fileName: string | null;
+  fileSize: number | null;
+  fileUrl: string | null;
+  consentChecks: ConsentChecks;
+  viewingDocumentUrl: string | null;
+  errorMessage: string;
+  errorSource: ElectronicSignatureErrorSource | null;
+};
+type ElectronicSignatureInput = {
+  config: ElectronicSignatureConfig;
+  getFileData: () => ArrayBuffer | null;
+};
+//#endregion
+//#region src/modules/electronic-signature/electronicSignatureStateMachine.d.ts
+declare const electronicSignatureMachine: xstate978.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: "SIGN";
+} | {
+  type: "FINISH";
+} | {
+  type: "RETRY";
+} | {
+  type: "CLOSE";
+}, {
+  [x: string]: xstate978.ActorRefFromLogic<xstate978.PromiseActorLogic<void, {
+    getFileData: () => ArrayBuffer | null;
+  }, xstate978.EventObject>> | xstate978.ActorRefFromLogic<xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>> | xstate978.ActorRefFromLogic<xstate978.PromiseActorLogic<SignedDocument[], {
+    documents: ElectronicSignatureDocument[];
+    variant: ElectronicSignatureVariant;
+  }, xstate978.EventObject>> | undefined;
+}, xstate978.Values<{
+  uploadDocument: {
+    src: "uploadDocument";
+    logic: xstate978.PromiseActorLogic<void, {
+      getFileData: () => ArrayBuffer | null;
+    }, xstate978.EventObject>;
+    id: string | undefined;
+  };
+  fetchUnsignedDocs: {
+    src: "fetchUnsignedDocs";
+    logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+    id: string | undefined;
+  };
+  signDocuments: {
+    src: "signDocuments";
+    logic: xstate978.PromiseActorLogic<SignedDocument[], {
+      documents: ElectronicSignatureDocument[];
+      variant: ElectronicSignatureVariant;
+    }, xstate978.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate978.Values<{
+  setDocuments: {
+    type: "setDocuments";
+    params: xstate978.NonReducibleUnknown;
+  };
+  setSignedDocuments: {
+    type: "setSignedDocuments";
+    params: xstate978.NonReducibleUnknown;
+  };
+  setFile: {
+    type: "setFile";
+    params: xstate978.NonReducibleUnknown;
+  };
+  updateConsent: {
+    type: "updateConsent";
+    params: xstate978.NonReducibleUnknown;
+  };
+  setViewingDocument: {
+    type: "setViewingDocument";
+    params: xstate978.NonReducibleUnknown;
+  };
+  clearViewingDocument: {
+    type: "clearViewingDocument";
+    params: xstate978.NonReducibleUnknown;
+  };
+}>, xstate978.Values<{
+  errorFromUpload: {
+    type: "errorFromUpload";
+    params: unknown;
+  };
+  errorFromSigning: {
+    type: "errorFromSigning";
+    params: unknown;
+  };
+  shouldUpload: {
+    type: "shouldUpload";
+    params: unknown;
+  };
+  shouldDownload: {
+    type: "shouldDownload";
+    params: unknown;
+  };
+  allConsented: {
+    type: "allConsented";
+    params: unknown;
+  };
+  hasDocuments: {
+    type: "hasDocuments";
+    params: unknown;
+  };
+  allSigned: {
+    type: "allSigned";
+    params: unknown;
+  };
+  allSignedAndDownload: {
+    type: "allSignedAndDownload";
+    params: unknown;
+  };
+}>, never, "error" | "signing" | "idle" | "uploading" | "fetchingDocs" | "reviewing" | "closed" | "uploadingFile" | "processing" | "successDownload" | "success" | "finished", string, ElectronicSignatureInput, xstate978.NonReducibleUnknown, xstate978.EventObject, xstate978.MetaObject, {
+  readonly id: "electronicSignature";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "uploadDocument" | "fetchUnsignedDocs" | "signDocuments">(logic: TSrc, ...[options]: ({
+        src: "uploadDocument";
+        logic: xstate978.PromiseActorLogic<void, {
+          getFileData: () => ArrayBuffer | null;
+        }, xstate978.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "uploadDocument";
+        logic: xstate978.PromiseActorLogic<void, {
+          getFileData: () => ArrayBuffer | null;
+        }, xstate978.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate978.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate978.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate978.RequiredActorOptions<T>]: unknown }) | undefined], xstate978.IsNotNever<xstate978.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "fetchUnsignedDocs";
+        logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "fetchUnsignedDocs";
+        logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate978.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate978.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate978.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate978.IsNotNever<xstate978.RequiredActorOptions<T_1>>> : never : never : never) | ({
+        src: "signDocuments";
+        logic: xstate978.PromiseActorLogic<SignedDocument[], {
+          documents: ElectronicSignatureDocument[];
+          variant: ElectronicSignatureVariant;
+        }, xstate978.EventObject>;
+        id: string | undefined;
+      } extends infer T_2 ? T_2 extends {
+        src: "signDocuments";
+        logic: xstate978.PromiseActorLogic<SignedDocument[], {
+          documents: ElectronicSignatureDocument[];
+          variant: ElectronicSignatureVariant;
+        }, xstate978.EventObject>;
+        id: string | undefined;
+      } ? T_2 extends {
+        src: TSrc;
+      } ? xstate978.ConditionalRequired<[options?: ({
+        id?: T_2["id"] | undefined;
+        systemId?: string;
+        input?: xstate978.InputFrom<T_2["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_2 in xstate978.RequiredActorOptions<T_2>]: unknown }) | undefined], xstate978.IsNotNever<xstate978.RequiredActorOptions<T_2>>> : never : never : never)): xstate978.ActorRefFromLogic<xstate978.GetConcreteByKey<xstate978.Values<{
+        uploadDocument: {
+          src: "uploadDocument";
+          logic: xstate978.PromiseActorLogic<void, {
+            getFileData: () => ArrayBuffer | null;
+          }, xstate978.EventObject>;
+          id: string | undefined;
+        };
+        fetchUnsignedDocs: {
+          src: "fetchUnsignedDocs";
+          logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+          id: string | undefined;
+        };
+        signDocuments: {
+          src: "signDocuments";
+          logic: xstate978.PromiseActorLogic<SignedDocument[], {
+            documents: ElectronicSignatureDocument[];
+            variant: ElectronicSignatureVariant;
+          }, xstate978.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate978.AnyActorLogic>(src: TLogic, ...[options]: xstate978.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate978.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate978.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate978.IsNotNever<xstate978.RequiredLogicInput<TLogic>>>): xstate978.ActorRefFromLogic<TLogic>;
+    };
+    input: ElectronicSignatureInput;
+    self: xstate978.ActorRef<xstate978.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: "SIGN";
+    } | {
+      type: "FINISH";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CLOSE";
+    }, Record<string, xstate978.AnyActorRef | undefined>, xstate978.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: "SIGN";
+    } | {
+      type: "FINISH";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CLOSE";
+    }, xstate978.AnyEventObject>;
+  }) => {
+    config: ElectronicSignatureConfig;
+    getFileData: () => ArrayBuffer | null;
+    documents: never[];
+    signedDocuments: never[];
+    fileName: null;
+    fileSize: null;
+    fileUrl: null;
+    consentChecks: Partial<Record<ConsentKey, boolean>>;
+    viewingDocumentUrl: null;
+    errorMessage: string;
+    errorSource: null;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: readonly [{
+          readonly target: "uploading";
+          readonly guard: "shouldUpload";
+        }, {
+          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: xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, xstate978.Values<{
+            uploadDocument: {
+              src: "uploadDocument";
+              logic: xstate978.PromiseActorLogic<void, {
+                getFileData: () => ArrayBuffer | null;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: xstate978.PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                variant: ElectronicSignatureVariant;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        };
+        readonly CONFIRM_FILE: {
+          readonly target: "uploadingFile";
+        };
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly uploadingFile: {
+      readonly invoke: {
+        readonly id: "uploadDocument";
+        readonly src: "uploadDocument";
+        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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          };
+          self: xstate978.ActorRef<xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, Record<string, xstate978.AnyActorRef>, xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, xstate978.AnyEventObject>;
+        }) => {
+          getFileData: () => ArrayBuffer | null;
+        };
+        readonly onDone: {
+          readonly target: "fetchingDocs";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: xstate978.ActionFunction<ElectronicSignatureContext, xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, xstate978.Values<{
+            uploadDocument: {
+              src: "uploadDocument";
+              logic: xstate978.PromiseActorLogic<void, {
+                getFileData: () => ArrayBuffer | null;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: xstate978.PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                variant: ElectronicSignatureVariant;
+              }, xstate978.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: "error";
+          readonly actions: xstate978.ActionFunction<ElectronicSignatureContext, xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, xstate978.Values<{
+            uploadDocument: {
+              src: "uploadDocument";
+              logic: xstate978.PromiseActorLogic<void, {
+                getFileData: () => ArrayBuffer | null;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: xstate978.PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                variant: ElectronicSignatureVariant;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: xstate978.ActionFunction<ElectronicSignatureContext, xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, xstate978.Values<{
+            uploadDocument: {
+              src: "uploadDocument";
+              logic: xstate978.PromiseActorLogic<void, {
+                getFileData: () => ArrayBuffer | null;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: xstate978.PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                variant: ElectronicSignatureVariant;
+              }, xstate978.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 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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          };
+          self: xstate978.ActorRef<xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, Record<string, xstate978.AnyActorRef>, xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, xstate978.AnyEventObject>;
+        }) => {
+          documents: ElectronicSignatureDocument[];
+          variant: ElectronicSignatureVariant;
+        };
+        readonly onDone: readonly [{
+          readonly target: "successDownload";
+          readonly guard: "allSignedAndDownload";
+          readonly actions: "setSignedDocuments";
+        }, {
+          readonly target: "success";
+          readonly guard: "allSigned";
+          readonly actions: "setSignedDocuments";
+        }, {
+          readonly target: "error";
+          readonly actions: xstate978.ActionFunction<ElectronicSignatureContext, xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, xstate978.Values<{
+            uploadDocument: {
+              src: "uploadDocument";
+              logic: xstate978.PromiseActorLogic<void, {
+                getFileData: () => ArrayBuffer | null;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: xstate978.PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                variant: ElectronicSignatureVariant;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: xstate978.ActionFunction<ElectronicSignatureContext, xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, xstate978.Values<{
+            uploadDocument: {
+              src: "uploadDocument";
+              logic: xstate978.PromiseActorLogic<void, {
+                getFileData: () => ArrayBuffer | null;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: xstate978.PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                variant: ElectronicSignatureVariant;
+              }, xstate978.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 error: {
+      readonly on: {
+        readonly RETRY: readonly [{
+          readonly target: "uploading";
+          readonly guard: "errorFromUpload";
+          readonly actions: xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, xstate978.Values<{
+            uploadDocument: {
+              src: "uploadDocument";
+              logic: xstate978.PromiseActorLogic<void, {
+                getFileData: () => ArrayBuffer | null;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: xstate978.PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                variant: ElectronicSignatureVariant;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "signing";
+          readonly guard: "errorFromSigning";
+          readonly actions: xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, xstate978.Values<{
+            uploadDocument: {
+              src: "uploadDocument";
+              logic: xstate978.PromiseActorLogic<void, {
+                getFileData: () => ArrayBuffer | null;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: xstate978.PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                variant: ElectronicSignatureVariant;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }, {
+          readonly target: "fetchingDocs";
+          readonly actions: xstate978.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: "SIGN";
+          } | {
+            type: "FINISH";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, undefined, xstate978.Values<{
+            uploadDocument: {
+              src: "uploadDocument";
+              logic: xstate978.PromiseActorLogic<void, {
+                getFileData: () => ArrayBuffer | null;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            fetchUnsignedDocs: {
+              src: "fetchUnsignedDocs";
+              logic: xstate978.PromiseActorLogic<UnsignedDocsResponse, void, xstate978.EventObject>;
+              id: string | undefined;
+            };
+            signDocuments: {
+              src: "signDocuments";
+              logic: xstate978.PromiseActorLogic<SignedDocument[], {
+                documents: ElectronicSignatureDocument[];
+                variant: ElectronicSignatureVariant;
+              }, xstate978.EventObject>;
+              id: string | undefined;
+            };
+          }>, never, never, never, never>;
+        }];
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly closed: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/electronic-signature/electronicSignatureActor.d.ts
+type CreateElectronicSignatureActorOptions = {
+  config: ElectronicSignatureConfig;
+  getFileData: () => ArrayBuffer | null;
+};
+//#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;
+  viewingDocumentUrl: string | null;
+};
+type ElectronicSignatureProcessingState = {
+  status: 'processing';
+};
+type ElectronicSignatureSuccessState = {
+  status: 'success';
+  signedDocuments: SignedDocument[];
+  downloadDocument: boolean;
+};
+type ElectronicSignatureErrorState = {
+  status: 'error';
+  errorMessage: string;
+};
+type ElectronicSignatureFinishedState = {
+  status: 'finished';
+};
+type ElectronicSignatureClosedState = {
+  status: 'closed';
+};
+type ElectronicSignatureState = ElectronicSignatureLoadingState | ElectronicSignatureUploadingState | ElectronicSignatureReviewingState | ElectronicSignatureSigningState | ElectronicSignatureProcessingState | ElectronicSignatureSuccessState | ElectronicSignatureErrorState | ElectronicSignatureFinishedState | ElectronicSignatureClosedState;
+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;
+  sign(): void;
+  finish(): void;
+  retry(): void;
+  close(): void;
+};
+type ElectronicSignatureManager = ReturnType<typeof createElectronicSignatureManager>;
+//#endregion
+export { AE_CONSENT_KEYS as a, ConsentKey as c, ElectronicSignatureVariant as d, QE_CONSENT_KEYS as f, getDefaultConsentChecks as g, getConsentKeys as h, electronicSignatureMachine as i, ElectronicSignatureConfig as l, areAllConsented as m, ElectronicSignatureState as n, AeConsentKey as o, QeConsentKey as p, createElectronicSignatureManager as r, ConsentChecks as s, ElectronicSignatureManager as t, ElectronicSignatureDocument as u };