@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.3

package/dist/idOcrManager-CJzrmM91.d.ts

@@ -0,0 +1,641 @@
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import { t as ActorRefFrom } from "./Actor-CGEelYtQ.js";
+import * as xstate365 from "xstate";
+
+//#region src/modules/id-ocr/types.d.ts
+type IdOcrConfig = {
+  /** Allows user to edit OCR information @default false */
+  editableOcr?: boolean;
+  /**
+   * When true (from flow/onboarding), after the first ID OCR step completes the
+   * machine loads and optionally edits OCR for the second captured ID.
+   */
+  secondId?: boolean;
+  /**
+   * Session flow id (injected by orchestrated flow UI). When listed in `CPFFlowIds`
+   * (`idOcrConsts`), only the CPF field is shown and validated; it maps to `documentNumber` on OCR.
+   */
+  flowId?: string;
+};
+type NameBean = {
+  fullName?: string;
+  firstName?: string;
+  middleName?: string;
+  givenName?: string;
+  nameSuffix?: string;
+  paternalLastName?: string;
+  maternalLastName?: string;
+  lastNameMrz?: string;
+};
+type AddressBean = {
+  street?: string;
+  colony?: string;
+  postalCode?: string;
+  city?: string;
+  state?: string;
+  label?: string;
+  confidentGeolocation?: boolean;
+};
+type AddressStatements = {
+  _id: string;
+  dateType: string;
+  addressStatementTimestamp: number;
+};
+type OcrData = {
+  name: NameBean;
+  givenName?: string;
+  firstName?: string;
+  middleName?: string;
+  nameSuffix?: string;
+  mothersSurname?: string;
+  fathersSurname?: string;
+  nickName?: string;
+  address?: string;
+  street?: string;
+  colony?: string;
+  postalCode?: string;
+  city?: string;
+  state?: string;
+  stateCode?: string;
+  countryCode?: string;
+  addressFields?: AddressBean;
+  fullAddress?: boolean;
+  invalidAddress?: boolean;
+  checkedAddress?: string;
+  checkedAddressBean?: AddressBean;
+  exteriorNumber?: string;
+  interiorNumber?: string;
+  addressFromStatement?: string;
+  addressFieldsFromStatement?: AddressBean;
+  invalidAddressFromStatement?: boolean;
+  addressStatementEmissionDate?: number;
+  documentType?: string;
+  addressStatementTimestamps?: AddressStatements[];
+  poaName?: string;
+  typeOfId?: string;
+  documentFrontSubtype?: string;
+  documentBackSubtype?: string;
+  birthDate?: number | string;
+  gender?: string;
+  claveDeElector?: string;
+  curp?: string;
+  numeroEmisionCredencial?: string;
+  cic?: string;
+  ocr?: string;
+  documentNumber?: string;
+  personalNumber?: string;
+  refNumber?: string;
+  nue?: string;
+  externalId?: string;
+  issuedAt?: string;
+  expireAt?: string;
+  expirationDate?: number;
+  issueDate?: number;
+  registrationDate?: number;
+  issuingCountry?: string;
+  issuingState?: string;
+  birthPlace?: string;
+  issuingAuthority?: string;
+  height?: string;
+  weight?: string;
+  eyeColor?: string;
+  hairColor?: string;
+  bloodType?: string;
+  maritalStatus?: string;
+  nationality?: string;
+  nationalityMrz?: string;
+  classes?: string;
+  cond?: string;
+  mentions?: string;
+  restrictions?: string;
+  mrz1?: string;
+  mrz2?: string;
+  mrz3?: string;
+  fullNameMrz?: string;
+  documentNumberCheckDigit?: string;
+  dateOfBirthCheckDigit?: string;
+  expirationDateCheckDigit?: string;
+  fathersName?: string;
+  mothersName?: string;
+  federalRevenueNumber?: string;
+  originDocumentId?: string;
+  driversLicenseCategory?: string;
+  controlNumber?: string;
+  renach?: string;
+  ocrReliabilityConfidence?: number;
+  ocrDataConfidence?: unknown;
+};
+type UpdateOcrDataParams = {
+  address?: string;
+  documentNumber?: string;
+  name?: string;
+  firstName?: string;
+  lastName?: string;
+  paternalLastName?: string;
+  maternalLastName?: string;
+  personalNumber?: string;
+  curp?: string;
+  email?: string;
+  birthDate?: string;
+  expireAt?: string;
+  gender?: string;
+  issuingCountry?: string;
+};
+type ValidationRule = {
+  type: 'required';
+} | {
+  type: 'minAge';
+  years: number;
+} | {
+  type: 'cpf';
+};
+type OcrFieldConfig = {
+  key: keyof UpdateOcrDataParams;
+  labelKey: string;
+  type: 'text' | 'date' | 'radio';
+  options?: {
+    label: string;
+    value: string;
+  }[];
+  validation?: ValidationRule[];
+  required: boolean;
+};
+type UpdateOcrResponse = {
+  success: boolean;
+};
+//#endregion
+//#region src/modules/id-ocr/idOcrStateMachine.d.ts
+type IdOcrOcrDocument = 'first' | 'second';
+type IdOcrContext = {
+  config: IdOcrConfig;
+  error?: string;
+  formData: UpdateOcrDataParams;
+  editedFields: UpdateOcrDataParams;
+  activeOcrDocument: IdOcrOcrDocument;
+  validationErrors?: Partial<Record<keyof UpdateOcrDataParams, string>>;
+};
+type IdOcrInput = {
+  config: IdOcrConfig;
+};
+declare const idOcrStateMachine: xstate365.StateMachine<IdOcrContext, {
+  type: "LOAD";
+} | {
+  type: "DATA_CHANGED";
+  field: keyof UpdateOcrDataParams;
+  value: string;
+} | {
+  type: "VALIDATE_FIELD";
+  field: keyof UpdateOcrDataParams;
+} | {
+  type: "CONTINUE";
+} | {
+  type: "RETRY";
+}, {
+  [x: string]: xstate365.ActorRefFromLogic<xstate365.PromiseActorLogic<OcrData, {
+    isSecondId: boolean;
+  }, xstate365.EventObject>> | xstate365.ActorRefFromLogic<xstate365.PromiseActorLogic<UpdateOcrResponse, {
+    params: UpdateOcrDataParams;
+    isSecondId: boolean;
+  }, xstate365.EventObject>> | undefined;
+}, xstate365.Values<{
+  getOcrData: {
+    src: "getOcrData";
+    logic: xstate365.PromiseActorLogic<OcrData, {
+      isSecondId: boolean;
+    }, xstate365.EventObject>;
+    id: string | undefined;
+  };
+  updateOcrData: {
+    src: "updateOcrData";
+    logic: xstate365.PromiseActorLogic<UpdateOcrResponse, {
+      params: UpdateOcrDataParams;
+      isSecondId: boolean;
+    }, xstate365.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate365.Values<{
+  setError: {
+    type: "setError";
+    params: xstate365.NonReducibleUnknown;
+  };
+  setInitialData: {
+    type: "setInitialData";
+    params: xstate365.NonReducibleUnknown;
+  };
+  updateField: {
+    type: "updateField";
+    params: xstate365.NonReducibleUnknown;
+  };
+  clearFieldValidationError: {
+    type: "clearFieldValidationError";
+    params: xstate365.NonReducibleUnknown;
+  };
+  setOcrValidationErrors: {
+    type: "setOcrValidationErrors";
+    params: xstate365.NonReducibleUnknown;
+  };
+  validateFormField: {
+    type: "validateFormField";
+    params: xstate365.NonReducibleUnknown;
+  };
+  beginSecondIdOcrPhase: {
+    type: "beginSecondIdOcrPhase";
+    params: xstate365.NonReducibleUnknown;
+  };
+  resetForRetry: {
+    type: "resetForRetry";
+    params: xstate365.NonReducibleUnknown;
+  };
+  computeValidationResult: {
+    type: "computeValidationResult";
+    params: xstate365.NonReducibleUnknown;
+  };
+}>, xstate365.Values<{
+  isOcrEditable: {
+    type: "isOcrEditable";
+    params: unknown;
+  };
+  shouldLoadSecondOcrAfterFirst: {
+    type: "shouldLoadSecondOcrAfterFirst";
+    params: unknown;
+  };
+  isOcrFormValid: {
+    type: "isOcrFormValid";
+    params: unknown;
+  };
+  shouldSubmit: {
+    type: "shouldSubmit";
+    params: unknown;
+  };
+  shouldProceedWithoutSubmitToSecondId: {
+    type: "shouldProceedWithoutSubmitToSecondId";
+    params: unknown;
+  };
+}>, never, "error" | "idle" | "success" | "finished" | "loading" | "submitting" | "inputting" | "readonly" | "validatingContinue", string, IdOcrInput, xstate365.NonReducibleUnknown, xstate365.EventObject, xstate365.MetaObject, {
+  readonly id: "idOcr";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "getOcrData" | "updateOcrData">(logic: TSrc, ...[options]: ({
+        src: "getOcrData";
+        logic: xstate365.PromiseActorLogic<OcrData, {
+          isSecondId: boolean;
+        }, xstate365.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "getOcrData";
+        logic: xstate365.PromiseActorLogic<OcrData, {
+          isSecondId: boolean;
+        }, xstate365.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate365.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate365.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate365.RequiredActorOptions<T>]: unknown }) | undefined], xstate365.IsNotNever<xstate365.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "updateOcrData";
+        logic: xstate365.PromiseActorLogic<UpdateOcrResponse, {
+          params: UpdateOcrDataParams;
+          isSecondId: boolean;
+        }, xstate365.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "updateOcrData";
+        logic: xstate365.PromiseActorLogic<UpdateOcrResponse, {
+          params: UpdateOcrDataParams;
+          isSecondId: boolean;
+        }, xstate365.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate365.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate365.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate365.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate365.IsNotNever<xstate365.RequiredActorOptions<T_1>>> : never : never : never)): xstate365.ActorRefFromLogic<xstate365.GetConcreteByKey<xstate365.Values<{
+        getOcrData: {
+          src: "getOcrData";
+          logic: xstate365.PromiseActorLogic<OcrData, {
+            isSecondId: boolean;
+          }, xstate365.EventObject>;
+          id: string | undefined;
+        };
+        updateOcrData: {
+          src: "updateOcrData";
+          logic: xstate365.PromiseActorLogic<UpdateOcrResponse, {
+            params: UpdateOcrDataParams;
+            isSecondId: boolean;
+          }, xstate365.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate365.AnyActorLogic>(src: TLogic, ...[options]: xstate365.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate365.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate365.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate365.IsNotNever<xstate365.RequiredLogicInput<TLogic>>>): xstate365.ActorRefFromLogic<TLogic>;
+    };
+    input: IdOcrInput;
+    self: xstate365.ActorRef<xstate365.MachineSnapshot<IdOcrContext, {
+      type: "LOAD";
+    } | {
+      type: "DATA_CHANGED";
+      field: keyof UpdateOcrDataParams;
+      value: string;
+    } | {
+      type: "VALIDATE_FIELD";
+      field: keyof UpdateOcrDataParams;
+    } | {
+      type: "CONTINUE";
+    } | {
+      type: "RETRY";
+    }, Record<string, xstate365.AnyActorRef | undefined>, xstate365.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "DATA_CHANGED";
+      field: keyof UpdateOcrDataParams;
+      value: string;
+    } | {
+      type: "VALIDATE_FIELD";
+      field: keyof UpdateOcrDataParams;
+    } | {
+      type: "CONTINUE";
+    } | {
+      type: "RETRY";
+    }, xstate365.AnyEventObject>;
+  }) => {
+    config: IdOcrConfig;
+    formData: UpdateOcrDataParams;
+    editedFields: {};
+    activeOcrDocument: IdOcrOcrDocument;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: readonly [{
+          readonly target: "loading";
+        }];
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly src: "getOcrData";
+        readonly input: ({
+          context
+        }: {
+          context: IdOcrContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          };
+          self: xstate365.ActorRef<xstate365.MachineSnapshot<IdOcrContext, {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          }, Record<string, xstate365.AnyActorRef>, xstate365.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          }, xstate365.AnyEventObject>;
+        }) => {
+          isSecondId: boolean;
+        };
+        readonly onDone: readonly [{
+          readonly target: "inputting";
+          readonly guard: "isOcrEditable";
+          readonly actions: "setInitialData";
+        }, {
+          readonly target: "readonly";
+          readonly actions: "setInitialData";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly readonly: {
+      readonly on: {
+        readonly CONTINUE: readonly [{
+          readonly target: "loading";
+          readonly guard: "shouldLoadSecondOcrAfterFirst";
+          readonly actions: "beginSecondIdOcrPhase";
+        }, {
+          readonly target: "success";
+        }];
+      };
+    };
+    readonly inputting: {
+      readonly on: {
+        readonly DATA_CHANGED: {
+          readonly actions: readonly ["updateField", "clearFieldValidationError"];
+        };
+        readonly VALIDATE_FIELD: {
+          readonly actions: "validateFormField";
+        };
+        readonly CONTINUE: {
+          readonly target: "validatingContinue";
+        };
+      };
+    };
+    readonly validatingContinue: {
+      readonly entry: "computeValidationResult";
+      readonly always: readonly [{
+        readonly guard: "shouldSubmit";
+        readonly target: "submitting";
+      }, {
+        readonly guard: "shouldProceedWithoutSubmitToSecondId";
+        readonly target: "loading";
+        readonly actions: "beginSecondIdOcrPhase";
+      }, {
+        readonly guard: "isOcrFormValid";
+        readonly target: "success";
+      }, {
+        readonly target: "inputting";
+      }];
+    };
+    readonly submitting: {
+      readonly invoke: {
+        readonly src: "updateOcrData";
+        readonly input: ({
+          context
+        }: {
+          context: IdOcrContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          };
+          self: xstate365.ActorRef<xstate365.MachineSnapshot<IdOcrContext, {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          }, Record<string, xstate365.AnyActorRef>, xstate365.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          }, xstate365.AnyEventObject>;
+        }) => {
+          params: UpdateOcrDataParams;
+          isSecondId: boolean;
+        };
+        readonly onDone: readonly [{
+          readonly target: "loading";
+          readonly guard: "shouldLoadSecondOcrAfterFirst";
+          readonly actions: "beginSecondIdOcrPhase";
+        }, {
+          readonly target: "success";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "resetForRetry";
+        };
+      };
+    };
+    readonly success: {
+      readonly after: {
+        readonly 3000: "finished";
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+type IdOcrMachine = typeof idOcrStateMachine;
+//#endregion
+//#region src/modules/id-ocr/idOcrActor.d.ts
+type IdOcrActor = ActorRefFrom<IdOcrMachine>;
+type CreateIdOcrActorOptions = {
+  config: IdOcrConfig;
+};
+//#endregion
+//#region src/modules/id-ocr/idOcrManager.d.ts
+type IdOcrIdleState = {
+  status: 'idle';
+};
+type IdOcrLoadingState = {
+  status: 'loading';
+  ocrDocument: IdOcrOcrDocument;
+};
+type IdOcrReadonlyState = {
+  status: 'readonly';
+  formData: UpdateOcrDataParams;
+  editableOcr: boolean;
+  ocrDocument: IdOcrOcrDocument;
+};
+type IdOcrInputtingState = {
+  status: 'inputting';
+  formData: UpdateOcrDataParams;
+  editedFields: UpdateOcrDataParams;
+  editableOcr: boolean;
+  ocrDocument: IdOcrOcrDocument;
+  validationErrors?: Partial<Record<keyof UpdateOcrDataParams, string>>;
+};
+type IdOcrSubmittingState = {
+  status: 'submitting';
+  ocrDocument: IdOcrOcrDocument;
+};
+type IdOcrFinishedState = {
+  status: 'finished';
+};
+type IdOcrErrorState = {
+  status: 'error';
+  error: string;
+};
+type IdOcrSuccessState = {
+  status: 'success';
+};
+type IdOcrState = IdOcrIdleState | IdOcrLoadingState | IdOcrReadonlyState | IdOcrInputtingState | IdOcrSubmittingState | IdOcrFinishedState | IdOcrErrorState | IdOcrSuccessState;
+declare function createIdOcrManager(options: CreateIdOcrActorOptions): Manager<IdOcrState> & {
+  load(): void;
+  setField(field: keyof UpdateOcrDataParams, value: string): void;
+  validateField(field: keyof UpdateOcrDataParams): void;
+  continue(): void;
+  retry(): void;
+};
+/**
+ * Creates an ID-OCR manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or for story-isolation testing.
+ */
+declare function createIdOcrManagerFromActor(actor: IdOcrActor): Manager<IdOcrState> & {
+  load(): void;
+  setField(field: keyof UpdateOcrDataParams, value: string): void;
+  validateField(field: keyof UpdateOcrDataParams): void;
+  continue(): void;
+  retry(): void;
+};
+type IdOcrManager = ReturnType<typeof createIdOcrManager>;
+//#endregion
+export { IdOcrActor as a, IdOcrConfig as c, UpdateOcrDataParams as d, ValidationRule as f, createIdOcrManagerFromActor as i, OcrData as l, IdOcrState as n, IdOcrOcrDocument as o, createIdOcrManager as r, idOcrStateMachine as s, IdOcrManager as t, OcrFieldConfig as u };

package/dist/{idOcrStateMachine-CDQ5d_VM.esm.js → idOcrStateMachine-DRZc4FBl.esm.js}

@@ -1,8 +1,8 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { x as getTimestamp } from "./events-Dvvriq9l.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
-import { t as validateCPF } from "./cpf-BRzggV8G.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { _ as getTimestamp } from "./events-CqGY1yMq.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
+import { t as validateCPF } from "./cpf-BKaho0j_.esm.js";
 
 //#region ../infra/src/providers/browser/DateFormattingProvider.ts
 var DateFormattingProvider = class {

package/dist/{idVerificationStateMachine-kRxwImzO.esm.js → idVerificationStateMachine-oqiERKpg.esm.js}

@@ -1,6 +1,6 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { a as fromPromise, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { a as fromPromise, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
 
 //#region src/modules/id-verification/idVerificationServices.ts
 /**

package/dist/identity-reuse.d.ts

@@ -1,4 +1,5 @@
-import "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
-import { c as identityReuseMachine, d as ReusableDocument, f as SubmitResponse, i as createIdentityReuseManagerFromActor, l as FetchDocumentsResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as IdentityReuseConfig } from "./identityReuseManager-Cww-NDtd.js";
+import "./StateMachine-C_AY4cs7.js";
+import "./Manager-CJ3G2zqi.js";
+import "./Actor-CGEelYtQ.js";
+import { c as identityReuseMachine, d as ReusableDocument, f as SubmitResponse, i as createIdentityReuseManagerFromActor, l as FetchDocumentsResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as IdentityReuseConfig } from "./identityReuseManager-TWKbXuvY.js";
 export { type FetchDocumentsResponse, type IdentityReuseConfig, type IdentityReuseManager, type IdentityReuseState, type ReusableDocument, SCAN_NEW_DOCUMENT, type SelectedDocumentId, type SubmitResponse, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/identity-reuse.esm.js

@@ -1,8 +1,9 @@
-import "./api-CESGtpbH.esm.js";
-import "./events-Dvvriq9l.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import "./xstate.esm-C9wncMQa.esm.js";
-import { n as identityReuseMachine, t as SCAN_NEW_DOCUMENT } from "./identityReuseStateMachine-BfE5YiEr.esm.js";
-import { n as createIdentityReuseManagerFromActor, t as createIdentityReuseManager } from "./identityReuseManager-C6n_97dw.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import "./events-CqGY1yMq.esm.js";
+import "./types-ElOJAGaM.esm.js";
+import "./endpoints-BzMJFAPV.esm.js";
+import "./xstate.esm-Bomq1a0z.esm.js";
+import { n as identityReuseMachine, t as SCAN_NEW_DOCUMENT } from "./identityReuseStateMachine-BmONeF6B.esm.js";
+import { n as createIdentityReuseManagerFromActor, t as createIdentityReuseManager } from "./identityReuseManager-Bu62LToE.esm.js";
 
 export { SCAN_NEW_DOCUMENT, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/{identityReuseManager-C6n_97dw.esm.js → identityReuseManager-Bu62LToE.esm.js}

@@ -1,6 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
-import { n as identityReuseMachine } from "./identityReuseStateMachine-BfE5YiEr.esm.js";
+import { n as createManagerInstrumentation } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import { l as createManager, s as createActor } from "./xstate.esm-Bomq1a0z.esm.js";
+import { n as identityReuseMachine } from "./identityReuseStateMachine-BmONeF6B.esm.js";
 
 //#region src/modules/identity-reuse/identityReuseActor.ts
 /**