@baas-id/react 0.2.2

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

@@ -0,0 +1,255 @@
+import type { Locale, StringOverrides } from "../i18n";
+import type { DocumentAuthenticity } from "../capture";
+import type { SelfieQualityFloors } from "../face/qualityGate";
+import type { Appearance } from "../theme/appearance";
+import type { TenantInstructions, TenantMessages } from "./experience";
+export type { Appearance, TenantInstructions, TenantMessages };
+export type { DocumentAuthenticity };
+export interface ExtractionField {
+    value: unknown;
+    sources: string[];
+    agreed?: boolean;
+    candidates?: Record<string, unknown>;
+}
+export interface ExtractionRecord {
+    schema_version: string;
+    fields: Record<string, ExtractionField>;
+    sources: Array<{
+        kind: string;
+        format?: string;
+        raw?: unknown;
+        valid?: boolean;
+    }>;
+    portrait: {
+        present: boolean;
+        box: number[] | null;
+        image: string | null;
+        detector: string | null;
+        score?: number | null;
+        faces_found?: number;
+        ghosts?: Array<{
+            box: number[];
+            score: number;
+        }>;
+    };
+    checks: {
+        cross_source_agreement: boolean | null;
+        conflicts: string[];
+        sources_present: string[];
+    };
+    warnings?: string[];
+    extraction?: {
+        side: string;
+        barcode_engine: string;
+        symbols_found: number;
+        symbologies: string[];
+        mrz_found: boolean;
+        elapsed_ms: number;
+    };
+}
+export interface RpidSession {
+    sessionId: string;
+    captureToken: string;
+    challengeScript?: string[];
+    expiresInS?: number;
+    flow?: SessionFlow;
+}
+export interface ApiSessionBody {
+    session_id: string;
+    capture_token: string;
+    challenge_script?: string[];
+    expires_in_s?: number;
+    flow?: {
+        document?: boolean;
+        document_sides?: "front_back" | "front";
+        locale?: Locale | "auto";
+        liveness?: boolean;
+        appearance?: Appearance;
+        instructions?: TenantInstructions;
+        messages?: TenantMessages;
+        quality?: {
+            selfie?: Record<string, number | null> | null;
+        } | null;
+        capture?: {
+            v?: number;
+            nonce?: string;
+        } | null;
+        handoff?: {
+            mode?: "auto" | "suggest";
+            ttl_s?: number;
+            copy?: Partial<Record<Locale, {
+                title?: string;
+                body?: string;
+            }>>;
+            role?: "phone";
+            tenant?: string;
+            code_hint?: string;
+        };
+        progress?: boolean;
+        test?: boolean;
+    };
+}
+export interface SessionFlow {
+    document?: boolean;
+    documentSides?: "front_back" | "front";
+    locale?: Locale;
+    appearance?: Appearance;
+    instructions?: TenantInstructions;
+    messages?: TenantMessages;
+    quality?: {
+        selfie?: Partial<Record<keyof SelfieQualityFloors, number | null>> | null;
+    } | null;
+    capture?: {
+        v?: number;
+        nonce?: string;
+    } | null;
+    handoff?: SessionHandoff;
+    progress?: boolean;
+    test?: boolean;
+}
+export interface SessionHandoff {
+    mode?: "auto" | "suggest";
+    ttlS?: number;
+    copy?: Partial<Record<Locale, {
+        title?: string;
+        body?: string;
+    }>>;
+    role?: "phone";
+    tenant?: string;
+    codeHint?: string;
+}
+export type HandoffOption = false | {
+    mode?: "auto" | "suggest";
+    device?: "mobile" | "tablet" | "desktop";
+};
+export interface VerificationResult {
+    verdict: "VERIFIED" | "REJECTED" | "NEEDS_REVIEW";
+    purpose: Purpose;
+    reason: string | null;
+    score: number | null;
+    assurance: string;
+    policy_version: string;
+    verification_token?: string;
+    test?: boolean;
+    handoff?: {
+        continue_on: "desktop";
+    };
+    assessment?: VerificationAssessment;
+    candidates?: IdentifyCandidate[];
+    duplicates?: DuplicateCandidate[];
+    subject_ref?: string | null;
+}
+export interface IdentifyCandidate {
+    subject_ref: string;
+    score: number;
+    enrolled_at?: string;
+}
+export interface DuplicateCandidate {
+    subject_ref: string;
+    score: number;
+}
+export interface VerificationAssessment {
+    decision: "verified" | "rejected" | "needs_review";
+    risk?: number;
+    reason?: string;
+}
+export type RpidFlowEvent = {
+    type: "session.created";
+    sessionId: string;
+    purpose: Purpose;
+    bound: boolean;
+} | {
+    type: "session.failed";
+    reason: string;
+} | {
+    type: "document.captured";
+    side: "front" | "back";
+    authenticity?: DocumentAuthenticity;
+} | {
+    type: "document.extracted";
+    side: "front" | "back";
+    record: ExtractionRecord;
+} | {
+    type: "document.rejected";
+    reason: string;
+    retriesLeft?: number;
+    authenticity?: DocumentAuthenticity;
+} | {
+    type: "document.retake";
+    side: "front" | "back";
+    target: "front" | "back";
+    reason: string;
+    mismatches?: string[];
+} | {
+    type: "face.captured";
+} | {
+    type: "face.rejected";
+    reason: string;
+    retriesLeft?: number;
+} | {
+    type: "processing.started";
+} | {
+    type: "verification.completed";
+    assurance: string;
+    score: number | null;
+    assessment?: VerificationAssessment;
+} | {
+    type: "handoff.created";
+    codeHint: string;
+    expiresInS: number;
+} | {
+    type: "handoff.claimed";
+    device: string | null;
+} | {
+    type: "handoff.finished";
+    verdict: string;
+} | {
+    type: "handoff.revoked";
+    reason: "continue_here" | "cancel";
+} | {
+    type: "verification.rejected";
+    reason: string;
+    verdict?: "REJECTED" | "NEEDS_REVIEW";
+    assessment?: VerificationAssessment;
+};
+export interface ModelImprovementPrompt {
+    text: string;
+    version: string;
+    language?: string;
+    learnMoreUrl?: string;
+    learnMoreLabel?: string;
+}
+export interface ConsentChoice {
+    modelImprovement: boolean;
+    version: string;
+    language: string;
+    acceptedAt: string;
+}
+export interface OpenSessionContext {
+    consent?: ConsentChoice;
+}
+export interface VerificationFlowProps {
+    apiUrl: string;
+    openSession: (signal?: AbortSignal, context?: OpenSessionContext) => Promise<RpidSession | ApiSessionBody>;
+    consent?: {
+        modelImprovement?: ModelImprovementPrompt;
+    };
+    privacyNote?: string | null;
+    modelsUrl?: string;
+    detector?: "tiny" | "legacy";
+    source?: "camera" | "demo";
+    locale?: Locale;
+    strings?: StringOverrides;
+    challengeMs?: number;
+    debug?: boolean;
+    onVerified: (result: VerificationResult) => void | Promise<void>;
+    onFailed?: (reason: string, detail?: unknown) => void;
+    onEvent?: (event: RpidFlowEvent) => void;
+    handoff?: HandoffOption;
+    diagnostics?: boolean;
+}
+export type Purpose = "enrollment" | "signin" | "reverification" | "identify";
+export type EnrollmentFlowProps = VerificationFlowProps;
+export type SignInFlowProps = VerificationFlowProps;
+export type ReverificationFlowProps = VerificationFlowProps;
+export type IdentifyFlowProps = VerificationFlowProps;

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

@@ -0,0 +1,21 @@
+import { type RpidClientConfig } from "../capture";
+import { type FlowState, type Side } from "./state";
+import type { SideRetake } from "../DocumentCapture";
+import type { ConsentChoice, Purpose, VerificationFlowProps, VerificationResult } from "./types";
+export declare function useFlowSession({ purpose, apiUrl, openSession, locale, strings: overrides, onVerified, onFailed, onEvent, source, consentChoice, diagnostics, }: VerificationFlowProps & {
+    purpose: Purpose;
+    consentChoice?: ConsentChoice | null;
+}): {
+    state: FlowState;
+    t: import("../i18n").Strings;
+    locale: import("../i18n").Locale;
+    overrides: import("../i18n").StringOverrides | undefined;
+    config: RpidClientConfig | null;
+    restart: () => undefined;
+    docCaptured: (side: Side, serverResult: unknown, thumb?: string) => void;
+    captureRejected: (kind: "document" | "face", reason: string, detail?: unknown) => void;
+    faceCaptured: () => Promise<void>;
+    docRetake: (r: SideRetake) => void;
+    remoteResult: (result: VerificationResult) => Promise<void>;
+    failWith: (code: string) => void;
+};

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

@@ -0,0 +1 @@
+export * from "./flows/index";

package/dist/types/react/handoff/ContinueFlow.d.ts

@@ -0,0 +1,28 @@
+import { type Locale, type StringOverrides, type Strings } from "../i18n";
+import type { RpidFlowEvent } from "../flows/types";
+export declare function readHandoffCode(search?: string, pathname?: string, hash?: string): string | null;
+export interface ContinueFlowProps {
+    apiUrl: string;
+    code: string | null;
+    modelsUrl?: string;
+    locale?: Locale;
+    strings?: StringOverrides;
+    privacyNote?: string | null;
+    source?: "camera" | "demo";
+    debug?: boolean;
+    onEvent?: (e: RpidFlowEvent) => void;
+    onDone?: (outcome: {
+        verdict: string;
+        reason: string | null;
+    }) => void;
+}
+export declare function ContinueFlow({ apiUrl, code, modelsUrl, locale: hostLocale, strings, privacyNote, source, debug, onEvent, onDone, }: ContinueFlowProps): import("react").JSX.Element;
+export declare function ContinueConfirmView({ t, tenant, codeHint, onContinue }: {
+    t: Strings;
+    tenant: string;
+    codeHint: string;
+    onContinue?: () => void;
+}): import("react").JSX.Element;
+export declare function ContinueDoneView({ t }: {
+    t: Strings;
+}): import("react").JSX.Element;

package/dist/types/react/handoff/ContinueOnPhone.d.ts

@@ -0,0 +1,60 @@
+import type { Strings } from "../i18n";
+import { type HandoffStatus } from "./api";
+import type { RpidClientConfig } from "../capture";
+import type { ApiSessionBody, Purpose, RpidFlowEvent, RpidSession, VerificationResult } from "../flows/types";
+import { type Locale, type StringOverrides } from "../i18n";
+import type { Appearance } from "../theme/appearance";
+export type HandoffMode = "auto" | "suggest";
+export interface HandoffCopy {
+    title?: string;
+    body?: string;
+}
+export declare const POLL_MS = 2000;
+export interface HandoffPanelProps {
+    config: RpidClientConfig;
+    t: Strings;
+    mode?: HandoffMode;
+    copy?: HandoffCopy | null;
+    onResult: (result: VerificationResult) => void;
+    onContinueHere?: () => void;
+    onError?: (code: string) => void;
+    onEvent?: (e: RpidFlowEvent) => void;
+    pollMs?: number;
+}
+export declare function HandoffPanel({ config, t, mode, copy, onResult, onContinueHere, onError, onEvent, pollMs, }: HandoffPanelProps): import("react").JSX.Element;
+export interface HandoffViewProps {
+    t: Strings;
+    mode: HandoffMode;
+    copy?: HandoffCopy | null;
+    link: {
+        url: string;
+        codeHint: string;
+        tenant: string;
+    } | null;
+    leftMs: number;
+    expired: boolean;
+    failed: boolean;
+    phase: HandoffStatus["phase"];
+    device: string | null;
+    copied?: "ok" | "fail" | null;
+    linkId?: string;
+    onCopy?: () => void;
+    onNewCode?: () => void;
+    onContinueHere?: () => void;
+}
+export declare function HandoffView({ t, mode, copy, link, leftMs, expired, failed, phase, device, copied, linkId, onCopy, onNewCode, onContinueHere, }: HandoffViewProps): import("react").JSX.Element;
+export interface ContinueOnPhoneProps {
+    apiUrl: string;
+    session: RpidSession | ApiSessionBody;
+    purpose?: Purpose;
+    mode?: HandoffMode;
+    locale?: Locale;
+    strings?: StringOverrides;
+    privacyNote?: string | null;
+    onResult: (result: VerificationResult) => void;
+    onContinueHere?: () => void;
+    onError?: (code: string) => void;
+    onEvent?: (e: RpidFlowEvent) => void;
+    appearance?: Appearance | null;
+}
+export declare function ContinueOnPhone(props: ContinueOnPhoneProps): import("react").JSX.Element;

package/dist/types/react/handoff/api.d.ts

@@ -0,0 +1,41 @@
+import type { RpidClientConfig } from "../capture";
+import type { ClientEvent } from "../telemetry/bus";
+import type { DeviceSnapshot } from "../telemetry/device";
+type Json = Record<string, unknown>;
+export interface HandoffCode {
+    code: string;
+    url: string;
+    expiresAt: string;
+    expiresInS: number;
+    codeHint: string;
+    tenant: string;
+}
+export type HandoffPhase = "waiting" | "connected" | "capturing" | "finished";
+export interface HandoffStatus {
+    status: "none" | "pending" | "claimed" | "expired" | "revoked";
+    phase: HandoffPhase | null;
+    codeHint: string | null;
+    expiresAt: string | null;
+    device: string | null;
+    claimedAt: string | null;
+    result: Json | null;
+    sessionExpired: boolean;
+}
+export declare function createHandoff(cfg: RpidClientConfig, device?: string, signal?: AbortSignal): Promise<HandoffCode>;
+export declare function handoffStatus(cfg: RpidClientConfig, signal?: AbortSignal): Promise<HandoffStatus>;
+export declare function revokeHandoff(cfg: RpidClientConfig, reason: "continue_here" | "cancel"): Promise<void>;
+export interface HandoffPeek {
+    tenant: string;
+    codeHint: string;
+    expiresAt: string;
+    expiresInS: number;
+    purpose: string;
+    locale?: string;
+    appearance?: unknown;
+}
+export declare function peekHandoff(apiUrl: string, code: string, signal?: AbortSignal): Promise<HandoffPeek>;
+export declare function claimHandoff(apiUrl: string, code: string, device?: string, signal?: AbortSignal): Promise<Json>;
+export declare function reportProgress(cfg: RpidClientConfig, step: "front" | "back" | "face"): Promise<void>;
+export declare function postDevice(cfg: RpidClientConfig, snapshot: DeviceSnapshot): Promise<void>;
+export declare function postClientEvents(cfg: RpidClientConfig, events: ClientEvent[], beacon?: boolean): void;
+export {};

package/dist/types/react/handoff/qr.d.ts

@@ -0,0 +1,9 @@
+export declare const QR_MAX_VERSION = 10;
+export interface QrMatrix {
+    size: number;
+    version: number;
+    mask: number;
+    modules: boolean[][];
+}
+export declare function encodeQr(text: string, mask?: number): QrMatrix;
+export declare function qrPath(m: QrMatrix, margin?: number): string;

package/dist/types/react/hooks.d.ts

@@ -0,0 +1,7 @@
+import { type RefObject } from "react";
+export declare function prefersReducedMotion(): boolean;
+export declare function useReducedMotion(): boolean;
+export declare function useElementSize<T extends Element>(): [RefObject<T>, {
+    w: number;
+    h: number;
+}];

package/dist/types/react/i18n/en.d.ts

@@ -0,0 +1,3 @@
+import type { ReasonEntry, Strings } from "./types";
+export declare const EN: Strings;
+export declare const EN_UNKNOWN: ReasonEntry;

package/dist/types/react/i18n/es-419.d.ts

@@ -0,0 +1,3 @@
+import type { ReasonEntry, Strings } from "./types";
+export declare const ES: Strings;
+export declare const ES_UNKNOWN: ReasonEntry;

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

@@ -0,0 +1,10 @@
+import type { Locale, ReasonEntry, StringOverrides, Strings } from "./types";
+export type { TeleRecipe, Locale, ClientReason, ServerReason, Reason, Recovery, ReasonEntry, GuideKey, EngineStage, DistanceHint, Strings, StringOverrides, } from "./types";
+export declare const DEFAULT_LOCALE: Locale;
+export declare function getStrings(locale?: Locale, overrides?: StringOverrides): Strings;
+export declare function reasonEntry(code: string | null | undefined, locale?: Locale, overrides?: StringOverrides): ReasonEntry;
+export declare function attemptsText(t: Strings, retriesLeft: number | null | undefined): string | null;
+export declare function faceRetryText(t: Strings, retriesLeft: number): string;
+export declare const LOCALES: readonly Locale[];
+export declare function browserLocale(languages?: readonly string[]): Locale | undefined;
+export declare function resolveLocale(host?: Locale | null, tenant?: Locale | "auto" | null, languages?: readonly string[]): Locale;