@baas-id/react 0.2.2

package/dist/types/react/face/qualityGate.d.ts

@@ -0,0 +1,59 @@
+import type { GuideKey } from "../i18n";
+import type { FaceSignals } from "../liveness";
+import type { PixelData } from "../vision/authenticity";
+export interface SelfieQualityFloors {
+    iod_frac_min: number | null;
+    iod_px_min: number | null;
+    sharpness_min: number | null;
+    luma_min: number | null;
+    luma_max: number | null;
+    contrast_min: number | null;
+    yaw_max: number | null;
+}
+export declare const SELFIE_QUALITY_DEFAULTS: SelfieQualityFloors;
+export declare const CROP_SIZE = 112;
+export declare const QUALITY_RETAKE_MS = 6000;
+export declare const QUALITY_PASS_FRAMES = 2;
+export interface SelfieQualityReading {
+    iodFrac: number;
+    iodPx: number;
+    sharpness: number;
+    luma: number;
+    contrast: number;
+    yaw: number;
+}
+export type QualityIssue = Extract<GuideKey, "move_closer" | "hold_still" | "too_dark" | "too_bright" | "find_light" | "look_straight">;
+export declare function floorsFrom(over?: Partial<Record<keyof SelfieQualityFloors, unknown>> | null): SelfieQualityFloors;
+export declare function selfieQualityIssue(r: SelfieQualityReading, f: SelfieQualityFloors): QualityIssue | null;
+export interface CropStats {
+    sharpness: number;
+    luma: number;
+    contrast: number;
+}
+export declare function faceCropStats(px: PixelData, box: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}): CropStats;
+export declare function readingFrom(sig: FaceSignals, stats: CropStats, frameW: number): SelfieQualityReading;
+export interface QualityIo {
+    alive(): boolean;
+    wait(ms: number): Promise<void>;
+    now(): number;
+    read(): Promise<{
+        sig: FaceSignals;
+        stats: CropStats;
+        frameW: number;
+    } | null>;
+}
+export type QualityResult = {
+    ok: true;
+    reading: SelfieQualityReading;
+} | {
+    ok: false;
+    issue: QualityIssue;
+} | null;
+export declare function holdForQuality(io: QualityIo, floors: SelfieQualityFloors, ui: {
+    guide(k: GuideKey): void;
+}, tickMs: number): Promise<QualityResult>;

package/dist/types/react/face/runLiveness.d.ts

@@ -0,0 +1,37 @@
+import type { GuideKey, Strings, TeleRecipe } from "../i18n";
+import { type ChallengeKind, type FaceSignals, type LivenessTracker, type Proximity } from "../liveness";
+export interface Framing {
+    found: boolean;
+    faceFrac: number;
+    faceW: number;
+    proximity: Proximity;
+}
+export interface LivenessIo {
+    alive(): boolean;
+    wait(ms: number): Promise<void>;
+    read(): Promise<FaceSignals | null>;
+    strings(): Strings;
+    now(): number;
+    keyframe?(tag: string): void;
+}
+export interface LivenessUi {
+    locked(): void;
+    step(i: number): void;
+    fill(centering: number): void;
+    framing(f: Framing): void;
+    guide(k: GuideKey): void;
+    progress(p: number): void;
+    yaw(yaw: number, confidence: number): void;
+    tele(text: TeleRecipe): void;
+    hold?(p: number): void;
+}
+export type LivenessResult = {
+    k: "passed";
+    reissues: number;
+} | {
+    k: "failed";
+    reason: string;
+} | {
+    k: "aborted";
+};
+export declare function runLiveness(script: ChallengeKind[], tracker: LivenessTracker, io: LivenessIo, ui: LivenessUi): Promise<LivenessResult>;

package/dist/types/react/face/scanState.d.ts

@@ -0,0 +1,40 @@
+import type { GuideKey } from "../i18n";
+import type { Ellipse } from "./faceView";
+export type ScanState = "searching" | "position" | "distance" | "light" | "steady" | "aligned" | "challenge" | "verifying" | "done" | "error";
+export declare function scanStateOf(s: {
+    error: string | null;
+    phase: string;
+    step: number;
+    total: number;
+    found: boolean;
+    guide: GuideKey | string;
+}): ScanState;
+export declare const isLocked: (s: ScanState) => s is "challenge" | "done" | "aligned" | "verifying";
+export declare function meshLevel(s: ScanState): number;
+export declare function segmentFills(s: {
+    step: number;
+    total: number;
+    hold: number;
+    progress: number;
+    done: boolean;
+}): number[];
+export declare function ellipsePerimeter(rx: number, ry: number): number;
+export interface Dash {
+    dasharray: string;
+    dashoffset: number;
+    length: number;
+}
+export declare function ringSegments(fills: readonly number[], perimeter: number, gap: number): Dash[];
+export declare function ellipseArc(o: Ellipse, a0: number, a1: number, n?: number): {
+    d: string;
+    length: number;
+};
+export declare const grow: (o: Ellipse, pad: number) => Ellipse;
+export declare function cueVisible(guide: GuideKey | string, progress: number): boolean;
+export declare const cueTone: (guide: GuideKey | string) => "go" | "wrong";
+export declare function fillLightNext(on: boolean, guide: GuideKey | string, state: ScanState): boolean;
+export declare function springEasing(stiffness?: number, damping?: number, samples?: number): {
+    easing: string;
+    ms: number;
+};
+export declare function serverReasonText(detail: unknown): string | null;

package/dist/types/react/face/upload.d.ts

@@ -0,0 +1,14 @@
+import { type AttestationProvider, type DeviceSignals, type Keyframe, type TimelineSummary } from "../capture";
+export interface FaceEvidence {
+    capture: Record<string, unknown> | null;
+    keyframes: Blob[];
+}
+export declare function faceEvidence(input: {
+    nonce: string | null | undefined;
+    frame: Blob;
+    keyframes: readonly Keyframe[];
+    timeline: TimelineSummary;
+    device: DeviceSignals | null;
+    attestation?: AttestationProvider;
+    stream?: MediaStream | null;
+}): Promise<FaceEvidence>;

package/dist/types/react/face/useFaceCapture.d.ts

@@ -0,0 +1,45 @@
+import { type RefObject } from "react";
+import { type EngineProgress } from "../vision";
+import { type ChallengeKind } from "../liveness";
+import { type GuideKey } from "../i18n";
+import type { FaceCaptureProps } from "../FaceCapture";
+import { PointsMotion } from "../document/track";
+import { type Framing } from "./runLiveness";
+export type FacePhase = "searching" | "locked" | "uploading" | "error";
+export declare function useFaceCapture(props: FaceCaptureProps): {
+    t: import("../i18n").Strings;
+    source: "camera" | "demo";
+    script: ChallengeKind[];
+    step: number;
+    phase: FacePhase;
+    tele: string;
+    fill: number;
+    challengeProgress: number;
+    guide: GuideKey;
+    error: string | null;
+    errorDetail: unknown;
+    loadProgress: EngineProgress | null;
+    engineReady: boolean;
+    framing: Framing;
+    yaw: {
+        value: number;
+        confidence: number;
+    };
+    retry: () => void;
+    retriesLeft: number | null;
+    final: boolean;
+    src: {
+        w: number;
+        h: number;
+    };
+    hold: number;
+    motion: PointsMotion;
+    oval: {
+        cx: number;
+        cy: number;
+        rx: number;
+        ry: number;
+    };
+    videoRef: RefObject<HTMLVideoElement | null>;
+    canvasRef: RefObject<HTMLCanvasElement | null>;
+};

package/dist/types/react/flows/ConsentStep.d.ts

@@ -0,0 +1,8 @@
+import type { Strings } from "../i18n";
+import type { ConsentChoice, ModelImprovementPrompt } from "./types";
+export declare function ConsentStep({ prompt, locale, t, onChoice, }: {
+    prompt: ModelImprovementPrompt;
+    locale: string;
+    t: Strings;
+    onChoice: (c: ConsentChoice) => void;
+}): import("react").JSX.Element;

package/dist/types/react/flows/EnrollmentFlow.d.ts

@@ -0,0 +1,2 @@
+import type { EnrollmentFlowProps } from "./types";
+export declare function EnrollmentFlow(props: EnrollmentFlowProps): import("react").JSX.Element;

package/dist/types/react/flows/FlowResult.d.ts

@@ -0,0 +1,13 @@
+import { type Locale, type StringOverrides, type Strings } from "../i18n";
+import type { VerificationResult } from "./types";
+export declare function FlowResult({ result, t }: {
+    result: VerificationResult;
+    t: Strings;
+}): import("react").JSX.Element;
+export declare function IdentifyOutcome({ reason, locale, overrides, onRestart, t, }: {
+    reason: string;
+    locale?: Locale;
+    overrides?: StringOverrides;
+    onRestart: () => void;
+    t: Strings;
+}): import("react").JSX.Element;

package/dist/types/react/flows/FlowShell.d.ts

@@ -0,0 +1,48 @@
+import { type ReactNode } from "react";
+import { type Locale, type StringOverrides, type Strings } from "../i18n";
+import { type CaptureId, type FailureCause, type FailureText, type RetakeNotice, type Side, type Step, type Thumbs } from "./state";
+import type { Purpose } from "./types";
+import { type Appearance } from "../theme/appearance";
+export declare function FlowShell({ step, purpose, title, t, children, privacy, appearance, forceAppearance, screen, manageFocus, }: {
+    step: Step;
+    purpose: Purpose;
+    title: string;
+    t: Strings;
+    children: ReactNode;
+    privacy?: string | null;
+    appearance?: Appearance | null;
+    forceAppearance?: boolean;
+    screen?: string;
+    manageFocus?: boolean;
+}): import("react").JSX.Element;
+export declare function StepRail({ step, t, plan, retakes, }: {
+    step: Step;
+    t: Strings;
+    plan?: readonly CaptureId[];
+    retakes?: Partial<Record<Side, RetakeNotice>>;
+}): import("react").JSX.Element;
+export declare function RetakeNoticeLine({ notice, side, t }: {
+    notice: RetakeNotice;
+    side: Side;
+    t: Strings;
+}): import("react").JSX.Element;
+export declare function EvidenceTray({ thumbs, t, plan, }: {
+    thumbs: Thumbs;
+    t: Strings;
+    plan?: readonly CaptureId[];
+}): import("react").JSX.Element;
+export declare function Preparing({ label, note }: {
+    label: string;
+    note?: string;
+}): import("react").JSX.Element;
+export declare function Failure({ reason, verdict, cause, text, locale, overrides, onRestart, t, takeFocus, }: {
+    reason: string;
+    verdict?: "REJECTED" | "NEEDS_REVIEW";
+    cause?: FailureCause;
+    text?: FailureText;
+    locale?: Locale;
+    overrides?: StringOverrides;
+    onRestart: () => void;
+    t: Strings;
+    takeFocus?: boolean;
+}): import("react").JSX.Element;

package/dist/types/react/flows/IdentifyFlow.d.ts

@@ -0,0 +1,2 @@
+import type { IdentifyFlowProps } from "./types";
+export declare function IdentifyFlow(props: IdentifyFlowProps): import("react").JSX.Element;

package/dist/types/react/flows/ReverificationFlow.d.ts

@@ -0,0 +1,2 @@
+import type { ReverificationFlowProps } from "./types";
+export declare function ReverificationFlow(props: ReverificationFlowProps): import("react").JSX.Element;

package/dist/types/react/flows/SignInFlow.d.ts

@@ -0,0 +1,2 @@
+import type { SignInFlowProps } from "./types";
+export declare function SignInFlow(props: SignInFlowProps): import("react").JSX.Element;

package/dist/types/react/flows/StepIntro.d.ts

@@ -0,0 +1,10 @@
+import type { Strings } from "../i18n";
+import type { CaptureId } from "./state";
+export declare function StepIntro({ step, body, t, movements, sessionMinutes, onStart, }: {
+    step: CaptureId;
+    body: string;
+    t: Strings;
+    movements?: number;
+    sessionMinutes?: number | null;
+    onStart: () => void;
+}): import("react").JSX.Element;

package/dist/types/react/flows/VerificationFlow.d.ts

@@ -0,0 +1,4 @@
+import type { Purpose, VerificationFlowProps } from "./types";
+export declare function VerificationFlow(props: VerificationFlowProps & {
+    purpose: Purpose;
+}): import("react").JSX.Element;

package/dist/types/react/flows/experience.d.ts

@@ -0,0 +1,35 @@
+import type { Locale, StringOverrides, Strings } from "../i18n";
+import type { CaptureId } from "./state";
+export interface IntroText {
+    title?: string;
+    body?: string;
+}
+export interface TenantInstructions {
+    enabled?: boolean;
+    confirmCapture?: boolean;
+    front?: StepInstructions;
+    back?: StepInstructions;
+    face?: StepInstructions;
+}
+export interface StepInstructions {
+    enabled?: boolean;
+    en?: IntroText;
+    "es-419"?: IntroText;
+}
+export interface TenantReasonText {
+    title?: string;
+    description?: string;
+    action?: string;
+}
+export type TenantMessages = Partial<Record<Locale, Record<string, TenantReasonText>>>;
+export declare function normalizeInstructions(raw: unknown): TenantInstructions | undefined;
+export declare function normalizeMessages(raw: unknown): TenantMessages | undefined;
+export declare function introEnabled(step: CaptureId, ins?: TenantInstructions | null): boolean;
+export declare function confirmEnabled(ins?: TenantInstructions | null): boolean;
+export declare function introFor(step: CaptureId, locale: Locale, t: Strings, ins?: TenantInstructions | null): Required<IntroText>;
+export declare function parseIntroBody(body: string): {
+    paragraphs: string[];
+    items: string[];
+};
+export declare function tenantReasonOverrides(messages: TenantMessages | undefined, locale: Locale, t: Strings): StringOverrides | undefined;
+export declare function mergeOverrides(tenant?: StringOverrides, host?: StringOverrides): StringOverrides | undefined;

package/dist/types/react/flows/failureDetail.d.ts

@@ -0,0 +1,12 @@
+export interface FailureText {
+    code: string;
+    reason: string;
+    reason_title: string;
+    reason_description: string;
+}
+export declare function hasReasonText(detail: unknown): boolean;
+export declare function reasonTextOf(detail: unknown): {
+    title?: string;
+    description?: string;
+} | null;
+export declare function withFailureText(detail: unknown, text: FailureText): unknown;

package/dist/types/react/flows/index.d.ts

@@ -0,0 +1,6 @@
+export { EnrollmentFlow } from "./EnrollmentFlow";
+export { SignInFlow } from "./SignInFlow";
+export { ReverificationFlow } from "./ReverificationFlow";
+export { IdentifyFlow } from "./IdentifyFlow";
+export { normalizeSession, captureNonceOf } from "./session";
+export type { EnrollmentFlowProps, SignInFlowProps, ReverificationFlowProps, IdentifyFlowProps, VerificationFlowProps, Purpose, IdentifyCandidate, DuplicateCandidate, ModelImprovementPrompt, ConsentChoice, OpenSessionContext, RpidSession, ApiSessionBody, SessionFlow, VerificationResult, VerificationAssessment, RpidFlowEvent, DocumentAuthenticity, ExtractionRecord, ExtractionField, Appearance, TenantInstructions, TenantMessages, SessionHandoff, HandoffOption, } from "./types";

package/dist/types/react/flows/session.d.ts

@@ -0,0 +1,5 @@
+import type { RpidSession, SessionFlow } from "./types";
+export declare function normalizeFlow(raw: unknown): SessionFlow | undefined;
+export declare function normalizeSession(raw: unknown): RpidSession;
+export declare const captureNonceOf: (s: RpidSession | null | undefined) => string | null;
+export declare function warnUnbound(s: RpidSession, source: "camera" | "demo"): void;

package/dist/types/react/flows/state.d.ts

@@ -0,0 +1,106 @@
+import type { Strings } from "../i18n";
+import type { Purpose, RpidSession, SessionFlow, VerificationResult } from "./types";
+export type Side = "front" | "back";
+export type CaptureId = Side | "face";
+export declare const FULL_ENROLLMENT: readonly CaptureId[];
+export declare function captureSteps(purpose: Purpose, flow?: SessionFlow | null): CaptureId[];
+export declare const isFaceOnly: (purpose: Purpose) => purpose is "signin" | "identify";
+export declare const NEUTRAL_OUTCOMES: readonly string[];
+export type Settlement = {
+    kind: "verified";
+} | {
+    kind: "concluded";
+    reason: string;
+    verdict: "REJECTED" | "NEEDS_REVIEW";
+};
+export declare function settleFinalize(result: Pick<VerificationResult, "verdict" | "reason">): Settlement;
+export type Step = {
+    k: "opening";
+} | {
+    k: "doc";
+    side: Side;
+} | {
+    k: "face";
+} | {
+    k: "finalizing";
+} | {
+    k: "done";
+    result: VerificationResult;
+} | {
+    k: "failed";
+    reason: string;
+    verdict?: "REJECTED" | "NEEDS_REVIEW";
+    cause?: FailureCause;
+    text?: FailureText;
+};
+export interface FailureCause {
+    reason: string;
+    title?: string;
+    description?: string;
+}
+export interface FailureText {
+    title?: string;
+    description?: string;
+}
+export interface RetakeNotice {
+    reason: string;
+    title?: string;
+    description?: string;
+    from?: Side;
+}
+export type Thumbs = {
+    front?: string;
+    back?: string;
+};
+export interface FlowState {
+    step: Step;
+    session: RpidSession | null;
+    thumbs: Thumbs;
+    plan: CaptureId[];
+    faceRetriesLeft?: number;
+    retakes?: Partial<Record<Side, RetakeNotice>>;
+}
+export type FlowAction = {
+    type: "open";
+} | {
+    type: "opened";
+    session: RpidSession;
+    purpose: Purpose;
+} | {
+    type: "docCaptured";
+    side: Side;
+    thumb?: string;
+} | {
+    type: "finalizing";
+} | {
+    type: "verified";
+    result: VerificationResult;
+} | {
+    type: "failed";
+    reason: string;
+    verdict?: "REJECTED" | "NEEDS_REVIEW";
+    cause?: FailureCause;
+    text?: FailureText;
+} | {
+    type: "retake";
+    from: Side;
+    target: Side;
+    notice: RetakeNotice;
+} | {
+    type: "faceRetry";
+    retriesLeft: number;
+} | {
+    type: "remote";
+};
+export declare const INITIAL_FLOW: FlowState;
+export declare function flowReducer(state: FlowState, action: FlowAction): FlowState;
+export declare const isCapturing: (s: Step) => s is {
+    k: "doc";
+    side: Side;
+} | {
+    k: "face";
+};
+export declare function railIndex(s: Step, plan?: readonly CaptureId[]): number;
+export declare function titleFor(step: Step, purpose: Purpose, t: Strings): string;
+export declare function finalizingLabel(purpose: Purpose, t: Strings): string;
+export declare const stepKey: (s: Step) => string;