@incodetech/core 2.0.0-alpha.1 → 2.0.0-alpha.11

package/dist/flow.d.ts

@@ -0,0 +1,578 @@
+import { t as WasmPipeline } from "./warmup-Cijuyvoc.js";
+import { t as Manager } from "./Manager-Cy9-TMC9.js";
+import { t as AnyStateMachine } from "./StateMachine-BqPpBhOz.js";
+
+//#region src/modules/flow/types.d.ts
+type EmptyConfig = Record<string, never>;
+type RegulationTypes = 'US' | 'Worldwide' | 'Other' | 'US_Illinois' | 'US_Texas' | 'US_California' | 'US_Washington';
+type TutorialIdConfig = {
+  showTutorial: boolean;
+  enableId: boolean;
+  enablePassport: boolean;
+  onlyFront: boolean;
+  onlyBack: boolean;
+  barcodeCapture: boolean;
+  fetchAdditionalPage: boolean;
+  secondId: boolean;
+  thirdId: boolean;
+  autoCaptureTimeout: number;
+  deviceIdleTimeout: number;
+  captureAttempts: number;
+  manualUploadIdCapture: boolean;
+  digitalIdsUpload: boolean;
+  showDocumentChooserScreen: boolean;
+  enableIdRecording: boolean;
+  usSmartCapture: boolean;
+  perCountryPerDocOverrides: Record<string, Record<string, {
+    onlyFront: boolean;
+    onlyBack: boolean;
+    fetchAdditionalPage: boolean;
+  }>>;
+};
+type FlowModuleConfig = {
+  AUTHENTICATION: {
+    showTutorial: boolean;
+    autoCaptureTimeout: number;
+    numberOfAttempts: number;
+    type: 'ONE_TO_ONE';
+    deepsightLiveness: 'SINGLE_FRAME' | 'MULTIMODAL' | 'VIDEOLIVENESS';
+    validateClosedEyes: boolean;
+    validateFaceMask: boolean;
+    validateHeadCover: boolean;
+    validateLenses: boolean;
+  };
+  ADDRESS: {
+    disableSkipPoa: boolean;
+    title: string;
+    text: string;
+  };
+  AE_SIGNATURE: {
+    uploadDocument: boolean;
+    downloadDocument: boolean;
+    issuePermanentCertificate: boolean;
+    allowWithoutScoreValidation: boolean;
+    validationsToSkip: ('ID' | 'FACE_RECOGNITION' | 'OTP' | 'TOTAL_SCORE')[];
+  };
+  CURP_VALIDATION: {
+    curpDataMatch: boolean;
+    deceasedStatusVerification: boolean;
+  };
+  CUSTOM_FIELDS: {
+    title: string;
+    customFields: {
+      name: string;
+      alias: string;
+      type: 'INTEGER' | 'DOUBLE' | 'BOOLEAN' | 'STRING';
+    }[];
+  };
+  DOCUMENT_CAPTURE: {
+    processingType: 'capture' | 'processPoaOcr' | 'processLoaOcr' | 'processAsylumSeekerVisaZaf' | 'processBankStatementOCR' | 'processBankCheck' | 'processV5CLogbook' | 'processCarInvoice' | 'processCirculationCard' | 'processFinanceSettlement';
+    title: string;
+    text: string;
+    allowSkipDocumentCapture: boolean;
+  };
+  EKYB: {
+    checkBusinessName: boolean;
+    businessNameSource: 'userInput';
+    checkAddress: boolean;
+    address: 'userInput';
+    checkTaxId: boolean;
+    taxIdSource: 'userInput';
+    checkUniqueBeneficialOwner: boolean;
+    uniqueBeneficialOwnerSource: 'userInput';
+  };
+  EXTERNAL_VERIFICATION: {
+    source: 'US_DRIVERS_LICENSE_1' | 'US_TELCO_1' | 'US_TELCO_2' | 'US_CONSUMER_1' | 'US_CREDIT_BUREAU_1' | 'MX_CONSUMER_1' | 'BR_GOVT_1' | 'CA_RES_CREDIT' | 'UK_CREDIT_BUREAU_1' | 'ES_1' | 'CL_1' | 'AR_1' | 'GR_1' | 'GT_1' | 'BR_CPF_1';
+    checkName: boolean;
+    nameSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkEmail: boolean;
+    emailSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkAddress: boolean;
+    addressSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkPhone: boolean;
+    phoneSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkSsn: boolean;
+    ssnSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkDob: boolean;
+    dobSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkNationality: boolean;
+    nationalitySource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkDlNumber: boolean;
+    dlNumberSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkDlState: boolean;
+    dlStateSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkDlExpireAt: boolean;
+    dlExpireAtSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkLast4SSN: boolean;
+    last4SSNSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkIdNum: boolean;
+    idNumSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkIdNum1: boolean;
+    idNum1Source: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+    checkGender: boolean;
+    genderSource: 'userInput' | 'document' | 'poa' | 'phoneModuleInput' | 'emailModuleInput';
+  };
+  EMAIL: {
+    otpVerification: boolean;
+    otpExpirationInMinutes: number;
+    prefill?: boolean;
+  };
+  FACE_MATCH: {
+    matchingType: 'selfieVsId' | 'selfieVsNfc' | 'idVsNfc' | 'nfc3Way';
+    disableFaceMatchAnimation: boolean;
+  };
+  FINISH_GPT: {
+    finishgptCompanyName: string;
+  };
+  GEOLOCATION: {
+    allowUserToSkipGeolocation: boolean;
+  };
+  INE_VALIDATION: {
+    facialValidation: boolean;
+    alternativeFacialValidation: boolean;
+    fallbackEnabled: boolean;
+    scrapingMethod: boolean;
+    scrapingV2: boolean;
+    scrapingV3: boolean;
+    failUnsupportedId: boolean;
+    dataValidation: boolean;
+    backgroundExecution: boolean;
+    mockConnectionError: boolean;
+    mockUserNotFoundError: boolean;
+    mockOK: boolean;
+  };
+  GOVT_VALIDATION_PROVISIONING: {
+    validationCountries: string[];
+    facialValidation: boolean;
+    dataValidation: boolean;
+    faceAndDataValidation: boolean;
+    addressValidation: boolean;
+    backgroundExecution: boolean;
+    faceMatchOverrideDataScore: boolean;
+    useCroppedIdFacePhoto: boolean;
+  };
+  TUTORIAL_ID: TutorialIdConfig;
+  ID: TutorialIdConfig;
+  SECOND_ID: TutorialIdConfig;
+  THIRD_ID: TutorialIdConfig;
+  ID_OCR: {
+    editableOcr: boolean;
+  };
+  INCODE_WATCHLIST: {
+    failIfFaceOnBlocklist: boolean;
+    addSuspectedFraudAutomatically: boolean;
+    autoExecution: boolean;
+  };
+  INSTANT_BAV: {
+    bavVendorCountry: 'US' | 'CA' | 'AU' | 'NZ' | 'BR' | 'MX' | 'CO' | 'UK' | 'EU';
+    bavNumberOfRetries: number;
+  };
+  ML_CONSENT: {
+    consentType: RegulationTypes;
+  };
+  NFC_SCAN: {
+    nfcAvailability: boolean;
+    nfcValidation: boolean;
+    showInitialDataConfirmationScreen: boolean;
+  };
+  PHONE: {
+    otpVerification: boolean;
+    otpExpirationInMinutes: number;
+    prefill: boolean;
+  };
+  SELFIE: {
+    showTutorial: boolean;
+    showPreview: boolean;
+    assistedOnboarding: boolean;
+    enableFaceRecording: boolean;
+    autoCaptureTimeout: number;
+    captureAttempts: number;
+    validateLenses: boolean;
+    validateFaceMask: boolean;
+    validateHeadCover: boolean;
+    validateClosedEyes: boolean;
+    validateBrightness: boolean;
+    deepsightLiveness: 'SINGLE_FRAME' | 'MULTIMODAL' | 'VIDEOLIVENESS';
+  };
+  SIGNATURE: {
+    title: string;
+    subTitle: string;
+  };
+  USER_CONSENT: {
+    title: string;
+    text: string;
+  };
+  CONFERENCE: {
+    enableConferenceOtp: boolean;
+  };
+  VIDEO_ONBOARDING: {
+    useAsSelfie: boolean;
+    showTutorials: boolean;
+    companyName: string;
+    checkLiveness: boolean;
+    checkIdScan: boolean;
+    checkDocumentScan: boolean;
+    compareIdEnabled: boolean;
+    compareOcrEnabled: boolean;
+    compareBackIdEnabled: boolean;
+    compareBackOcrEnabled: boolean;
+    checkVoiceConsent: boolean;
+    voiceConsentQuestions: number;
+    selfieQualityAffectsScore: boolean;
+    maxWaitingVideoSelfieFile: number;
+    lastSecondsVideoQualityCheck: boolean;
+    lastSecondsVideoQualityCheckDuration: number;
+    validateClosedEyes: boolean;
+    validateFaceMask: boolean;
+    validateHeadCover: boolean;
+    validateLenses: boolean;
+  };
+  DYNAMIC_FORMS: {
+    screens: {
+      title: string;
+      hideTitle: boolean;
+      questions: {
+        questionId: string;
+        overrides: string | null;
+        isPredefined: boolean;
+        predefinedQuestionType: string | null;
+        question: string;
+        inputType: 'NUMBER' | 'CPF' | 'COUNTRY' | 'NATIONALITY' | 'DATE' | 'PHONE' | 'EMAIL' | 'TEXT' | 'MULTISELECT' | 'YESNO' | 'SELECT';
+        options: string[];
+      }[];
+    }[];
+  };
+  COMBINED_CONSENT: {
+    combinedConsents: string;
+  };
+  QE_SIGNATURE: {
+    uploadDocument: boolean;
+    downloadDocument: boolean;
+  };
+  CERTIFICATE_ISSUANCE: {
+    region: string;
+    type: 'ONE_TIME' | 'SHORT_TERM' | 'LONG_TERM';
+  };
+  ANTIFRAUD: EmptyConfig;
+  CHECKBOX_SIGNATURE: EmptyConfig;
+  CROSS_DOCUMENT_DATA_MATCH: EmptyConfig;
+  DEVICE_FINGERPRINT: EmptyConfig;
+  FACE_ONBOARDING: EmptyConfig;
+  FIELD_COMPARISON: EmptyConfig;
+  FISCAL_QR: EmptyConfig;
+  GENERATE_QR: EmptyConfig;
+  INSTANT_VERIFY: EmptyConfig;
+  IP_ADDRESS: EmptyConfig;
+  NAME_CAPTURE: EmptyConfig;
+  SHOW_RESULTS: EmptyConfig;
+  STADIUM_SELECTOR: EmptyConfig;
+  UNIVERSAL_IDENTITY: EmptyConfig;
+  WATCHLIST: EmptyConfig;
+  TRUST_GRAPH: EmptyConfig;
+  WATCHLIST_BUSINESS: EmptyConfig;
+};
+type FlowModule = { [K in keyof FlowModuleConfig]: {
+  key: K;
+  configuration: FlowModuleConfig[K];
+} }[keyof FlowModuleConfig];
+type Flow = {
+  flowId: string;
+  name: string;
+  autoApproveEnabled?: boolean;
+  autoApproveLevel?: 'LOW' | 'MEDIUM' | 'HIGH';
+  checkTutorials?: boolean;
+  checkAuthorization?: boolean;
+  redirectDesktopToMobile?: boolean;
+  disableUnsupportedBrowserScreen?: boolean;
+  qrPhishingResistance?: boolean;
+  addContinueToDesktop?: boolean;
+  redirectOriginOnly?: boolean;
+  displayOnboardingResultOnDesktop?: boolean;
+  enableMultipleOnboardings?: boolean;
+  disableLaunchScreen?: boolean;
+  enableSardineRisk?: boolean;
+  mandatoryConsentCheck?: boolean;
+  disableSmsOption?: boolean;
+  mergeSessionRecordings?: boolean;
+  ageAssurance?: boolean;
+  flowModules: FlowModule[];
+  enforceCaptureAttemptLimits?: boolean;
+  enableFraudAi?: boolean;
+  getEnableIdOnlyIdentity?: boolean;
+  ds?: boolean;
+};
+//#endregion
+//#region src/modules/flow/flowAnalyzer.d.ts
+/**
+ * Analyzes a flow configuration and returns the WASM pipelines needed.
+ * Use this to conditionally warmup WASM only when required by the flow.
+ *
+ * @param flow - The flow configuration from /omni/onboarding/flow
+ * @returns Array of WASM pipelines needed (e.g., ['selfie', 'idCapture'])
+ *
+ * @example
+ * ```typescript
+ * const pipelines = getRequiredWasmPipelines(flow);
+ * if (pipelines.length > 0) {
+ *   warmupWasm({ ...wasmConfig, pipelines });
+ * }
+ * ```
+ */
+declare function getRequiredWasmPipelines(flow: Flow): WasmPipeline[];
+//#endregion
+//#region src/modules/flow/flowCompletionService.d.ts
+type FinishStatus = {
+  redirectionUrl: string;
+  action: 'approved' | 'rejected' | 'none';
+  scoreStatus: 'OK' | 'WARN' | 'MANUAL_OK' | 'FAIL' | 'UNKNOWN' | 'MANUAL_FAIL';
+};
+type GetFinishStatusFn = (flowId: string | undefined | null, signal?: AbortSignal) => Promise<FinishStatus>;
+//#endregion
+//#region src/modules/flow/flowServices.d.ts
+type GetFlow = (signal: AbortSignal) => Promise<Flow>;
+//#endregion
+//#region src/modules/flow/flowActor.d.ts
+type CreateFlowActorOptions = {
+  getFlow?: GetFlow;
+};
+//#endregion
+//#region src/modules/flow/flowManager.d.ts
+/** Flow manager is waiting to be started */
+type FlowIdleState = {
+  status: 'idle';
+};
+/** Flow is being fetched from the server */
+type FlowLoadingState = {
+  status: 'loading';
+};
+/** Flow is loaded and ready for navigation */
+type FlowReadyState = {
+  status: 'ready';
+  /** The complete flow configuration from the server */
+  flow: Flow;
+  /** Array of module keys in order */
+  steps: string[];
+  /** Zero-based index of the current step */
+  currentStepIndex: number;
+  /** The module key of the current step (e.g., 'SELFIE', 'ID', 'FACE_MATCH') */
+  currentStep: string | undefined;
+  /** The configuration object for the current module. Type varies by module. */
+  config: unknown;
+};
+/** All steps have been completed */
+type FlowFinishedState = {
+  status: 'finished';
+  /** The complete flow configuration */
+  flow: Flow;
+};
+/** An error occurred while loading or processing the flow */
+type FlowErrorState = {
+  status: 'error';
+  /** The error message */
+  error: string;
+};
+/** Union of all possible flow states */
+type FlowState = FlowIdleState | FlowLoadingState | FlowReadyState | FlowFinishedState | FlowErrorState;
+/**
+ * Creates a flow manager instance for managing onboarding flow state and navigation.
+ *
+ * The flow manager provides:
+ * - State management with statuses: `idle`, `loading`, `ready`, `finished`, `error`
+ * - Step navigation with `nextStep()` and `prevStep()`
+ * - Current step info via `state.currentStep` and `state.config` when in `ready` state
+ * - Module configuration lookup via `getModuleConfig()`
+ *
+ * @param options - Optional configuration for the flow actor
+ * @param options.getFlow - Custom function to fetch flow data. Defaults to `getOnboardingFlow`
+ * @returns A manager instance with state subscription, API methods, and lifecycle controls
+ *
+ * @example
+ * ```ts
+ * const flowManager = createFlowManager();
+ *
+ * flowManager.subscribe((state) => {
+ *   if (state.status === 'ready') {
+ *     console.log(state.currentStep, state.config);
+ *   }
+ * });
+ *
+ * flowManager.load({ token: 'session-token' });
+ * ```
+ */
+declare function createFlowManager(options?: CreateFlowActorOptions): Manager<FlowState> & {
+  /**
+   * Loads the flow from the server.
+   * Transitions the state from `idle` to `loading`, then to `ready` on success or `error` on failure.
+   * Requires setup() to have been called with a token first.
+   */
+  load(): void;
+  /**
+   * Cancels the current loading operation and returns to `idle` state.
+   * Only effective when in `loading` state.
+   */
+  cancel(): void;
+  /**
+   * Resets the flow manager to its initial `idle` state.
+   * Can be called from `ready`, `finished`, or `error` states.
+   */
+  reset(): void;
+  /**
+   * Advances to the next step in the flow.
+   * If on the last step, transitions to `finished` state.
+   * Only effective when in `ready` state.
+   */
+  nextStep(): void;
+  /**
+   * Goes back to the previous step in the flow.
+   * Does nothing if already on the first step.
+   * Only effective when in `ready` state.
+   */
+  prevStep(): void;
+  /**
+   * Whether the flow can advance to the next step.
+   * Returns `true` if in `ready` state and not on the last step.
+   */
+  readonly canNext: boolean;
+  /**
+   * Whether the flow can go back to the previous step.
+   * Returns `true` if in `ready` state and not on the first step.
+   */
+  readonly canPrev: boolean;
+  /**
+   * Gets the configuration for a specific module by its key.
+   * Useful for accessing config of modules other than the current one.
+   * @param moduleKey - The unique key identifier of the module
+   * @returns The module configuration or `undefined` if not found or not in `ready` state
+   */
+  getModuleConfig: <T$1 = unknown>(moduleKey: string) => T$1 | undefined;
+  /**
+   * Checks if a module is enabled in the current flow.
+   * @param moduleKey - The unique key identifier of the module
+   * @returns `true` if the module exists in the flow, `false` otherwise or if not in `ready` state
+   */
+  isModuleEnabled: (moduleKey: string) => boolean;
+};
+//#endregion
+//#region src/modules/flow/moduleLoader.d.ts
+type LazyModule<T$1> = () => Promise<T$1>;
+type ModuleLoaderRegistry = {
+  [key: string]: LazyModule<{
+    default: unknown;
+  }>;
+};
+interface ModuleLoader {
+  load<T$1>(moduleKey: string): Promise<T$1>;
+  prefetch(moduleKey: string): void;
+  isLoaded(moduleKey: string): boolean;
+}
+declare function createModuleLoader(registry: ModuleLoaderRegistry): ModuleLoader;
+//#endregion
+//#region src/modules/flow/orchestratedFlowStateMachine.d.ts
+type GetFlowFn = (signal: AbortSignal) => Promise<Flow>;
+type ModuleRegistry = {
+  PHONE?: AnyStateMachine;
+  EMAIL?: AnyStateMachine;
+  SELFIE?: AnyStateMachine;
+  [key: string]: AnyStateMachine | undefined;
+};
+type OrchestratedFlowInput = {
+  getFlow: GetFlowFn;
+  modules: ModuleRegistry;
+  getFinishStatus?: GetFinishStatusFn;
+};
+type OrchestratedFlowEvent = {
+  type: 'LOAD';
+} | {
+  type: 'CANCEL';
+} | {
+  type: 'RESET';
+} | {
+  type: 'MODULE_COMPLETE';
+} | {
+  type: '*';
+  [key: string]: unknown;
+} | {
+  type: string;
+  [key: string]: unknown;
+};
+//#endregion
+//#region src/modules/flow/orchestratedFlowManager.d.ts
+type OrchestratedFlowIdleState = {
+  status: 'idle';
+};
+type OrchestratedFlowLoadingState = {
+  status: 'loading';
+};
+type OrchestratedFlowReadyState = {
+  status: 'ready';
+  flow: Flow;
+  steps: string[];
+  currentStepIndex: number;
+  currentStep: string | undefined;
+  config: unknown;
+  moduleState: unknown;
+};
+type OrchestratedFlowFinishedState = {
+  status: 'finished';
+  flow: Flow;
+  finishStatus: {
+    redirectionUrl: string;
+    action: 'approved' | 'rejected' | 'none';
+    scoreStatus: 'OK' | 'WARN' | 'MANUAL_OK' | 'FAIL' | 'UNKNOWN' | 'MANUAL_FAIL';
+  };
+};
+type OrchestratedFlowErrorState = {
+  status: 'error';
+  error: string;
+};
+type OrchestratedFlowState = OrchestratedFlowIdleState | OrchestratedFlowLoadingState | OrchestratedFlowReadyState | OrchestratedFlowFinishedState | OrchestratedFlowErrorState;
+type CreateOrchestratedFlowActorOptions = {
+  getFlow?: GetFlowFn;
+  modules: ModuleRegistry;
+  getFinishStatus?: OrchestratedFlowInput['getFinishStatus'];
+};
+declare function createOrchestratedFlowManager(options: CreateOrchestratedFlowActorOptions): Manager<OrchestratedFlowState> & {
+  /**
+   * Start loading the flow configuration from the backend.
+   */
+  load(): void;
+  /**
+   * Cancel an in-progress flow load.
+   */
+  cancel(): void;
+  /**
+   * Reset the flow to its initial idle state.
+   */
+  reset(): void;
+  /**
+   * Signal that the current module has completed successfully.
+   * Call this from your UI component's `onFinish` callback.
+   *
+   * @example
+   * ```tsx
+   * <Phone
+   *   config={config}
+   *   onFinish={() => flowManager.completeModule()}
+   * />
+   * ```
+   */
+  completeModule(): void;
+  /**
+   * Signal that the current module encountered an error.
+   * Call this from your UI component's `onError` callback if you want
+   * the flow to transition to an error state.
+   *
+   * @param error - Error message describing what went wrong
+   */
+  errorModule(error: string): void;
+  /**
+   * Send a raw event to the flow state machine.
+   * Prefer using the typed methods (completeModule, errorModule) when possible.
+   */
+  send(event: OrchestratedFlowEvent): void;
+  readonly canNext: boolean;
+  getModuleConfig: <T$1 = unknown>(moduleKey: string) => T$1 | undefined;
+  isModuleEnabled: (moduleKey: string) => boolean;
+};
+//#endregion
+export { type FinishStatus, type Flow, type FlowModule, type FlowModuleConfig, type FlowReadyState, type FlowState, type LazyModule, type ModuleLoader, type ModuleLoaderRegistry, type ModuleRegistry, type OrchestratedFlowFinishedState, type OrchestratedFlowInput, type OrchestratedFlowReadyState, type OrchestratedFlowState, createFlowManager, createModuleLoader, createOrchestratedFlowManager, getRequiredWasmPipelines };