@velion-la/onboarding-sdk-react-native 1.0.0-beta.2

package/lib/typescript/ui/theme/ThemeProvider.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview ThemeProvider + hooks.
+ *
+ * - `ThemeProvider` resolves tokens from `VelionConfig.theme` + colorMode and
+ *   exposes them to descendants.
+ * - `useTheme()` returns the active `ResolvedTheme`.
+ * - `useReducedMotion()` honours the OS-level `prefers-reduced-motion` flag —
+ *   components disable animations when true.
+ */
+import React, { type ReactNode } from 'react';
+import type { VelionTheme } from '../../types';
+import { type ResolvedTheme } from './tokens';
+export interface ThemeProviderProps {
+    /** Consumer-supplied overrides (subset of tokens). */
+    themeOverrides?: VelionTheme | undefined;
+    /** Explicit mode. `'auto'` follows the system color scheme. */
+    colorMode?: 'light' | 'dark' | 'auto' | undefined;
+    children: ReactNode;
+}
+export declare function ThemeProvider({ themeOverrides, colorMode, children, }: ThemeProviderProps): React.JSX.Element;
+export declare function useTheme(): ResolvedTheme;
+export declare function useReducedMotion(): boolean;
+//# sourceMappingURL=ThemeProvider.d.ts.map

package/lib/typescript/ui/theme/ThemeProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThemeProvider.d.ts","sourceRoot":"","sources":["../../../../src/ui/theme/ThemeProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,EAMZ,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAS5D,MAAM,WAAW,kBAAkB;IACjC,sDAAsD;IACtD,cAAc,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IACzC,+DAA+D;IAC/D,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAClD,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,wBAAgB,aAAa,CAAC,EAC5B,cAAc,EACd,SAAkB,EAClB,QAAQ,GACT,EAAE,kBAAkB,qBAsBpB;AAED,wBAAgB,QAAQ,IAAI,aAAa,CAQxC;AAED,wBAAgB,gBAAgB,IAAI,OAAO,CAG1C"}

package/lib/typescript/ui/theme/index.d.ts

@@ -0,0 +1,3 @@
+export { ThemeProvider, useTheme, useReducedMotion, type ThemeProviderProps, } from './ThemeProvider';
+export { LIGHT_TOKENS, DARK_TOKENS, getDefaultThemeTokens, resolveTheme, mixHex, withAlpha, isHexDark, type ResolvedTheme, type ThemeTokenSet, } from './tokens';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/ui/theme/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/theme/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,KAAK,kBAAkB,GACxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,YAAY,EACZ,WAAW,EACX,qBAAqB,EACrB,YAAY,EACZ,MAAM,EACN,SAAS,EACT,SAAS,EACT,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,UAAU,CAAC"}

package/lib/typescript/ui/theme/tokens.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Theme tokens for the React Native SDK.
+ *
+ * Exposes logical tokens as a plain JS object that components consume via
+ * `useTheme()`.
+ *
+ * Light and dark are tuned independently (Material Design 3 / Apple HIG dark
+ * pairing). Consumer overrides from `VelionConfig.theme` are layered on top.
+ */
+import type { VelionTheme } from '../../types';
+/** Tonal token set. Shape matches `VelionTheme` (all required, no undefineds). */
+export type ThemeTokenSet = Required<VelionTheme>;
+/**
+ * Resolved values that components actually read from. We keep colors as plain
+ * hex strings; consumers that want to layer translucency use `mixHex` instead
+ * of CSS `color-mix()` (which does not exist in RN).
+ */
+export interface ResolvedTheme extends ThemeTokenSet {
+    /** The mode that components should consider active (post-luminance check). */
+    effectiveMode: 'light' | 'dark';
+    /** The numeric pixel value parsed from `borderRadius` (the SDK-wide default). */
+    borderRadiusPx: number;
+}
+export declare const LIGHT_TOKENS: ThemeTokenSet;
+export declare const DARK_TOKENS: ThemeTokenSet;
+export declare function getDefaultThemeTokens(colorMode?: 'light' | 'dark'): ThemeTokenSet;
+/** Layers consumer overrides on top of the base tokens for the requested mode. */
+export declare function resolveTheme(theme: VelionTheme | undefined, colorMode: 'light' | 'dark'): ResolvedTheme;
+/** WCAG relative-luminance check. Returns false on unparsable input. */
+export declare function isHexDark(hex: string): boolean;
+/**
+ * Mix two hex colors at the given ratio (0–100). Cheap stand-in for the web's
+ * `color-mix(in srgb, A x%, B)` so we can render the soft halos and tinted
+ * backgrounds the design system uses (.vl-retry-dialog, .vl-sworn__option).
+ */
+export declare function mixHex(a: string, b: string, ratioOfA: number): string;
+/**
+ * Returns an `rgba()` string with the supplied alpha (0–1). Use for translucent
+ * borders / fills that should not blend with the host background.
+ */
+export declare function withAlpha(hex: string, alpha: number): string;
+//# sourceMappingURL=tokens.d.ts.map

package/lib/typescript/ui/theme/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../../src/ui/theme/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,kFAAkF;AAClF,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC;AAElD;;;;GAIG;AACH,MAAM,WAAW,aAAc,SAAQ,aAAa;IAClD,8EAA8E;IAC9E,aAAa,EAAE,OAAO,GAAG,MAAM,CAAC;IAChC,iFAAiF;IACjF,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,YAAY,EAAE,aAe1B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,aAezB,CAAC;AAEF,wBAAgB,qBAAqB,CACnC,SAAS,GAAE,OAAO,GAAG,MAAgB,GACpC,aAAa,CAEf;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,KAAK,EAAE,WAAW,GAAG,SAAS,EAC9B,SAAS,EAAE,OAAO,GAAG,MAAM,GAC1B,aAAa,CAWf;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAY9C;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CASrE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK5D"}

package/lib/typescript/utils/EventEmitter.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Typed, memory-safe EventEmitter for internal SDK communication.
+ *
+ * Design rationale:
+ * - Fully typed via generics — no `any` escapes at the call sites.
+ * - All `on()` calls return an unsubscribe function, which is the preferred
+ *   modern pattern over imperative `off()` calls. This makes cleanup trivial
+ *   via a collected array of disposables.
+ * - Listeners that throw are caught and logged, preventing one bad subscriber
+ *   from silently breaking the entire event chain.
+ * - `removeAllListeners()` is explicitly called in `VelionOnboarding.destroy()`
+ *   to prevent memory leaks in long-lived single-page applications.
+ */
+/** A strongly-typed listener function for a given event payload. */
+type Listener<TPayload> = (payload: TPayload) => void;
+/** A function returned by `on()` that removes the registered listener when called. */
+export type Unsubscribe = () => void;
+/**
+ * A generic, compile-time safe EventEmitter.
+ *
+ * @typeParam TEventMap - An object type mapping event names to their payload types.
+ *
+ * @example
+ * ```typescript
+ * interface MyEvents {
+ *   'data:ready': { records: string[] };
+ *   'error': Error;
+ * }
+ *
+ * const emitter = new TypedEventEmitter<MyEvents>();
+ *
+ * const unsub = emitter.on('data:ready', ({ records }) => {
+ *   // `records` is correctly typed as string[]
+ *   console.log(records);
+ * });
+ *
+ * emitter.emit('data:ready', { records: ['a', 'b'] });
+ * unsub(); // Clean up
+ * ```
+ */
+export declare class TypedEventEmitter<TEventMap extends Record<string, unknown>> {
+    /**
+     * Internal store. Using a `Map<K, Set<Listener>>` gives O(1) lookups and
+     * avoids duplicate listeners with zero extra checks (Set semantics).
+     */
+    private readonly _listeners;
+    /**
+     * Registers a listener for the given event. The listener will be invoked
+     * synchronously every time `emit(event, payload)` is called.
+     *
+     * @param event - The event name to subscribe to.
+     * @param listener - The callback to invoke. Receives the typed payload.
+     * @returns An unsubscribe function. Call it to remove this specific listener.
+     */
+    on<K extends keyof TEventMap>(event: K, listener: Listener<TEventMap[K]>): Unsubscribe;
+    /**
+     * Registers a one-time listener. The listener is automatically removed
+     * after the first time the event fires.
+     *
+     * @param event - The event name to subscribe to.
+     * @param listener - The callback to invoke once.
+     * @returns An unsubscribe function. Call it to cancel before the event fires.
+     */
+    once<K extends keyof TEventMap>(event: K, listener: Listener<TEventMap[K]>): Unsubscribe;
+    /**
+     * Emits an event, synchronously invoking all registered listeners.
+     * Errors thrown by individual listeners are caught and logged to prevent
+     * cascading failures.
+     *
+     * @param event - The event name to emit.
+     * @param payload - The data to pass to each listener.
+     */
+    emit<K extends keyof TEventMap>(event: K, payload: TEventMap[K]): void;
+    /**
+     * Removes a specific listener for an event.
+     *
+     * @param event - The event name.
+     * @param listener - The exact listener function reference to remove.
+     */
+    off<K extends keyof TEventMap>(event: K, listener: Listener<TEventMap[K]>): void;
+    /**
+     * Removes all listeners, optionally scoped to a single event.
+     * Called by `VelionOnboarding.destroy()` to prevent memory leaks.
+     *
+     * @param event - If provided, only clears listeners for that event.
+     *                If omitted, clears ALL listeners on ALL events.
+     */
+    removeAllListeners(event?: keyof TEventMap): void;
+    /**
+     * Returns the number of registered listeners for a given event.
+     * Useful for debugging and testing assertions.
+     *
+     * @param event - The event name to check.
+     */
+    listenerCount(event: keyof TEventMap): number;
+}
+export {};
+//# sourceMappingURL=EventEmitter.d.ts.map

package/lib/typescript/utils/EventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter.d.ts","sourceRoot":"","sources":["../../../src/utils/EventEmitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,oEAAoE;AACpE,KAAK,QAAQ,CAAC,QAAQ,IAAI,CAAC,OAAO,EAAE,QAAQ,KAAK,IAAI,CAAC;AAEtD,sFAAsF;AACtF,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,iBAAiB,CAAC,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACtE;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAGvB;IAEJ;;;;;;;OAOG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,SAAS,EAC1B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAC/B,WAAW;IAUd;;;;;;;OAOG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,SAAS,EAC5B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAC/B,WAAW;IAQd;;;;;;;OAOG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI;IAgBtE;;;;;OAKG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,SAAS,EAC3B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAC/B,IAAI;IAIP;;;;;;OAMG;IACH,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,SAAS,GAAG,IAAI;IAQjD;;;;;OAKG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,SAAS,GAAG,MAAM;CAG9C"}

package/lib/typescript/utils/base64.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Base64 helpers without `Buffer` (RN does not ship a Buffer global) and
+ * without leaning on `react-native-quick-base64`. Hermes provides `btoa` /
+ * `atob`, which take Latin-1 strings — we wrap them with byte arrays so
+ * callers don't have to think about the in-between.
+ */
+/**
+ * Encodes a `Uint8Array` to a standard base64 string.
+ *
+ * Implementation note: `btoa` requires a Latin-1 string. We convert the byte
+ * array to one char per byte via `String.fromCharCode`, in chunks to avoid
+ * blowing the JS argument-list limit on large frames (~1 MB JPEG).
+ */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Decodes a standard base64 string into a `Uint8Array`. */
+export declare function base64ToBytes(b64: string): Uint8Array;
+/** Lowercase hex (`'a1f3…'`) — matches the canonical Iris HMAC format. */
+export declare function bytesToHexLower(bytes: Uint8Array): string;
+//# sourceMappingURL=base64.d.ts.map

package/lib/typescript/utils/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../../src/utils/base64.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CASvD;AAED,4DAA4D;AAC5D,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAOrD;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAOzD"}

package/lib/typescript/utils/deviceFingerprint.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Device Fingerprint via Fingerprint Pro RN SDK.
+ *
+ * Uses the official `@fingerprintjs/fingerprintjs-pro-react-native` agent
+ * class to identify the device.
+ *
+ * Why a real SDK and not a hand-rolled hash:
+ *   - The backend (`PublicSdkSessionController.fingerprint`) reads only
+ *     `request_id` and `sealed_result` from the body. A custom `visitor_id`
+ *     field is silently dropped and the AML enrichment lookup never runs.
+ *   - Fingerprint Pro returns a stable `requestId` (lookup key against the
+ *     Fingerprint server) and a `sealedResult` (encrypted payload the
+ *     backend decrypts with its private key for server-side identification).
+ *
+ * The Fingerprint Pro RN SDK is loaded **dynamically** so it stays an
+ * optional peer dep: hosts that don't ship the fingerprint module get a
+ * clear `FINGERPRINT_FAILED` error instead of a hard module-resolution
+ * crash at app boot. (The Velion example app installs it; third-party
+ * consumers without a Fingerprint workspace can swap defaults via
+ * `fingerprintApiKey` / `fingerprintEndpoint` in `VelionConfig`.)
+ */
+/** Public shape of the result. */
+export interface DeviceFingerprintResult {
+    request_id: string;
+    sealed_result?: string;
+}
+export interface DeviceFingerprintOptions {
+    /** Custom endpoint subdomain (proxied through Velion infra). */
+    endpoint: string;
+    /** Optional override for the public Fingerprint Pro key. */
+    apiKey?: string;
+    /** Hard ceiling for the call (ms). The SDK's own timeout can hang past this; we Promise.race against it. */
+    timeoutMs?: number;
+}
+/**
+ * Calls Fingerprint Pro RN to obtain `requestId` + optional `sealedResult`,
+ * the only two pieces of data the Velion backend cares about. Throws a
+ * shaped `SdkError` on any failure (missing module, agent init error,
+ * network).
+ */
+export declare function generateDeviceFingerprint(options: DeviceFingerprintOptions): Promise<DeviceFingerprintResult>;
+//# sourceMappingURL=deviceFingerprint.d.ts.map

package/lib/typescript/utils/deviceFingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviceFingerprint.d.ts","sourceRoot":"","sources":["../../../src/utils/deviceFingerprint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,kCAAkC;AAClC,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,wBAAwB;IACvC,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4GAA4G;IAC5G,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAkDD;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,uBAAuB,CAAC,CAwFlC"}

package/lib/typescript/utils/documentTypeOptions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Default identification document option for HUMAN_BASIC_INFO when the backend
+ * does not send `accepted_country_documents` (same label keys as legacy UI).
+ */
+/**
+ * Fallback list for the HUMAN_BASIC_INFO identification type selector when step config
+ * does not include document types from the backend.
+ */
+export declare function resolveDocumentTypeOptions(uiLocale: string): Array<{
+    value: string;
+    label: string;
+}>;
+//# sourceMappingURL=documentTypeOptions.d.ts.map

package/lib/typescript/utils/documentTypeOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentTypeOptions.d.ts","sourceRoot":"","sources":["../../../src/utils/documentTypeOptions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAgBH;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,GACf,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAKzC"}

package/lib/typescript/utils/googleMapsPreflight.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Pre-flight checks for the assisted address flow.
+ *
+ * The SDK no longer calls any Google REST API from the client — reverse
+ * geocoding goes through the OS native geocoder (see `osGeocoder.ts`). What
+ * we still need to verify is:
+ *   1. `react-native-maps` is linked.
+ *   2. On Android, the Google Maps key is declared in `AndroidManifest.xml`
+ *      as `<meta-data android:name="com.google.android.geo.API_KEY" .../>`.
+ *      Without that, mounting `<MapView>` throws a native
+ *      `IllegalStateException` from the Fabric UI manager — a JS error
+ *      boundary cannot catch it because the throw happens in a native
+ *      thread during the UI commit.
+ *
+ * Note that these probes cannot catch the iOS-specific case where
+ * `react-native-maps` IS installed but the `AirGoogleMaps` sub-target was
+ * never added to the Xcode project — that one only surfaces at render time
+ * and is handled by `MapFallbackBoundary`.
+ */
+/**
+ * Returns true when `react-native-maps` is importable and exposes the
+ * MapView component we need.
+ */
+export declare function isReactNativeMapsAvailable(): boolean;
+/**
+ * Best-effort probe for the Android `com.google.android.geo.API_KEY` meta-data
+ * in the host's `AndroidManifest.xml`.
+ *
+ * Returns:
+ *   - `true`  on iOS (the check does not apply — Apple Maps needs no key).
+ *   - `true`  when we can confirm the key is wired via the Expo config
+ *             (`android.config.googleMaps.apiKey`). Expo prebuild copies that
+ *             into the manifest, so its presence in `expoConfig` is a reliable
+ *             proxy for the real meta-data.
+ *   - `false` when `expo-constants` is available AND the Expo config does not
+ *             declare the key — we know prebuild produced a manifest without
+ *             the meta-data, so mounting `<MapView>` would crash.
+ *   - `undefined` when `expo-constants` is not installed (bare RN). We cannot
+ *             probe the manifest without a custom native module; the caller
+ *             should default to the previous behaviour (trust the integrator
+ *             when they pass `googleMapsApiKey` via `VelionConfig`).
+ */
+export declare function isAndroidGoogleMapsKeyInManifest(): boolean | undefined;
+//# sourceMappingURL=googleMapsPreflight.d.ts.map

package/lib/typescript/utils/googleMapsPreflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"googleMapsPreflight.d.ts","sourceRoot":"","sources":["../../../src/utils/googleMapsPreflight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CASpD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gCAAgC,IAAI,OAAO,GAAG,SAAS,CAetE"}

package/lib/typescript/utils/hmac.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview HMAC-SHA256 over JPEG frames for the Iris liveness flow.
+ *
+ * React Native's WebCrypto support is incomplete in Hermes (no `subtle.sign`),
+ * so we lean on `@noble/hashes` — pure JavaScript, ~10 KB, no native code.
+ *
+ * Canonical message (must match the Iris orchestrator exactly):
+ *   `${sessionId}\n${frameId}\n${ts}\n${sha256hex(jpeg)}`
+ *
+ * Output: lowercase hex MAC, sent in the JSON envelope's `mac` field.
+ */
+export interface HmacKey {
+    readonly raw: Uint8Array;
+}
+/** Decode the base64 frame_integrity_key from `/liveness-init`. */
+export declare function importHmacKey(base64: string): HmacKey;
+/**
+ * Build the signed envelope sent over the Iris WebSocket. Mirrors
+ * `LivenessModule.buildSignedEnvelope`:
+ *   1. Compute SHA-256 of the JPEG bytes (hex, lowercase).
+ *   2. Build the canonical message.
+ *   3. HMAC-SHA256 with the imported key.
+ *   4. Wrap into `{ type: 'FRAME', frameId, timestamp, image, mac }`.
+ *
+ * Returns the JSON string ready to `ws.send`.
+ */
+export declare function buildSignedFrameEnvelope(args: {
+    key: HmacKey;
+    sessionId: string;
+    frameId: number;
+    jpegBytes: Uint8Array;
+    jpegBase64: string;
+    /** Defaults to `Date.now()`. */
+    timestamp?: number;
+}): {
+    json: string;
+    timestamp: number;
+};
+//# sourceMappingURL=hmac.d.ts.map

package/lib/typescript/utils/hmac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["../../../src/utils/hmac.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;CAC1B;AAED,mEAAmE;AACnE,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,GAAG,EAAE,OAAO,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,UAAU,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAiBtC"}

package/lib/typescript/utils/iso3166Countries.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ISO 3166-1 alpha-2 country list with localized display names.
+ *
+ * Strategy:
+ *   1. If `Intl.DisplayNames` is available (full ICU build, polyfilled
+ *      Hermes, native iOS runtime, …), use it — it covers every BCP-47
+ *      locale and stays current with ICU updates.
+ *   2. Otherwise fall back to a built-in map covering all 249 ISO 3166-1
+ *      alpha-2 codes in `es` and `en`. The names match the official
+ *      Spanish convention (es. wikipedia.org/wiki/ISO_3166-1) and the ISO
+ *      English short name. Hermes default builds (which ship without
+ *      `Intl.DisplayNames`) get full localized names without needing
+ *      `@formatjs/intl-displaynames`.
+ */
+export interface Iso3166CountryOption {
+    readonly code: string;
+    readonly name: string;
+}
+/**
+ * Returns all ISO 3166-1 alpha-2 countries sorted by localized display name.
+ */
+export declare function listIso3166CountriesForUi(locale: string): Iso3166CountryOption[];
+/**
+ * Filters by country name or code (case-insensitive).
+ */
+export declare function filterIso3166Countries(options: readonly Iso3166CountryOption[], query: string): Iso3166CountryOption[];
+//# sourceMappingURL=iso3166Countries.d.ts.map

package/lib/typescript/utils/iso3166Countries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iso3166Countries.d.ts","sourceRoot":"","sources":["../../../src/utils/iso3166Countries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAyDD;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAchF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,SAAS,oBAAoB,EAAE,EACxC,KAAK,EAAE,MAAM,GACZ,oBAAoB,EAAE,CAMxB"}

package/lib/typescript/utils/jpegFromUri.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Helpers for reading a captured photo into JPEG bytes.
+ *
+ * Vision-Camera writes captures to a `file://` path; consumers convert that
+ * path into either base64 (for the Iris HMAC envelope) or raw bytes (for
+ * binary WebSocket frames + direct PUT to signed URLs).
+ *
+ * Why not `fetch(uri).then(r => r.blob()).then(b => b.arrayBuffer())`?
+ *
+ * React Native's Blob polyfill does NOT implement `Blob.arrayBuffer()`
+ * (it's web-only). Calling it crashes with
+ * `TypeError: blob.arrayBuffer is not a function`. The reliable path on
+ * iOS + Android is the native `File.arrayBuffer()` from
+ * `expo-file-system` v19+, which reads directly from disk into an
+ * ArrayBuffer without going through the JS Blob bridge.
+ */
+export interface JpegFromUri {
+    bytes: Uint8Array;
+    base64: string;
+    byteLength: number;
+}
+/**
+ * Reads a `file://` URI into JPEG bytes + base64 representation.
+ *
+ * Accepts both forms vision-camera returns (`/var/mobile/...` without a
+ * scheme on iOS; `file:///data/...` on Android). Normalises to `file://`.
+ */
+export declare function readJpegFromUri(uri: string): Promise<JpegFromUri>;
+//# sourceMappingURL=jpegFromUri.d.ts.map

package/lib/typescript/utils/jpegFromUri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jpegFromUri.d.ts","sourceRoot":"","sources":["../../../src/utils/jpegFromUri.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CASvE"}

package/lib/typescript/utils/keepAwake.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Thin wrapper around `expo-keep-awake` that prevents the device from
+ * locking the screen while the SDK is in the foreground. Without this,
+ * Android's screen-timeout policy kicks in during camera-heavy steps
+ * (LIVENESS_MATCH, DOCUMENTS_OCR) where the user is holding still and
+ * not interacting with the touchscreen — the screen dims, then locks,
+ * and the session is interrupted.
+ *
+ * Implementation is `require`-based so the SDK keeps working in bare
+ * React Native setups where `expo-keep-awake` may not be installed —
+ * in that case both calls degrade to no-ops and the host is expected to
+ * manage the wake lock itself.
+ */
+export declare function activateScreenKeepAwake(): void;
+export declare function deactivateScreenKeepAwake(): void;
+//# sourceMappingURL=keepAwake.d.ts.map

package/lib/typescript/utils/keepAwake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keepAwake.d.ts","sourceRoot":"","sources":["../../../src/utils/keepAwake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAuBH,wBAAgB,uBAAuB,IAAI,IAAI,CAc9C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAUhD"}

package/lib/typescript/utils/log.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Lightweight log gate.
+ *
+ * `log.info()` is silent unless either:
+ *   - `__DEV__` is true (Metro bundler injects this in development), or
+ *   - the host explicitly opted in via `VelionConfig.debug = true`.
+ *
+ * `log.warn()` / `log.error()` always go through. They sit on top of `console.*`
+ * so the host's logging pipeline (Sentry, Datadog, …) keeps capturing them.
+ */
+/** Enables verbose logging at runtime. Called from VelionOnboarding when `config.debug === true`. */
+export declare function setDebugEnabled(enabled: boolean): void;
+export declare const log: {
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+};
+//# sourceMappingURL=log.d.ts.map

package/lib/typescript/utils/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/utils/log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,qGAAqG;AACrG,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEtD;AAOD,eAAO,MAAM,GAAG;kBACA,OAAO,EAAE,GAAG,IAAI;kBAIhB,OAAO,EAAE,GAAG,IAAI;mBAGf,OAAO,EAAE,GAAG,IAAI;CAGhC,CAAC"}

package/lib/typescript/utils/osGeocoder.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Reverse geocoding via the OS-native geocoder, bypassing Google's REST API
+ * entirely.
+ *
+ * Why this exists:
+ *   - The Google Geocoding Web Service is HTTP REST. It does not honour
+ *     iOS/Android application restrictions on the API key, so a key tightly
+ *     locked to a bundle ID still fails with REQUEST_DENIED when called from
+ *     fetch().
+ *   - The OS geocoder (CLGeocoder on iOS / android.location.Geocoder on
+ *     Android) needs no Google key and respects the platform conventions
+ *     users expect. Coverage in urban LATAM is excellent; rural coverage on
+ *     iOS uses Apple Maps (lower than Google in remote zones) but the
+ *     downstream OCR step normally recovers the printed address either way.
+ *   - Keeps the SDK to one Google Maps key whose only purpose is rendering
+ *     the map via the native Maps SDK — that one IS protected by the iOS /
+ *     Android app restriction.
+ *
+ * Returns the same `ParsedAddressFields` shape that the previous Google
+ * Geocoding caller produced, so downstream code (`AddressDetailsForm`,
+ * payload assembly) doesn't change.
+ */
+import { type ParsedAddressFields } from './parseGoogleAddressComponents';
+export interface ReverseGeocodeArgs {
+    latitude: number;
+    longitude: number;
+    /** `'es'` or `'en'` — passed through to the OS where supported. */
+    locale?: string;
+}
+/**
+ * Returns parsed structured address fields, or `null` when the OS geocoder
+ * has no match.
+ */
+export declare function reverseGeocode(args: ReverseGeocodeArgs): Promise<(ParsedAddressFields & {
+    latitude: number;
+    longitude: number;
+}) | null>;
+//# sourceMappingURL=osGeocoder.d.ts.map

package/lib/typescript/utils/osGeocoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"osGeocoder.d.ts","sourceRoot":"","sources":["../../../src/utils/osGeocoder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,EACL,KAAK,mBAAmB,EACzB,MAAM,gCAAgC,CAAC;AAGxC,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,CAAC,mBAAmB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,CAAC,CAgCjF"}

package/lib/typescript/utils/parseGoogleAddressComponents.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Maps Google Geocoder / Places `address_components` into
+ * `AddressInfoPayload` fields.
+ *
+ * The wire shape used here is whatever the Google Geocoding REST API
+ * returns: `{ long_name, short_name, types: string[] }`.
+ */
+export interface GoogleAddressComponent {
+    long_name: string;
+    short_name: string;
+    types: string[];
+}
+export interface ParsedAddressFields {
+    country: string;
+    state: string;
+    city: string;
+    district?: string;
+    neighborhood?: string;
+    street: string;
+    number: string;
+    zip_code: string;
+}
+/**
+ * Parses `address_components` from a Geocoder result or Place result.
+ * Applies fallbacks so required API fields are usually non-empty when Google
+ * returns a result.
+ */
+export declare function parseGoogleAddressComponents(components: GoogleAddressComponent[] | null | undefined, formattedAddress: string | undefined, lat: number, lng: number): ParsedAddressFields & {
+    latitude: number;
+    longitude: number;
+};
+/**
+ * True when the parsed address has enough required fields to send to the
+ * backend.
+ */
+export declare function isAddressSelectionComplete(parsed: ParsedAddressFields, required?: {
+    state?: boolean | undefined;
+    city?: boolean | undefined;
+    street?: boolean | undefined;
+    number?: boolean | undefined;
+    postal?: boolean | undefined;
+}): boolean;
+//# sourceMappingURL=parseGoogleAddressComponents.d.ts.map

package/lib/typescript/utils/parseGoogleAddressComponents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseGoogleAddressComponents.d.ts","sourceRoot":"","sources":["../../../src/utils/parseGoogleAddressComponents.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAYD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,sBAAsB,EAAE,GAAG,IAAI,GAAG,SAAS,EACvD,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,mBAAmB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAgD/D;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,GAAE;IACR,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACzB,GACL,OAAO,CAcT"}

package/lib/typescript/utils/personNameNormalize.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Normalizes a single name field (given names or surnames) for API submission.
+ *
+ * - Trims leading/trailing whitespace
+ * - Applies Unicode NFC (composed form) for consistent encoding
+ * - Splits on any run of whitespace and rejoins with a single ASCII space,
+ *   so multiple internal spaces or line breaks become one separator between words
+ */
+export declare function normalizePersonNameSegment(raw: string): string;
+//# sourceMappingURL=personNameNormalize.d.ts.map

package/lib/typescript/utils/personNameNormalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"personNameNormalize.d.ts","sourceRoot":"","sources":["../../../src/utils/personNameNormalize.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ9D"}

package/lib/typescript/utils/sdkError.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Helpers to normalize thrown values into SdkError for consistent onError delivery.
+ */
+import { SdkErrorCode, type SdkError } from '../types';
+/**
+ * Returns true if the value looks like an SdkError (has code and message).
+ */
+export declare function isSdkError(value: unknown): value is SdkError;
+/**
+ * Normalizes any thrown value to an SdkError so it can be passed to rejectStep/onError.
+ * Use when catching in a flow that must always end with an event to the implementer.
+ */
+export declare function toSdkError(err: unknown, defaultCode: SdkErrorCode, defaultMessage: string): SdkError;
+//# sourceMappingURL=sdkError.d.ts.map

package/lib/typescript/utils/sdkError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdkError.d.ts","sourceRoot":"","sources":["../../../src/utils/sdkError.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEvD;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAS5D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,OAAO,EACZ,WAAW,EAAE,YAAY,EACzB,cAAc,EAAE,MAAM,GACrB,QAAQ,CAWV"}

package/lib/typescript/utils/sdkVersion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compile-time SDK version string sent on every authenticated request as
+ * `X-Velion-SDK-Version`. Bump it together with `sdk/package.json#version`
+ * on every release.
+ */
+export declare const SDK_VERSION: "0.1.0";
+//# sourceMappingURL=sdkVersion.d.ts.map

package/lib/typescript/utils/sdkVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdkVersion.d.ts","sourceRoot":"","sources":["../../../src/utils/sdkVersion.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAG,OAAgB,CAAC"}

package/lib/typescript/utils/stepConfig.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentCaptureMode, DocumentsOcrStepConfig, HumanBasicInfoStepConfig, TermsAndConditionsItem, TermsAndConditionsStepConfig } from '../types';
+export declare function resolveDocumentOptionsFromStepConfig(cfg: HumanBasicInfoStepConfig | undefined): Array<{
+    value: string;
+    label: string;
+}> | undefined;
+export declare function resolveCaptureModeFromStepConfig(cfg: DocumentsOcrStepConfig | undefined): DocumentCaptureMode | undefined;
+export declare function resolveTermsFromStepConfig(cfg: TermsAndConditionsStepConfig | undefined): TermsAndConditionsItem[] | undefined;
+//# sourceMappingURL=stepConfig.d.ts.map

package/lib/typescript/utils/stepConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stepConfig.d.ts","sourceRoot":"","sources":["../../../src/utils/stepConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,4BAA4B,EAC7B,MAAM,UAAU,CAAC;AAElB,wBAAgB,oCAAoC,CAClD,GAAG,EAAE,wBAAwB,GAAG,SAAS,GACxC,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAAS,CAmBrD;AAED,wBAAgB,gCAAgC,CAC9C,GAAG,EAAE,sBAAsB,GAAG,SAAS,GACtC,mBAAmB,GAAG,SAAS,CASjC;AAED,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,4BAA4B,GAAG,SAAS,GAC5C,sBAAsB,EAAE,GAAG,SAAS,CAetC"}