@baas-id/react 0.3.1 → 0.3.7

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

@@ -0,0 +1,37 @@
+import type { GuideKey } from "../i18n";
+import type { FingerBox, FingerPixels, Slot } from "./detector";
+export interface FingertipStats {
+    sharpness: number;
+    luma: number;
+    contrast: number;
+    glare: number;
+    ridge: number;
+    widthPx: number;
+}
+export type FingerGuideId = Extract<GuideKey, "no_hand" | "fingers_closer" | "fingers_back" | "fingers_together" | "hold_fingers_still" | "finger_glare" | "finger_blurry" | "show_left_hand" | "show_right_hand" | "too_dark" | "perfect">;
+export interface FingerFloors {
+    widthPxMin: number;
+    slotFracMax: number;
+    glareMax: number;
+    lumaMin: number;
+    lumaMax: number;
+    ridgeMin: number;
+    sharpnessMin: number | null;
+}
+export declare const FINGER_FLOORS: FingerFloors;
+export declare const RIDGE_W = 192;
+export declare function ridgeScore(g: Float32Array, w: number, h: number): number;
+export declare function fingertipStats(px: FingerPixels, box: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}): FingertipStats;
+export interface FingerReading {
+    slots: readonly Slot[];
+    boxes: readonly FingerBox[];
+    stats: ReadonlyArray<FingertipStats | null>;
+    hand?: "left" | "right";
+}
+export declare function fingertipPasses(st: FingertipStats | null, f?: FingerFloors): boolean;
+export declare function fingerGate(r: FingerReading, f?: FingerFloors): FingerGuideId;

package/dist/types/react/finger/runFingerCapture.d.ts

@@ -0,0 +1,77 @@
+import type { FingerBox, FingerDetector, FingerGroup, FingerPixels } from "./detector";
+import { type FingerFloors, type FingerGuideId, type FingertipStats } from "./qualityGate";
+export declare const FINGER_TICK_MS = 90;
+export declare const PRESENT_FRAMES = 3;
+export declare const HOLD_FRAMES = 5;
+export declare const STILL_MAX = 0.02;
+export declare const FINGER_TIMEOUT_MS = 25000;
+export declare const TORCH_SETTLE_MS = 350;
+export interface FingerFrame<F> {
+    px: FingerPixels;
+    frame: F;
+    w: number;
+    h: number;
+}
+export interface FingerIo<F> {
+    alive(): boolean;
+    wait(ms: number): Promise<void>;
+    now(): number;
+    read(): Promise<FingerFrame<F> | null>;
+    detector: FingerDetector;
+    region(frame: F, box: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }): FingerPixels | null;
+    keep?(frame: F): F;
+    encode(frame: F): Promise<Blob>;
+    crop(frame: F, box: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }): Promise<Blob>;
+    torch?: {
+        supported: boolean;
+        on: boolean;
+        set(on: boolean): Promise<boolean>;
+    };
+}
+export type SlotState = "empty" | "found" | "good";
+export interface FingerUi {
+    guide(k: FingerGuideId): void;
+    slots(states: SlotState[]): void;
+    hold(p: number): void;
+    stage(s: "searching" | "holding" | "torch" | "done"): void;
+    reading?(r: {
+        boxes: FingerBox[];
+        stats: Array<FingertipStats | null>;
+        guide: FingerGuideId;
+    }): void;
+}
+export interface FingerCaptureOutput {
+    file: Blob;
+    crops: Blob[];
+    boxes: Array<[number, number, number, number]>;
+    stats: FingertipStats[];
+    torch: {
+        supported: boolean;
+        response: number | null;
+    };
+}
+export type FingerRunResult = {
+    k: "captured";
+    out: FingerCaptureOutput;
+} | {
+    k: "failed";
+    reason: "FINGER_NOT_FOUND" | "FINGER_QUALITY_LOW";
+} | {
+    k: "aborted";
+};
+export declare function runFingerCapture<F>(group: FingerGroup, io: FingerIo<F>, ui: FingerUi, opts?: {
+    torch?: boolean;
+    floors?: FingerFloors;
+    timeoutMs?: number;
+    tickMs?: number;
+}): Promise<FingerRunResult>;

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

@@ -0,0 +1,10 @@
+import { type DeviceSignals, type TimelineSummary } from "../capture";
+export declare function fingerEvidence(input: {
+    nonce: string | null | undefined;
+    file: Blob;
+    crops: readonly Blob[];
+    positions: readonly string[];
+    timeline: TimelineSummary;
+    device: DeviceSignals | null;
+    tMs?: number;
+}): Promise<Record<string, unknown> | null>;

package/dist/types/react/finger/useFingerCapture.d.ts

@@ -0,0 +1,31 @@
+import { type RefObject } from "react";
+import type { FingerCaptureProps } from "../FingerCapture";
+import { type FingerGroup, type Slot } from "./detector";
+import type { FingerGuideId } from "./qualityGate";
+import { type SlotState } from "./runFingerCapture";
+export type FingerPhase = "searching" | "holding" | "torch" | "uploading" | "done" | "error";
+export declare function useFingerCapture(props: FingerCaptureProps): {
+    t: import("../i18n").Strings;
+    source: "camera" | "demo";
+    phase: FingerPhase;
+    guide: FingerGuideId;
+    slotStates: SlotState[];
+    hold: number;
+    group: FingerGroup;
+    groups: FingerGroup[];
+    groupAt: number;
+    slots: Slot[];
+    src: {
+        w: number;
+        h: number;
+    };
+    error: string | null;
+    errorDetail: unknown;
+    retriesLeft: number | null;
+    final: boolean;
+    torchOn: boolean;
+    tele: string;
+    retry: () => void;
+    videoRef: RefObject<HTMLVideoElement | null>;
+    canvasRef: RefObject<HTMLCanvasElement | null>;
+};

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

@@ -23,6 +23,8 @@ export declare function StepRail({ step, t, plan, retakes, }: {
     plan?: readonly CaptureId[];
     retakes?: Partial<Record<Side, RetakeNotice>>;
 }): import("react").JSX.Element;
+export declare function watchModality(): () => void;
+export declare function focusTitle(el: HTMLElement): void;
 export declare function RetakeNoticeLine({ notice, side, t }: {
     notice: RetakeNotice;
     side: Side;

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

@@ -10,11 +10,14 @@ export interface TenantInstructions {
     front?: StepInstructions;
     back?: StepInstructions;
     face?: StepInstructions;
+    chip?: StepInstructions;
+    finger?: StepInstructions;
 }
 export interface StepInstructions {
     enabled?: boolean;
     en?: IntroText;
     "es-419"?: IntroText;
+    unreadableHint?: boolean;
 }
 export interface TenantReasonText {
     title?: string;
@@ -26,6 +29,7 @@ export declare function normalizeInstructions(raw: unknown): TenantInstructions
 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 unreadableHintEnabled(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[];

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

@@ -3,4 +3,4 @@ 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";
+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, SessionChip, SessionFinger, FingerPosition, StepId, } from "./types";

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

@@ -0,0 +1,27 @@
+export declare const DEFAULT_SESSION_TTL_S = 900;
+export declare const RENEW_MARGIN_MS = 60000;
+export declare const MAX_SILENT_RENEWALS = 8;
+export declare const MAX_IDLE_MS: number;
+export type RenewReason = "expiring" | "resume" | "start" | "expired";
+export type RenewOutcome = "renewed" | "failed" | "unsupported" | "aborted" | "skipped";
+export interface SessionLife {
+    openedAt: number;
+    ttlMs: number;
+    silent: number;
+    touchedAt: number;
+}
+export declare function lifeOf(openedAt: number, expiresInS?: number, prev?: SessionLife | null, silent?: boolean): SessionLife;
+export declare const expiresAtOf: (l: SessionLife) => number;
+export declare const marginOf: (l: SessionLife) => number;
+export declare const renewDueAt: (l: SessionLife) => number;
+export declare const needsRenewal: (l: SessionLife, now: number) => boolean;
+export declare const maySilentlyRenew: (l: SessionLife, now: number) => boolean;
+export declare function useKeepFresh({ active, sessionId, life, renew, touch }: {
+    active: boolean;
+    sessionId: string;
+    life: {
+        readonly current: SessionLife | null;
+    };
+    renew: (why: RenewReason) => Promise<RenewOutcome>;
+    touch: () => void;
+}): void;

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

@@ -1,4 +1,8 @@
-import type { RpidSession, SessionFlow } from "./types";
+import type { FingerPosition, RpidSession, SessionChip, SessionFinger, SessionFlow, StepId } from "./types";
+export declare const FINGER_POSITIONS: readonly FingerPosition[];
+export declare function normalizeSteps(raw: unknown): StepId[] | undefined;
+export declare function normalizeChip(raw: unknown): SessionChip | undefined;
+export declare function normalizeFinger(raw: unknown): SessionFinger | undefined;
 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;

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

@@ -1,9 +1,17 @@
 import type { Strings } from "../i18n";
-import type { Purpose, RpidSession, SessionFlow, VerificationResult } from "./types";
+import type { ExtractionRecord, Purpose, RpidSession, SessionFlow, VerificationResult } from "./types";
 export type Side = "front" | "back";
-export type CaptureId = Side | "face";
+export type CaptureId = Side | "chip" | "finger" | "face";
+export declare const ALL_STEPS: readonly CaptureId[];
 export declare const FULL_ENROLLMENT: readonly CaptureId[];
 export declare function captureSteps(purpose: Purpose, flow?: SessionFlow | null): CaptureId[];
+export interface ChipAccess {
+    documentNumber: string;
+    birthDate: string;
+    expiryDate: string;
+}
+export declare function yymmdd(v: unknown): string | null;
+export declare function chipAccessOf(record: ExtractionRecord | null | undefined): ChipAccess | null;
 export declare const isFaceOnly: (purpose: Purpose) => purpose is "signin" | "identify";
 export declare const NEUTRAL_OUTCOMES: readonly string[];
 export type Settlement = {
@@ -14,13 +22,19 @@ export type Settlement = {
     verdict: "REJECTED" | "NEEDS_REVIEW";
 };
 export declare function settleFinalize(result: Pick<VerificationResult, "verdict" | "reason">): Settlement;
+export declare const toStep: (id: CaptureId) => Step;
+export declare const idOf: (s: Step) => CaptureId | null;
 export type Step = {
     k: "opening";
 } | {
     k: "doc";
     side: Side;
+} | {
+    k: "chip";
 } | {
     k: "face";
+} | {
+    k: "finger";
 } | {
     k: "finalizing";
 } | {
@@ -58,7 +72,10 @@ export interface FlowState {
     thumbs: Thumbs;
     plan: CaptureId[];
     faceRetriesLeft?: number;
+    fingerRetriesLeft?: number;
     retakes?: Partial<Record<Side, RetakeNotice>>;
+    chain?: string;
+    chipAccess?: ChipAccess;
 }
 export type FlowAction = {
     type: "open";
@@ -66,10 +83,17 @@ export type FlowAction = {
     type: "opened";
     session: RpidSession;
     purpose: Purpose;
+} | {
+    type: "renewed";
+    session: RpidSession;
 } | {
     type: "docCaptured";
     side: Side;
     thumb?: string;
+    record?: ExtractionRecord | null;
+} | {
+    type: "stepDone";
+    id: "chip" | "finger" | "face";
 } | {
     type: "finalizing";
 } | {
@@ -89,6 +113,9 @@ export type FlowAction = {
 } | {
     type: "faceRetry";
     retriesLeft: number;
+} | {
+    type: "fingerRetry";
+    retriesLeft: number;
 } | {
     type: "remote";
 };
@@ -97,9 +124,14 @@ export declare function flowReducer(state: FlowState, action: FlowAction): FlowS
 export declare const isCapturing: (s: Step) => s is {
     k: "doc";
     side: Side;
+} | {
+    k: "chip";
 } | {
     k: "face";
+} | {
+    k: "finger";
 };
+export declare const lastStep: (plan: readonly CaptureId[]) => CaptureId;
 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;

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

@@ -4,6 +4,8 @@ import type { DocumentAuthenticity } from "../capture";
 import type { SelfieQualityFloors } from "../face/qualityGate";
 import type { Appearance } from "../theme/appearance";
 import type { TenantInstructions, TenantMessages } from "./experience";
+import type { ChipReader } from "../chip/provider";
+import type { FingerDetector } from "../finger/detector";
 export type { Appearance, TenantInstructions, TenantMessages };
 export type { DocumentAuthenticity };
 export interface ExtractionField {
@@ -88,8 +90,29 @@ export interface ApiSessionBody {
         };
         progress?: boolean;
         test?: boolean;
+        steps?: StepId[];
+        chip?: {
+            required?: boolean;
+            aa_challenge?: string;
+            data_groups?: string[];
+        } | null;
+        finger?: {
+            fingers?: FingerPosition[];
+            torch?: boolean;
+        } | null;
     };
 }
+export type StepId = "front" | "back" | "chip" | "face" | "finger";
+export type FingerPosition = "right_index" | "right_middle" | "right_ring" | "right_little" | "left_index" | "left_middle" | "left_ring" | "left_little" | "right_thumb" | "left_thumb";
+export interface SessionChip {
+    required: boolean;
+    aaChallenge?: string;
+    dataGroups: string[];
+}
+export interface SessionFinger {
+    fingers: FingerPosition[];
+    torch: boolean;
+}
 export interface SessionFlow {
     document?: boolean;
     documentSides?: "front_back" | "front";
@@ -108,6 +131,9 @@ export interface SessionFlow {
     handoff?: SessionHandoff;
     progress?: boolean;
     test?: boolean;
+    steps?: StepId[];
+    chip?: SessionChip;
+    finger?: SessionFinger;
 }
 export interface SessionHandoff {
     mode?: "auto" | "suggest";
@@ -160,6 +186,13 @@ export type RpidFlowEvent = {
     sessionId: string;
     purpose: Purpose;
     bound: boolean;
+    renewed?: true;
+} | {
+    type: "session.renewed";
+    sessionId: string;
+    previousSessionId: string;
+    purpose: Purpose;
+    reason: "expiring" | "resume" | "start" | "expired";
 } | {
     type: "session.failed";
     reason: string;
@@ -182,6 +215,26 @@ export type RpidFlowEvent = {
     target: "front" | "back";
     reason: string;
     mismatches?: string[];
+} | {
+    type: "chip.read";
+    access: "bac" | "pace";
+    dataGroups: string[];
+    activeAuth: boolean;
+} | {
+    type: "chip.unavailable";
+    reason: string;
+    chipRequired: boolean;
+} | {
+    type: "chip.rejected";
+    reason: string;
+    retriesLeft?: number;
+} | {
+    type: "finger.captured";
+    fingers: string[];
+} | {
+    type: "finger.rejected";
+    reason: string;
+    retriesLeft?: number;
 } | {
     type: "face.captured";
 } | {
@@ -229,10 +282,13 @@ export interface ConsentChoice {
 }
 export interface OpenSessionContext {
     consent?: ConsentChoice;
+    previousSessionId?: string;
+    renewal?: boolean;
 }
 export interface VerificationFlowProps {
     apiUrl: string;
     openSession: (signal?: AbortSignal, context?: OpenSessionContext) => Promise<RpidSession | ApiSessionBody>;
+    sessionRenewal?: boolean;
     consent?: {
         modelImprovement?: ModelImprovementPrompt;
     };
@@ -251,6 +307,8 @@ export interface VerificationFlowProps {
     onEvent?: (event: RpidFlowEvent) => void;
     handoff?: HandoffOption;
     diagnostics?: boolean;
+    chipReader?: ChipReader;
+    fingerDetector?: FingerDetector;
 }
 export type Purpose = "enrollment" | "signin" | "reverification" | "identify";
 export type EnrollmentFlowProps = VerificationFlowProps;

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

@@ -1,8 +1,10 @@
 import { type RpidClientConfig } from "../capture";
 import { type FlowState, type Side } from "./state";
+import type { ChipOutcome } from "../chip/useChipRead";
 import type { SideRetake } from "../DocumentCapture";
+import { type RenewOutcome, type RenewReason, type SessionLife } from "./renewal";
 import type { ConsentChoice, Purpose, VerificationFlowProps, VerificationResult } from "./types";
-export declare function useFlowSession({ purpose, apiUrl, openSession, locale, strings: overrides, formality: formalityProp, onVerified, onFailed, onEvent, source, consentChoice, diagnostics, }: VerificationFlowProps & {
+export declare function useFlowSession({ purpose, apiUrl, openSession, locale, strings: overrides, formality: formalityProp, onVerified, onFailed, onEvent, source, consentChoice, diagnostics, sessionRenewal, }: VerificationFlowProps & {
     purpose: Purpose;
     consentChoice?: ConsentChoice | null;
 }): {
@@ -14,9 +16,17 @@ export declare function useFlowSession({ purpose, apiUrl, openSession, locale, s
     config: RpidClientConfig | null;
     restart: () => undefined;
     docCaptured: (side: Side, serverResult: unknown, thumb?: string) => void;
-    captureRejected: (kind: "document" | "face", reason: string, detail?: unknown) => void;
+    captureRejected: (kind: "document" | "face" | "chip" | "finger", reason: string, detail?: unknown) => void;
     faceCaptured: () => Promise<void>;
+    chipDone: (outcome: ChipOutcome) => void;
+    fingerCaptured: (serverResult: unknown) => void;
     docRetake: (r: SideRetake) => void;
     remoteResult: (result: VerificationResult) => Promise<void>;
     failWith: (code: string) => void;
+    life: import("react").MutableRefObject<SessionLife | null>;
+    renew: (why: RenewReason, loud?: boolean) => Promise<RenewOutcome>;
+    touch: () => void;
+    beforeCapture: (unused: boolean) => true | Promise<boolean>;
+    preparing: boolean;
+    renewalOn: () => boolean;
 };

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

@@ -1,7 +1,14 @@
 import { type Formality, type Locale, type StringOverrides, type Strings } from "../i18n";
 import type { RpidFlowEvent } from "../flows/types";
 import type { ColorScheme } from "../theme/scheme";
+import type { ChipReader } from "../chip/provider";
+import type { FingerDetector } from "../finger/detector";
 export declare function readHandoffCode(search?: string, pathname?: string, hash?: string): string | null;
+export declare function readLastLook(now?: number): {
+    locale?: string;
+    formality?: Formality;
+} | null;
+export declare const CONTINUE_DEFAULT_LOCALE: Locale;
 export interface ContinueFlowProps {
     apiUrl: string;
     code: string | null;
@@ -18,15 +25,21 @@ export interface ContinueFlowProps {
         verdict: string;
         reason: string | null;
     }) => void;
+    onLanguage?: (language: {
+        locale: Locale;
+        formality: Formality;
+    }) => void;
+    chipReader?: ChipReader;
+    fingerDetector?: FingerDetector;
 }
-export declare function ContinueFlow({ apiUrl, code, modelsUrl, locale: hostLocale, strings, formality, colorScheme, privacyNote, source, debug, onEvent, onDone, }: ContinueFlowProps): import("react").JSX.Element;
+export declare function ContinueFlow({ apiUrl, code, modelsUrl, locale: hostLocale, strings, formality, colorScheme, privacyNote, source, debug, onEvent, onDone, onLanguage, chipReader, fingerDetector, }: 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 type DoneStep = "front" | "back" | "face";
+export type DoneStep = "front" | "back" | "chip" | "face" | "finger";
 export declare function ContinueDoneView({ t, tenant, codeHint, steps }: {
     t: Strings;
     tenant?: string | null;

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

@@ -11,6 +11,11 @@ export interface HandoffCopy {
     body?: string;
 }
 export declare const POLL_MS = 2000;
+export declare function linkOnce(config: RpidClientConfig, previous: {
+    sessionId: string;
+    captureToken: string;
+}): void;
+export declare function resetLinkedPairs(): void;
 export interface HandoffPanelProps {
     config: RpidClientConfig;
     t: Strings;
@@ -23,6 +28,16 @@ export interface HandoffPanelProps {
     onEvent?: (e: RpidFlowEvent) => void;
     pollMs?: number;
 }
+export declare const FOLLOW_KEY = "rpid.handoff.follow";
+interface FollowRecord {
+    apiUrl: string;
+    sessionId: string;
+    captureToken: string;
+    at: number;
+}
+export declare function rememberFollow(cfg: RpidClientConfig): void;
+export declare function forgetFollow(sessionId?: string): void;
+export declare function readFollow(): FollowRecord | null;
 export declare function HandoffPanel({ config, t, mode, copy, onResult, onContinueHere, onError, onFailed, onEvent, pollMs, }: HandoffPanelProps): import("react").JSX.Element;
 export interface HandoffViewProps {
     t: Strings;
@@ -50,8 +65,10 @@ export interface HandoffViewProps {
         final: boolean;
     } | null;
     onAgain?: () => void;
+    retrying?: boolean;
+    resumed?: boolean;
 }
-export declare function HandoffView({ t, mode, copy, link, leftMs, expired, failed, phase, device, copied, linkId, onCopy, onNewCode, onContinueHere, stopped, onAgain, }: HandoffViewProps): import("react").JSX.Element;
+export declare function HandoffView({ t, mode, copy, link, leftMs, expired, failed, phase, device, copied, linkId, onCopy, onNewCode, onContinueHere, stopped, onAgain, retrying, resumed, }: HandoffViewProps): import("react").JSX.Element;
 export declare function CodeChip({ t, code, instruction }: {
     t: Strings;
     code: string;
@@ -74,3 +91,4 @@ export interface ContinueOnPhoneProps {
     colorScheme?: ColorScheme;
 }
 export declare function ContinueOnPhone(props: ContinueOnPhoneProps): import("react").JSX.Element;
+export {};

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

@@ -28,6 +28,10 @@ export interface HandoffStatus {
 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 declare function linkSession(cfg: RpidClientConfig, previous: {
+    sessionId: string;
+    captureToken: string;
+}): Promise<boolean>;
 export interface HandoffPeek {
     tenant: string;
     codeHint: string;
@@ -43,10 +47,12 @@ export interface CallLanguage {
     formality?: "formal" | "informal";
 }
 export declare function peekHandoff(apiUrl: string, code: string, signal?: AbortSignal, lang?: CallLanguage): Promise<HandoffPeek>;
+export declare function refusalLanguage(e: unknown): CallLanguage | null;
 export declare function claimHandoff(apiUrl: string, code: string, device?: string, signal?: AbortSignal, lang?: CallLanguage): Promise<Json>;
-export declare function reportProgress(cfg: RpidClientConfig, step: "front" | "back" | "face"): Promise<void>;
+export type ProgressStep = "front" | "back" | "chip" | "face" | "finger";
+export declare function reportProgress(cfg: RpidClientConfig, step: ProgressStep): Promise<void>;
 export declare function reportPhone(cfg: RpidClientConfig, event: "heartbeat" | "failed" | "abandoned", info?: {
-    step?: "front" | "back" | "face";
+    step?: ProgressStep;
     reason?: string;
     final?: boolean;
 }, beacon?: boolean): void;

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

@@ -1,7 +1,8 @@
 import type { RpidClientConfig } from "../capture";
+import { type ProgressStep } from "./api";
 export declare const HEARTBEAT_MS = 10000;
 export interface PhoneFailure {
     reason: string;
     final: boolean;
 }
-export declare function usePhoneLink(cfg: RpidClientConfig | null, step: "front" | "back" | "face" | null, failure: PhoneFailure | null, finished: boolean): void;
+export declare function usePhoneLink(cfg: RpidClientConfig | null, step: ProgressStep | null, failure: PhoneFailure | null, finished: boolean): void;