@incodetech/prizma-core-screens 0.1.0

package/dist/flows.d.ts

@@ -0,0 +1,216 @@
+import type { ComponentType } from 'react';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { FaceCaptureCapturingState, FaceCaptureStrings } from './FaceCaptureStrings';
+import type { FaceMatchComparisonVariant, FaceMatchLivenessVerdict, FaceMatchResultStatus, FaceMatchStrings } from './FaceMatchStrings';
+import type { DocumentCaptureConfirmStage, DocumentCaptureMethodSelectionVariant, DocumentCaptureStrings, DocumentCaptureTutorialVariant } from './DocumentCaptureStrings';
+import type { IdCaptureDocumentType, IdCaptureSide, IdCaptureStageState, IdCaptureStrings } from './IdCaptureStrings';
+import { type IdCaptureTutorialVariant } from './IdCaptureTutorialScreen';
+import { type IdCaptureResultVerdict } from './IdCaptureResultScreen';
+/** The prop shape EVERY Face Capture screen accepts — the flow player needs
+ *  nothing more to render any step. */
+export interface FaceCaptureScreenProps {
+    strings: FaceCaptureStrings;
+    screenId?: string;
+    overrides?: PrizmaScreenOverrides;
+    onAction?: PrizmaScreenActionHandler;
+}
+/** Fixed variant props: they select the Figma spec section, never the copy. */
+export interface FaceCaptureFlowVariant {
+    /** FaceCaptureTutorialScreen — `faceCapture.tutorial.loading`. */
+    ctaLoading?: boolean;
+    /** FaceCaptureCapturingScreen — which of the 15 `capturing.*` sections. */
+    state?: FaceCaptureCapturingState;
+    /** FaceCaptureLoadingScreen — `loading.uploading` vs `loading.processing`. */
+    stage?: 'uploading' | 'processing';
+    /** FaceCaptureResultErrorScreen — the `*Exhausted` half of the error pairs. */
+    exhausted?: boolean;
+}
+export interface FaceCaptureFlowStep {
+    /** Stable screen id — also what the screen reports through `onAction`. */
+    screenId: string;
+    component: ComponentType<FaceCaptureScreenProps>;
+    variant?: FaceCaptureFlowVariant;
+}
+/**
+ * Face Capture — the happy path, in the order the purple Figma sections are
+ * numbered (1 tutorial → 2 capturing → 3 manualCapture → 4 loading →
+ * 5 resultSuccess), which is also GUIDELINES.md §8's canonical capture
+ * sequence.
+ *
+ * `faceCapture.resultError.*` and `faceCapture.genericErrors.noConnection` are
+ * NOT steps: they are branches the host swaps in when a verdict or the network
+ * fails. They are exported separately so a player can offer them without
+ * implying they follow success.
+ */
+export declare const faceCaptureFlow: readonly FaceCaptureFlowStep[];
+/** The off-path screens: manual capture (offered when auto-capture is turned
+ *  off or gives up), the two error verdicts, and the connectivity error. */
+export declare const faceCaptureBranches: readonly FaceCaptureFlowStep[];
+/** The prop shape EVERY Face Match screen accepts. */
+export interface FaceMatchScreenProps {
+    strings: FaceMatchStrings;
+    screenId?: string;
+    overrides?: PrizmaScreenOverrides;
+    onAction?: PrizmaScreenActionHandler;
+}
+/** Fixed variant props: they select the Figma spec section, never the copy. */
+export interface FaceMatchFlowVariant {
+    /** FaceMatchComparisonScreen — which purple photo set. */
+    variant?: FaceMatchComparisonVariant;
+    /** FaceMatchComparisonScreen — the converged `*.matching` sections. */
+    matching?: boolean;
+    /** FaceMatchResultScreen — `success.*` vs `error.*`. */
+    status?: FaceMatchResultStatus;
+    /** FaceMatchResultScreen — the `*.liveness{Success,Failed}` halves. */
+    liveness?: FaceMatchLivenessVerdict;
+}
+export interface FaceMatchFlowStep {
+    /** Stable screen id — also what the screen reports through `onAction`. */
+    screenId: string;
+    component: ComponentType<FaceMatchScreenProps>;
+    variant?: FaceMatchFlowVariant;
+}
+/**
+ * Face Match — the happy path: the two captured photos are presented, they
+ * converge while the comparison runs, and the verdict is a match.
+ *
+ * The other comparison variants (`nfc`, `firstAndSecondID`,
+ * `threeFacesMatching`), the photo-less compact matching state and the failing /
+ * liveness verdicts are branches, exported separately.
+ */
+export declare const faceMatchFlow: readonly FaceMatchFlowStep[];
+/**
+ * The off-path screens: the three-photo comparison variants (NFC portrait, or a
+ * second document, joining the selfie), the compact matching state shown when
+ * the captures are not displayed, and the five remaining verdicts.
+ *
+ * `comparison.threeFacesMatching` is the converged state of BOTH three-photo
+ * variants — Figma authors it once, with the labels hidden, so `nfc` stands in
+ * for either.
+ */
+export declare const faceMatchBranches: readonly FaceMatchFlowStep[];
+/** The prop shape EVERY Document Capture screen accepts. */
+export interface DocumentCaptureScreenProps {
+    strings: DocumentCaptureStrings;
+    screenId?: string;
+    overrides?: PrizmaScreenOverrides;
+    onAction?: PrizmaScreenActionHandler;
+}
+/** Fixed variant props: they select the Figma spec section, never the copy. */
+export interface DocumentCaptureFlowVariant {
+    /** DocumentCaptureTutorialScreen — which `tutorial.*` intro section. */
+    variant?: DocumentCaptureTutorialVariant;
+    /** DocumentCaptureMethodSelectionScreen — 2-row (web), 3-row (native), or the
+     *  native pair without the camera row (nativeUpload). */
+    method?: DocumentCaptureMethodSelectionVariant;
+    /** DocumentCaptureCaptureScreen — `capture.default` vs `capture.filled`. */
+    state?: 'empty' | 'filled';
+    /** DocumentCaptureConfirm*Screen — review / analyzing / success. */
+    stage?: DocumentCaptureConfirmStage;
+    /** DocumentCaptureNextPageScreen — the `.mandatory` half of the pair. */
+    mandatory?: boolean;
+    /** DocumentCaptureGenericErrorScreen — the `*Exhausted` half of the pair. */
+    exhausted?: boolean;
+}
+export interface DocumentCaptureFlowStep {
+    /** Stable screen id — also what the screen reports through `onAction`. */
+    screenId: string;
+    component: ComponentType<DocumentCaptureScreenProps>;
+    variant?: DocumentCaptureFlowVariant;
+}
+/**
+ * Document Capture BRANCHES at the tutorial: the method sheet sends the user
+ * down the camera path or the upload path, and the two paths have different
+ * confirmation screens (`confirmImage.*` vs `confirmUpload.*`). So the module
+ * ships three sequences instead of one:
+ *
+ *   documentCaptureFlow        the shared head — tutorial → method sheet
+ *   documentCaptureCameraFlow  capture → confirmImage(review→analyzing→success)
+ *   documentCaptureUploadFlow  confirmUpload(review→analyzing→success)
+ *
+ * `documentCaptureBranchesByMethod` maps the sheet's two answers onto the two
+ * tails, so a player can resolve the branch without hardcoding screen ids.
+ *
+ * Not steps in any sequence: `commonIssues` (help, reachable from the camera
+ * stage's "?" control), the two generic-error verdicts, and the connectivity
+ * error. They are exported as `documentCaptureBranches`.
+ */
+export declare const documentCaptureFlow: readonly DocumentCaptureFlowStep[];
+/** Tail A — "Take photo": the dark camera stage, then the photo confirmation. */
+export declare const documentCaptureCameraFlow: readonly DocumentCaptureFlowStep[];
+/** Tail B — "Upload document": the picker is OS chrome (DEVIATIONS #20), so the
+ *  Prizma sequence resumes at the file confirmation. */
+export declare const documentCaptureUploadFlow: readonly DocumentCaptureFlowStep[];
+/** The method sheet's two answers → the tail each one leads to. */
+export declare const documentCaptureBranchesByMethod: Readonly<Record<'camera' | 'upload', readonly DocumentCaptureFlowStep[]>>;
+/** The off-path screens: the two native method sheets, the multi-page prompt,
+ *  the common-issues help, the two error verdicts, and the connectivity error. */
+export declare const documentCaptureBranches: readonly DocumentCaptureFlowStep[];
+/** The prop shape EVERY ID Capture screen accepts — the flow player needs
+ *  nothing more to render any step. */
+export interface IdCaptureScreenProps {
+    strings: IdCaptureStrings;
+    screenId?: string;
+    overrides?: PrizmaScreenOverrides;
+    onAction?: PrizmaScreenActionHandler;
+}
+/** Fixed variant props: they select the Figma spec section, never the copy. */
+export interface IdCaptureFlowVariant {
+    /** IdCaptureTutorialScreen — which of the three tutorial sections. */
+    variant?: IdCaptureTutorialVariant;
+    /** IdCaptureStageScreen / IdCaptureResultScreen / IdCaptureAnalyzingScreen —
+     *  `id` vs `passport` (the `Passport capture` groups). */
+    documentType?: IdCaptureDocumentType;
+    /** IdCaptureStageScreen — which face of a two-sided document. */
+    side?: IdCaptureSide;
+    /** The `↕️ vertical` groups. */
+    vertical?: boolean;
+    /** IdCaptureStageScreen — which stage section. */
+    state?: IdCaptureStageState;
+    /** IdCaptureStageScreen — the `*-manual` sections. */
+    manual?: boolean;
+    /** IdCaptureResultScreen — which verdict section. */
+    verdict?: IdCaptureResultVerdict;
+    /** IdCaptureDocumentErrorScreen — the `-empty` section. */
+    empty?: boolean;
+}
+export interface IdCaptureFlowStep {
+    /** Stable screen id — also what the screen reports through `onAction`. */
+    screenId: string;
+    component: ComponentType<IdCaptureScreenProps>;
+    variant?: IdCaptureFlowVariant;
+}
+/**
+ * ID Capture — the happy path of a TWO-SIDED document, in the order the purple
+ * sections are numbered: document selection (1-1) → tutorial (1-2) → camera
+ * stage (1-5 … 1-8) → analyzing (1-9-1) → review (1-9-2) → front success (1-10)
+ * → flip (1-11) → back stage (1-12 … 1-15) → back analyzing (1-16-1) → back
+ * success (1-17) → hold on (1-18).
+ *
+ * The passport path is the same list without the flip and the back half, with
+ * `documentType: 'passport'` on every capture step (the `Passport capture`
+ * group's numbering, 3-x, mirrors it exactly) — see `idCapturePassportFlow`.
+ * Failures and the chrome-free error screens are branches, not steps, so they
+ * are exported separately: nothing about them follows success.
+ */
+export declare const idCaptureFlow: readonly IdCaptureFlowStep[];
+/** The single-sided passport path — the `Passport capture` group (3-x). */
+export declare const idCapturePassportFlow: readonly IdCaptureFlowStep[];
+/**
+ * The off-path screens: the manual stage (offered when auto-capture is turned
+ * off or gives up), the five on-camera error stages, every verdict failure, the
+ * help sheet, the permission gate, the document-error screens and the
+ * connectivity error.
+ *
+ * The `↕️ vertical` groups are not separate branches — they are the same steps
+ * with `vertical: true`, which is why `idCaptureVerticalOf` exists below.
+ */
+export declare const idCaptureBranches: readonly IdCaptureFlowStep[];
+/**
+ * The `ID capture ↕️ vertical` (2-x) and `Passport capture ↕️ vertical` (4-x)
+ * groups: the SAME steps with the portrait frame. Kept as a derivation rather
+ * than two more literal lists, because that is precisely what the Figma groups
+ * are — the numbering, the states and the copy are identical and only
+ * `PrizmaIdCapture.isVertical` flips.
+ */
+export declare const idCaptureVerticalOf: (steps: readonly IdCaptureFlowStep[]) => readonly IdCaptureFlowStep[];