@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/trust-graph.d.ts

@@ -1,7 +1,6 @@
-import "./StateMachine-D5WO6lHS.js";
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import * as xstate996 from "xstate";
-
+import { A as StateMachine, c as AnyEventObject, p as EventObject, v as MetaObject, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
 //#region src/modules/trust-graph/trustGraphManager.d.ts
 type TrustGraphIdleState = {
   status: 'idle';
@@ -60,7 +59,7 @@ type TrustGraphContext = Record<string, never>;
  * Mirror the `noOpFlowModuleMachine` / `identitySearchMachine` headless pattern:
  * start directly in the `final` state.
  */
-declare const trustGraphMachine: xstate996.StateMachine<TrustGraphContext, xstate996.AnyEventObject, {}, never, never, never, never, "finished", string, xstate996.NonReducibleUnknown, xstate996.NonReducibleUnknown, xstate996.EventObject, xstate996.MetaObject, {
+declare const trustGraphMachine: StateMachine<TrustGraphContext, AnyEventObject, {}, never, never, never, never, "finished", string, NonReducibleUnknown, NonReducibleUnknown, EventObject, MetaObject, {
   readonly id: "trust-graph";
   readonly initial: "finished";
   readonly context: {};

package/dist/trust-graph.esm.js

@@ -1,7 +1,5 @@
-import "./api-DsbUi7TO.esm.js";
-import { n as eventModuleNames, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
-import { l as createManager, s as createActor, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { c as createManager, o as createActor, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
 //#region src/modules/trust-graph/trustGraphStateMachine.ts
 /**
 * Trust-graph is a headless "skip" module: it has no UI and the SDK performs no
@@ -23,13 +21,11 @@ const trustGraphMachine = setup({ types: { context: {} } }).createMachine({
 	context: {},
 	states: { finished: { type: "final" } }
 });
-
 //#endregion
 //#region src/modules/trust-graph/trustGraphActor.ts
 function createTrustGraphActor() {
 	return createActor(trustGraphMachine).start();
 }
-
 //#endregion
 //#region src/modules/trust-graph/trustGraphManager.ts
 function mapState(snapshot) {
@@ -37,7 +33,16 @@ function mapState(snapshot) {
 	return { status: "idle" };
 }
 function createApi(_options) {
-	return { load() {} };
+	return { 
+	/**
+	* Retained for API compatibility. Trust-graph is a headless skip module
+	* whose machine starts in `finished` (backend-only, no SDK action), so there
+	* is nothing to kick off and calling this has no effect.
+	*
+	* @deprecated The module completes on its own as soon as the manager is
+	* created; reading `getState()` / subscribing is sufficient.
+	*/
+load() {} };
 }
 /**
 * Creates a trust-graph manager for headless usage.
@@ -57,6 +62,5 @@ function createTrustGraphManager() {
 		instrumentation: createManagerInstrumentation(eventModuleNames.trustGraph)
 	});
 }
-
 //#endregion
-export { createTrustGraphManager, trustGraphMachine };
+export { createTrustGraphManager, trustGraphMachine };

package/dist/types-BEwVKkLJ.d.ts

@@ -0,0 +1,15 @@
+//#region src/internal/permissions/types.d.ts
+type PermissionResult = 'granted' | 'denied' | 'prompt';
+/**
+ * What the camera-permission screen should show.
+ *
+ * `'checking'` and `'idle'` are deliberately distinct. `'checking'` means the
+ * permission query is still in flight and the SDK does not yet know whether a
+ * prompt is needed, so the UI must render nothing; `'idle'` means the answer is
+ * in and the user has to be asked. Collapsing the two made the allow-camera
+ * sheet paint during every check — visible as a flash even when the camera was
+ * already granted.
+ */
+type PermissionStatus = 'checking' | 'idle' | 'motionOnly' | 'requesting' | 'denied' | 'learnMore';
+//#endregion
+export { PermissionStatus as n, PermissionResult as t };

package/dist/{types-BKLb3C42.esm.js → types-BN5RPPIZ.esm.js}

@@ -30,6 +30,5 @@ const FACE_ERROR_CODES = {
 	SELFIE_IMAGE_LOW_QUALITY: "SELFIE_IMAGE_LOW_QUALITY",
 	NO_MORE_ATTEMPTS: "NO_MORE_ATTEMPTS"
 };
-
 //#endregion
-export { FACE_ERROR_CODES as t };
+export { FACE_ERROR_CODES as t };

package/dist/types-BSBzhHRH.d.ts

@@ -0,0 +1,57 @@
+//#region src/modules/dynamic-forms/types.d.ts
+/**
+ * Input types supported by dynamic form questions.
+ * `inputType` on `Question` is optional so unknown future API values degrade
+ * gracefully to the text fallback rather than requiring this union to be widened.
+ */
+type InputType = 'TEXT' | 'DATE' | 'COUNTRY' | 'NATIONALITY' | 'NUMBER' | 'EMAIL' | 'PHONE' | 'CPF' | 'NAME' | 'YESNO' | 'SELECT' | 'MULTISELECT';
+/**
+ * A single question within a dynamic form screen.
+ */
+type Question = {
+  questionId: string;
+  /** Display label shown to the user */
+  question: string;
+  inputType?: InputType;
+  /** Fallback type used when `inputType` is absent */
+  overrides?: InputType;
+  isPredefined?: boolean;
+  isOptional?: boolean;
+  options?: string[];
+  /**
+   * Form Pre-fill: the interview attribute this question is prefilled from
+   * (`null`/absent = not prefilled). Non-null opts the form into the one-shot
+   * prefill fetch. Distinct from `DynamicFormsConfig.prefillValue` (the
+   * single-question login-hint). `editable` (default true) only matters when
+   * `prefillSource` is set.
+   */
+  prefillSource?: string | null;
+  editable?: boolean;
+};
+/**
+ * A single screen within the dynamic form flow.
+ */
+type Screen = {
+  title?: string;
+  hideTitle?: boolean;
+  questions: Question[];
+};
+/**
+ * Configuration for the dynamic forms module.
+ * Provide either `screens` (pre-loaded) or `flowId` (fetched from API).
+ */
+type DynamicFormsConfig = {
+  /** Flow ID used to fetch screens from the API when `screens` is not provided */
+  flowId?: string;
+  /** Pre-loaded screens — skips the API fetch when provided */
+  screens?: Screen[];
+  /**
+   * Value used to prefill the sole answer of a single-question first screen (e.g.
+   * a login hint read from a URL param by the host). Applied only when the form
+   * is exactly one screen with one question; ignored otherwise. The field stays
+   * editable. The host reads the value — core never touches the URL.
+   */
+  prefillValue?: string;
+};
+//#endregion
+export { Screen as i, InputType as n, Question as r, DynamicFormsConfig as t };

package/dist/types-BX_XkMsQ2.d.ts

@@ -0,0 +1,21 @@
+import { a as RegulationTypes } from "./types-KPvmag_B.js";
+//#region src/modules/mandatory-consent/types.d.ts
+type RegulatoryConsentType = 'MANDATORY' | 'ML';
+type MandatoryConsentConfig = {
+  consentType: RegulationTypes;
+  language?: string;
+  /** 'MANDATORY' (default) for MANDATORY_CONSENT, 'ML' for ML_CONSENT. */
+  type?: RegulatoryConsentType;
+};
+type MandatoryConsent = {
+  id: string;
+  title: string;
+  text: string;
+  description?: string;
+  consentType: string;
+};
+type FetchMandatoryConsentResponse = {
+  consents: MandatoryConsent[];
+};
+//#endregion
+export { MandatoryConsent as n, MandatoryConsentConfig as r, FetchMandatoryConsentResponse as t };

package/dist/types-BfHiko5D.d.ts

@@ -0,0 +1,48 @@
+import { l as FieldDef } from "./types-Bk_6dmDa.js";
+//#region src/modules/ekyb/types.d.ts
+type UboEntry = {
+  id: string;
+  name: string;
+  surname: string;
+};
+type EkybFormValues = {
+  country: string;
+  businessName?: string;
+  street?: string;
+  houseNo?: string;
+  addressLine2?: string;
+  city?: string;
+  state?: string;
+  postalCode?: string;
+  taxId?: string;
+};
+type EkybConfig = {
+  flowId?: string;
+  verificationFields?: string[];
+  checkBusinessName?: boolean;
+  checkAddress?: boolean;
+  checkTaxId?: boolean;
+  checkUniqueBeneficialOwner?: boolean;
+};
+type EkybValidationRule = {
+  type: 'required';
+} | {
+  type: 'streetLevelRequired';
+} | {
+  type: 'cnpj';
+} | {
+  type: 'postalCodeFormat';
+  country: string;
+};
+type EkybValidationError = {
+  key: string;
+  params?: Record<string, string | number>;
+};
+type EkybValidationErrors = Partial<Record<string, EkybValidationError>>;
+type EkybFieldDef = FieldDef & {
+  optionalForCountries?: string[];
+  validation?: EkybValidationRule[];
+};
+type EkybCountry = 'BR' | 'US' | 'GB' | 'ES' | 'IT' | 'FR' | 'DE' | 'IL' | 'MX' | 'CN' | 'NG' | 'CM' | 'KE';
+//#endregion
+export { EkybValidationError as a, EkybFormValues as i, EkybCountry as n, EkybValidationErrors as o, EkybFieldDef as r, UboEntry as s, EkybConfig as t };

package/dist/{types-D8Cl1N2Z.d.ts → types-BfgmV7s72.d.ts}

@@ -1,5 +1,5 @@
-import { t as AnyStateMachine } from "./StateMachine-D5WO6lHS.js";
-
+import { l as AnyStateMachine } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
 //#region src/internal/orchestration/types.d.ts
 /** Eager module: a pre-imported state machine. */
 type EagerModule = AnyStateMachine;

package/dist/types-CJ7Yl9K-2.d.ts

@@ -0,0 +1,164 @@
+//#region src/modules/id-ocr/types.d.ts
+type IdOcrConfig = {
+  /** Allows user to edit OCR information @default false */
+  editableOcr?: boolean;
+  cpfOnly?: 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
+export { UpdateOcrResponse as a, UpdateOcrDataParams as i, OcrData as n, ValidationRule as o, OcrFieldConfig as r, IdOcrConfig as t };

package/dist/types-DPIDuhut.d.ts

@@ -0,0 +1,40 @@
+//#region src/modules/redirect-to-mobile/types.d.ts
+type RedirectToMobileConfig = {
+  flowId?: string;
+  url?: string;
+  disableSmsOption?: boolean;
+  addContinueToDesktop?: boolean;
+  qrPhishingResistance?: boolean;
+  authHint?: string;
+  externalId?: string;
+  lang?: string;
+};
+type OnboardingStatus = 'ONBOARDING_FINISHED' | 'ONBOARDING_IN_PROGRESS' | 'ONBOARDING_NOT_STARTED';
+type OnboardingStatusResponse = {
+  onboardingStatus: OnboardingStatus;
+};
+type RedirectUrlResponse = {
+  url: string;
+};
+type QrRefreshResponse = {
+  urlUuid: string;
+};
+type StartInfoResponse = {
+  phonePrefix: string;
+  ipIsoCode: string;
+};
+type SendRedirectSmsParams = {
+  smsType: 'DESKTOP_ONBOARDING';
+  uuid: string;
+  params?: string[];
+};
+type RedirectToMobileServices = {
+  fetchRedirectUrl: (signal?: AbortSignal) => Promise<RedirectUrlResponse>;
+  fetchOnboardingStatus: (signal?: AbortSignal) => Promise<OnboardingStatusResponse>;
+  sendRedirectSms: (params: SendRedirectSmsParams, signal?: AbortSignal) => Promise<void>;
+  addPhoneForRedirect: (phone: string, signal?: AbortSignal) => Promise<void>;
+  refreshQrUuid: (onboardingId: string, signal?: AbortSignal) => Promise<QrRefreshResponse>;
+  fetchStartInfo: (signal?: AbortSignal) => Promise<StartInfoResponse>;
+};
+//#endregion
+export { RedirectToMobileServices as n, RedirectToMobileConfig as t };

package/dist/types-DVmXIdzW.d.ts

@@ -0,0 +1,82 @@
+//#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 = {
+  /**
+   * Whether the signing endpoint acknowledged this document as signed. Set from
+   * either the AES signed-PDF URL or the QES `{ success: true }` acknowledgment.
+   */
+  signed: boolean;
+  /**
+   * URL of the signed PDF when the endpoint returns one (AES `/process/sign`).
+   * QES `/process/signQes` returns only `{ success: true }` with no document
+   * URL, so this is absent for the QE variant.
+   */
+  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';
+/**
+ * Mutable in-memory holder for the document selected for upload.
+ *
+ * The actor and manager must share this exact object so `selectFile()` updates
+ * the bytes later consumed by the machine's upload actor.
+ */
+type ElectronicSignatureFileDataHolder = {
+  current: ArrayBuffer | null;
+};
+type ElectronicSignatureContext = {
+  config: ElectronicSignatureConfig;
+  fileDataHolder: ElectronicSignatureFileDataHolder;
+  documents: ElectronicSignatureDocument[];
+  signedDocuments: SignedDocument[];
+  fileName: string | null;
+  fileSize: number | null;
+  fileUrl: string | null;
+  /**
+   * Upload destination for the single document this session may hold.
+   * Generated exactly once (`POST /generateDocumentUploadUrl` creates a
+   * server-side document) and reused across upload retries so a session can
+   * never accumulate more than one document — see the AES "two documents"
+   * bug where a retry created a second, unremovable document.
+   */
+  preSignedUrl: string | null;
+  consentChecks: ConsentChecks;
+  viewingDocumentUrl: string | null;
+  errorMessage: string;
+  errorSource: ElectronicSignatureErrorSource | null;
+};
+type ElectronicSignatureInput = {
+  config: ElectronicSignatureConfig;
+  fileDataHolder: ElectronicSignatureFileDataHolder;
+  getFileData?: never;
+} | {
+  config: ElectronicSignatureConfig;
+  /**
+   * @deprecated Pass `fileDataHolder` so actor and manager ownership is
+   * explicit. Retained for existing direct machine integrations.
+   */
+  getFileData: () => ArrayBuffer | null;
+  fileDataHolder?: never;
+};
+//#endregion
+export { getDefaultConsentChecks as _, ElectronicSignatureConfig as a, ElectronicSignatureFileDataHolder as c, QE_CONSENT_KEYS as d, QeConsentKey as f, getConsentKeys as g, areAllConsented as h, ConsentKey as i, ElectronicSignatureInput as l, UnsignedDocsResponse as m, AeConsentKey as n, ElectronicSignatureContext as o, SignedDocument as p, ConsentChecks as r, ElectronicSignatureDocument as s, AE_CONSENT_KEYS as t, ElectronicSignatureVariant as u };

package/dist/types-DelMqZLe.d.ts

@@ -0,0 +1,105 @@
+import { t as CameraStream } from "./camera-9wWD-pwg.js";
+import { t as PermissionResult } from "./types-BEwVKkLJ.js";
+//#region src/modules/document-capture/types.d.ts
+type DocumentType = 'addressStatement' | 'otherDocument1' | 'otherDocument2' | 'otherDocument3' | 'v5cMultiPageLogbook' | 'circulationCard' | 'financeSettlement' | 'carInvoice' | 'capture' | 'processPoaOcr' | 'processLoaOcr' | 'processAsylumSeekerVisaZaf' | 'processBankStatementOCR' | 'processBankCheck' | 'processV5CLogbook' | 'processCarInvoice' | 'processCirculationCard' | 'processFinanceSettlement' | 'processW8BenOcr' | 'processW8BenEOcr' | 'w8Ben' | 'w8BenE';
+declare const DOCUMENT_CAPTURE_ERROR_CODES: {
+  readonly FILE_TOO_LARGE: "FILE_TOO_LARGE";
+  readonly UPLOAD_FAILED: "UPLOAD_FAILED";
+};
+declare const DOCUMENT_CAPTURE_FINALIZE_ERROR_CODES: {
+  readonly UNEXPECTED_ERROR: "UNEXPECTED_ERROR";
+};
+type DocumentCaptureErrorCode = (typeof DOCUMENT_CAPTURE_ERROR_CODES)[keyof typeof DOCUMENT_CAPTURE_ERROR_CODES];
+type DocumentCaptureFinalizeErrorCode = (typeof DOCUMENT_CAPTURE_FINALIZE_ERROR_CODES)[keyof typeof DOCUMENT_CAPTURE_FINALIZE_ERROR_CODES];
+/**
+ * Configuration for the document capture module.
+ * Parameterized to support both DOCUMENT_CAPTURE and ADDRESS flows.
+ */
+type DocumentCaptureConfig = {
+  /** Processing type for API endpoint routing. @default 'addressStatement' */
+  processingType?: DocumentType;
+  /**
+   * Restricts the capture method, selecting the Figma "3 cases" flow:
+   * - `'camera'` → capture only (upload hidden)
+   * - `'file'` → upload only (camera hidden)
+   * - absent → capture + upload (method selection) — the default
+   */
+  captureMode?: 'file' | 'camera';
+  /** Allow user to skip this step. @default false */
+  allowSkipDocumentCapture?: boolean;
+  /** Backend ADDRESS config field. Inverted: `disableSkipPoa: true` → skip disabled. If both are set, `allowSkipDocumentCapture` takes precedence. */
+  disableSkipPoa?: boolean;
+  /** Tutorial screen title override */
+  title?: string;
+  /** Tutorial screen text override */
+  text?: string;
+  /** Title override for the second-page tutorial (multi-page flows). Falls back to `title`. */
+  step2Title?: string;
+  /** Text override for the second-page tutorial (multi-page flows). Falls back to `text`. */
+  step2Text?: string;
+  /** Number of capture/upload attempts before auto-advancing. @default 3 */
+  captureAttempts?: number;
+  /** Send image as base64 instead of raw file. @default false */
+  sendBase64?: boolean;
+  /** Maximum file size in bytes. @default 10485760 (10MB) */
+  maxFileSize?: number;
+  /** Restrict uploads to PDF files only (camera capture is unaffected). @default false */
+  onlyPdf?: boolean;
+};
+type CapturedDocument = {
+  imageBase64: string;
+  file: File;
+  fileType: string;
+};
+type DocumentUploadResponse = {
+  success: boolean;
+  status?: 'ADD_NEXT_PAGE' | 'OPTIONAL_PAGE_CAPTURE' | 'SUCCESS';
+};
+type FinalizeDocumentResponse = {
+  status?: string;
+  success?: boolean;
+};
+type DocumentCaptureResolvedConfig = {
+  processingType: DocumentType;
+  /** Resolved: restrict to camera capture only (upload hidden). */
+  onlyCapture: boolean;
+  /** Resolved: restrict to file / photo-library upload only (camera hidden). */
+  onlyUpload: boolean;
+  allowSkipDocumentCapture: boolean;
+  captureAttempts: number;
+  sendBase64: boolean;
+  maxFileSize: number;
+  /** Resolved: restrict uploads to PDF files only. */
+  onlyPdf: boolean;
+  title: string | undefined;
+  text: string | undefined;
+  step2Title: string | undefined;
+  step2Text: string | undefined;
+};
+type DocumentCaptureNextPageType = 'none' | 'required' | 'optional';
+type DocumentCaptureContext = {
+  config: DocumentCaptureResolvedConfig;
+  stream: CameraStream | undefined;
+  permissionResult: PermissionResult | 'refresh' | undefined;
+  capturedDocument: CapturedDocument | undefined;
+  captureMethod: 'camera' | 'file' | 'gallery' | undefined;
+  /**
+   * Whether the capture-method selection surface (bottom sheet on mobile web,
+   * modal on desktop, upload-only selector) is open. Modeled in context — not
+   * as a discrete state — so the analytics mapper can name the selector screen
+   * while the machine stays in `tutorial`.
+   */
+  methodSelectionOpen: boolean;
+  /** Whether the "common issues" help overlay is open over the camera view. */
+  helpOpen: boolean;
+  progress: number;
+  error: DocumentCaptureErrorCode | DocumentCaptureFinalizeErrorCode | undefined;
+  attemptsRemaining: number;
+  pageNumber: number;
+  nextPageType: DocumentCaptureNextPageType;
+};
+type DocumentCaptureInput = {
+  config: DocumentCaptureConfig;
+};
+//#endregion
+export { DocumentCaptureErrorCode as a, DocumentType as c, DocumentCaptureContext as i, DocumentUploadResponse as l, DOCUMENT_CAPTURE_ERROR_CODES as n, DocumentCaptureInput as o, DocumentCaptureConfig as r, DocumentCaptureNextPageType as s, CapturedDocument as t, FinalizeDocumentResponse as u };

package/dist/types-EELWyWpd.d.ts

@@ -0,0 +1,6 @@
+import { i as FlowModuleConfig } from "./types-KPvmag_B.js";
+import { t as BaseFaceCaptureConfig } from "./types-Hmd7U0JA.js";
+//#region src/modules/authentication/types.d.ts
+type AuthenticationConfig = FlowModuleConfig['AUTHENTICATION'] & BaseFaceCaptureConfig;
+//#endregion
+export { AuthenticationConfig as t };