@webority/mobile-core 0.0.23

package/lib/typescript/commonjs/permissions/notifications.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=notifications.d.ts.map

package/lib/typescript/commonjs/permissions/photos.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=photos.d.ts.map

package/lib/typescript/commonjs/phone/countries.d.ts

@@ -0,0 +1,13 @@
+/**
+ * English display names for every country libphonenumber-js knows, keyed by
+ * ISO 3166-1 alpha-2. GENERATED by scripts/gen-phone-countries.mjs from Node's
+ * Intl.DisplayNames('en', { type: 'region' }) over getCountries() on 2026-09-14;
+ * '&' is written as 'and'. Re-run the script rather than editing by hand.
+ *
+ * Lives on its own import path (mobile-core/phone/countries) so an app that
+ * never opens a full country list does not carry these 245 strings in its
+ * bundle. Pair with getPhoneCountries() from the package root for the calling
+ * codes; a country picker that needs another language supplies its own names.
+ */
+export declare const PHONE_COUNTRY_NAMES: Readonly<Record<string, string>>;
+//# sourceMappingURL=countries.d.ts.map

package/lib/typescript/commonjs/share/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Opens a downloaded file through the system share sheet, where the person picks
+ * a viewer or saves it. A separate entry point because it names expo-sharing, an
+ * optional peer: Metro resolves every require reachable from an import, so keeping
+ * it off the main barrel and off `/download` lets an app skip the package when it
+ * never opens files.
+ *
+ * The share sheet rather than `Linking.openURL`: Android 7 and later refuse a
+ * `file://` link, and a `content://` link sent through Linking carries no read
+ * grant, so the OS-open route never reached a viewer there.
+ */
+export type ShareErrorCode = 'unavailable' | 'failed';
+export declare class ShareError extends Error {
+    readonly code: ShareErrorCode;
+    constructor(code: ShareErrorCode, message: string);
+}
+export interface ShareFileOptions {
+    /** Picks the apps Android offers; mapped to a UTI for iOS where one is known. */
+    mimeType?: string;
+    /** The share sheet's title on Android. */
+    dialogTitle?: string;
+}
+/**
+ * Hands a local file (the `path` `downloadFile` returns) to the share sheet.
+ * A bare path is given a `file://` scheme. Rejects with `ShareError`: `unavailable`
+ * when the device has no share sheet, `failed` when the sheet could not open the file.
+ */
+export declare const shareFile: (path: string, options?: ShareFileOptions) => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/smsRetriever/index.d.ts

@@ -0,0 +1,30 @@
+export interface SmsRetrieverError {
+    type: 'TIMEOUT' | 'SERVICE_UNAVAILABLE' | 'UNKNOWN_ERROR';
+    message: string;
+}
+export interface SmsListenerSubscription {
+    remove: () => void;
+}
+export interface SmsRetrieverBackend {
+    getAppHash: () => Promise<string>;
+    startListening: (onMessage: (message: string) => void, onError?: (error: SmsRetrieverError) => void) => SmsListenerSubscription;
+}
+/** Test-only injection point. Pass `null` to reset to the native module. */
+export declare const setSmsRetrieverImplementation: (impl: SmsRetrieverBackend | null) => void;
+/**
+ * The Play Services SMS Retriever API — auto-reads an incoming OTP SMS with
+ * no SMS permission, matched by an 11-character app-signature hash
+ * (`getAppHash`) the backend appends to the message. Android only; every
+ * method is safe to call on iOS and resolves/reports unavailable rather than
+ * throwing, so a caller doesn't need a platform check at every call site.
+ *
+ * OTP extraction is left to the caller — `onMessage` receives the raw SMS
+ * text, since the expected OTP format (digit count, prefix) is a backend
+ * concern, not this module's.
+ */
+export declare const SmsRetriever: {
+    isAvailable: () => boolean;
+    getAppHash: () => Promise<string>;
+    startListening: (onMessage: (message: string) => void, onError?: (error: SmsRetrieverError) => void) => SmsListenerSubscription;
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/specs/NativeSmsRetriever.d.ts

@@ -0,0 +1,15 @@
+import type { TurboModule } from 'react-native';
+/**
+ * Android-only — the Play Services SMS Retriever API has no iOS equivalent.
+ * The JS wrapper in `smsRetriever/index.ts` never touches this module on
+ * iOS, so `getEnforcing` only ever runs on Android, where autolinking has
+ * registered `SmsRetrieverPackage`.
+ */
+export interface Spec extends TurboModule {
+    startSMSListener(): void;
+    stopSMSListener(): void;
+    getAppHash(): Promise<string>;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeSmsRetriever.d.ts.map

package/lib/typescript/commonjs/sqlite/adapters/expo.d.ts

@@ -0,0 +1,30 @@
+import type { SqliteDriver } from '../index';
+/**
+ * expo-sqlite. Shape verified against 57.0.2 rather than assumed, and it is the
+ * one driver that cannot share an adapter with the others: expo splits reads
+ * from writes. `getAllAsync` yields rows but no change count, `runAsync` yields
+ * `{ changes, lastInsertRowId }` but no rows, and SqliteResultSet needs all
+ * three from one call. `prepareAsync` + `executeAsync` is the only call that
+ * returns both, so every statement goes through it rather than being routed by
+ * sniffing the SQL for a leading SELECT.
+ *
+ * The REQUIRE lives in the driver entry point beside this file, never here.
+ */
+export interface ExpoSqliteExecuteResult {
+    lastInsertRowId: number;
+    changes: number;
+    getAllAsync: () => Promise<Record<string, unknown>[]>;
+}
+export interface ExpoSqliteStatementLike {
+    executeAsync: (params: unknown[]) => Promise<ExpoSqliteExecuteResult>;
+    finalizeAsync: () => Promise<void>;
+}
+export interface ExpoSqliteDatabaseLike {
+    prepareAsync: (source: string) => Promise<ExpoSqliteStatementLike>;
+    closeAsync: () => Promise<void>;
+}
+export interface ExpoSqliteModuleLike {
+    openDatabaseAsync: (name: string, options?: Record<string, unknown>, directory?: string) => Promise<ExpoSqliteDatabaseLike>;
+}
+export declare const adaptExpoSqlite: (mod: ExpoSqliteModuleLike) => SqliteDriver;
+//# sourceMappingURL=expo.d.ts.map

package/lib/typescript/commonjs/sqlite/index.d.ts

@@ -0,0 +1,113 @@
+/**
+ * expo-sqlite is the fleet's only sanctioned SQLite driver (react-native.md:
+ * "we will always use expo-sqlite, what Expo gives, we don't look elsewhere
+ * ever") — this module resolves it automatically, with no app-side wiring.
+ * `setSqliteImplementation` still exists, narrowed to tests and the showcase:
+ * it injects a denying/failing backend to reach error paths a healthy device
+ * never takes, the same pattern every other injectable surface in this
+ * library follows. It is not a way to pick an alternate real driver.
+ */
+export interface SqliteResultSet {
+    rows: Record<string, unknown>[];
+    rowsAffected: number;
+    insertId?: number;
+}
+export interface SqliteDatabase {
+    execute: (sql: string, params?: readonly unknown[]) => Promise<SqliteResultSet>;
+    close: () => Promise<void>;
+}
+export interface SqliteDriver {
+    open: (name: string, options?: {
+        location?: string;
+    }) => Promise<SqliteDatabase>;
+}
+/**
+ * Test/showcase-only injection point — see the module header. Not a way to
+ * pick an alternate real driver; `@webority/mobile-core` always
+ * resolves expo-sqlite when nothing is injected. Pass `null` to clear it.
+ */
+export declare const setSqliteImplementation: (impl: SqliteDriver | null) => void;
+export declare const isSqliteAvailable: () => boolean;
+/** The ledger of applied migrations. Never emptied by `wipe`. */
+export declare const MIGRATIONS_TABLE = "_webority_migrations";
+/**
+ * SQLite cannot bind an identifier to `?`, so every table/column name reaching
+ * a statement is concatenated. This is the ONE place that is allowed to happen,
+ * and it throws rather than quoting a hostile name into something executable.
+ */
+export declare const assertSqlIdentifier: (value: unknown, kind?: string) => string;
+/** Normalise a JS value into something every SQLite driver can bind. */
+export declare const toSqliteValue: (value: unknown) => unknown;
+/** SQLite has no boolean type, so a stored flag comes back as 0/1 or '0'/'1'. */
+export declare const fromSqliteBoolean: (value: unknown) => boolean;
+/**
+ * Build an `IN (...)` clause with one placeholder per value. An empty list
+ * yields a clause that matches nothing, because `IN ()` is a syntax error.
+ */
+export declare const whereIn: (column: string, values: readonly unknown[]) => {
+    sql: string;
+    params: unknown[];
+};
+export interface RawWhere {
+    sql: string;
+    params?: readonly unknown[];
+}
+/**
+ * Either a map of column to value (ANDed, `null` meaning IS NULL) or a raw
+ * fragment for anything the object form cannot express.
+ */
+export type Where = Record<string, unknown> | RawWhere;
+export interface FindOptions {
+    orderBy?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface Migration {
+    version: number;
+    name?: string;
+    up: string | string[] | ((tx: Pick<Db, 'execute'>) => Promise<void>);
+}
+export interface MigrateOptions {
+    /**
+     * Skip the downgrade guard. Only set this when the app knows the older code
+     * can read the newer schema.
+     */
+    allowDowngrade?: boolean;
+}
+export declare const DEFAULT_PRAGMAS: Readonly<Record<string, string | number>>;
+export interface OpenDatabaseOptions {
+    location?: string;
+    /**
+     * Merged over DEFAULT_PRAGMAS and applied on open. Pass `false` to apply none.
+     */
+    pragmas?: Record<string, string | number> | false;
+}
+export interface Db {
+    readonly name: string;
+    execute: (sql: string, params?: readonly unknown[]) => Promise<SqliteResultSet>;
+    select: <T = Record<string, unknown>>(sql: string, params?: readonly unknown[]) => Promise<T[]>;
+    selectOne: <T = Record<string, unknown>>(sql: string, params?: readonly unknown[]) => Promise<T | null>;
+    transaction: <T>(work: (tx: Pick<Db, 'execute' | 'select' | 'selectOne'>) => Promise<T>) => Promise<T>;
+    insert: (table: string, row: Record<string, unknown>) => Promise<number | undefined>;
+    insertMany: (table: string, rows: Record<string, unknown>[]) => Promise<number>;
+    update: (table: string, values: Record<string, unknown>, where: Where) => Promise<number>;
+    remove: (table: string, where: Where) => Promise<number>;
+    upsert: (table: string, row: Record<string, unknown>, conflictColumns: string[]) => Promise<void>;
+    findAll: <T = Record<string, unknown>>(table: string, where?: Where, options?: FindOptions) => Promise<T[]>;
+    findOne: <T = Record<string, unknown>>(table: string, where?: Where) => Promise<T | null>;
+    count: (table: string, where?: Where) => Promise<number>;
+    tableExists: (table: string) => Promise<boolean>;
+    createTable: (table: string, columns: Record<string, string>, options?: {
+        ifNotExists?: boolean;
+    }) => Promise<void>;
+    dropTable: (table: string, options?: {
+        ifExists?: boolean;
+    }) => Promise<void>;
+    wipe: () => Promise<void>;
+    reset: (migrations: Migration[]) => Promise<number>;
+    migrate: (migrations: Migration[], options?: MigrateOptions) => Promise<number>;
+    baseline: (version: number, migrations?: Migration[]) => Promise<void>;
+    close: () => Promise<void>;
+}
+export declare const openDatabase: (name: string, options?: OpenDatabaseOptions) => Promise<Db>;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/storage/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Minimal AsyncStorage shape we depend on.
+ * Lets us avoid a hard import on `@react-native-async-storage/async-storage`.
+ */
+interface AsyncStorageLike {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+    /**
+     * The batch API exists under TWO names, and both are live in this fleet.
+     *
+     * `@react-native-async-storage/async-storage` 3 renamed the v1 trio and
+     * changed their shapes: `getMany` returns a Record where `multiGet` returned
+     * pairs, and `setMany` takes a Record where `multiSet` took pairs. The v1
+     * names are still what `expo-sqlite/kv-store` and AsyncStorage 2 expose.
+     *
+     * Declaring only one set is not a compile error and not a runtime error — it
+     * silently falls through to the per-key loop below. The fleet pins
+     * AsyncStorage 3, so recognising only the v1 names put every consumer on N
+     * round-trips per batch with nothing to notice.
+     */
+    getMany?: (keys: string[]) => Promise<Record<string, string | null>>;
+    setMany?: (entries: Record<string, string>) => Promise<void>;
+    removeMany?: (keys: string[]) => Promise<void>;
+    multiGet?: (keys: readonly string[]) => Promise<readonly [string, string | null][]>;
+    multiSet?: (kvs: readonly [string, string][]) => Promise<void>;
+    multiRemove?: (keys: readonly string[]) => Promise<void>;
+    clear?: () => Promise<void>;
+    getAllKeys?: () => Promise<readonly string[]>;
+}
+/**
+ * Always true now that the backend ships with the library. Kept because callers
+ * whose use of storage is an OPTIMISATION branch on it, and removing it would
+ * be a breaking change for no gain.
+ */
+export declare const isStorageAvailable: () => boolean;
+/**
+ * Replace the storage backend. Intended for TESTS and for the showcase; an app
+ * gets expo-sqlite/kv-store without wiring anything. Pass `null` to restore it.
+ */
+export declare const setStorageImplementation: (impl: AsyncStorageLike | null) => void;
+export interface StorageApi {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<boolean>;
+    removeItem: (key: string) => Promise<boolean>;
+    getJson: <T>(key: string) => Promise<T | null>;
+    setJson: <T>(key: string, value: T) => Promise<boolean>;
+    multiGet: (keys: readonly string[]) => Promise<Record<string, string | null>>;
+    multiSet: (entries: Record<string, string>) => Promise<boolean>;
+    multiRemove: (keys: readonly string[]) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    getAllKeys: () => Promise<string[]>;
+}
+/**
+ * Typed AsyncStorage wrapper with safe JSON helpers.
+ * All operations swallow errors (logging them) and return a falsy result
+ * so that storage problems never crash the app.
+ *
+ * Backed by `expo-sqlite/kv-store` by default;
+ * override with `setStorageImplementation()` for MMKV or custom adapters.
+ */
+export declare const Storage: StorageApi;
+export type { AsyncStorageLike };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/utils/imageCompression.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Image compression for uploads: the whole shell an app needs around a
+ * picked photo, so an app calls this once and uploads what comes back.
+ *
+ * What it does, in order:
+ *
+ * 1. Measures the source. A missing or EMPTY file throws `ImageUnreadableError`
+ *    so the user is asked to retake: the OS evicts a camera temp file between
+ *    capture and a delayed save, and uploading the empty result is a certain
+ *    server rejection that can wedge an outbox.
+ * 2. Decodes the photo ONCE and reads its size. The longer side is brought
+ *    down to `maxSize` (1500 by default, the fleet standard); a photo already
+ *    within it is never enlarged.
+ * 3. Re-encodes at a quality picked from the source's real byte size (bigger
+ *    files are compressed harder), or at the `quality` given. The re-encode
+ *    drops EXIF as a side effect; location and time travel as payload fields,
+ *    never add a second stripping step.
+ * 4. With `maxBytes`, keeps re-encoding at a lower quality, then a smaller
+ *    size, until the output fits, deleting each superseded file.
+ * 5. Measures the output the same way as the source and returns everything
+ *    an upload needs: uri, pixel size, byte size, mime type, extension, file
+ *    name and a ready `FormData` part.
+ *
+ * Only an ENCODER failure falls back to the original file, reported through
+ * `compressed: false` with the original's own type and size; the reference
+ * apps upload the original rather than lose the photo. An unreadable file is
+ * never a fallback, it throws.
+ *
+ * Backed by `expo-image-manipulator` and `expo-file-system`; an app wires
+ * nothing. Tests and the showcase inject a backend through
+ * `setImageCompressorImplementation`.
+ */
+export type ImageOutputFormat = 'jpg' | 'png' | 'webp';
+export interface CompressImageOptions {
+    /** Bound on the LONGER side in pixels; never enlarges. Defaults to 1500. */
+    maxSize?: number;
+    /**
+     * JPEG/WebP quality, 0 to 1. Overrides the size-based quality ladder. PNG
+     * is lossless and ignores it.
+     */
+    quality?: number;
+    /** Output format. Defaults to `'jpg'`. */
+    output?: ImageOutputFormat;
+    /**
+     * Byte size of the source as the picker reported it. Only a HINT for the
+     * quality ladder when the file cannot be measured (an Android `content://`
+     * URI); a measurable file is measured, because the picker's number can be
+     * stale by the time this runs.
+     */
+    fileSize?: number;
+    /**
+     * Byte ceiling for the output (an API's upload limit). Quality is stepped
+     * down to `minQuality`, then the size is stepped down, until the output
+     * fits. Best effort: the result's `size` says whether it did.
+     */
+    maxBytes?: number;
+    /** Lowest quality the `maxBytes` ladder may reach. Defaults to 0.4. */
+    minQuality?: number;
+    /**
+     * Base name for the output file (any extension is replaced by the output
+     * format's). Defaults to the source's own name, or `image`. A picked photo
+     * has no useful name of its own; a list of twelve documents all called
+     * `image.jpg` is unreadable.
+     */
+    name?: string;
+}
+export interface CompressedImage {
+    /** Local URI of the file to upload. */
+    uri: string;
+    /** Pixel size; null only for an uncompressed original that could not be decoded. */
+    width: number | null;
+    height: number | null;
+    /** Byte size on disk; null only for an uncompressed original that could not be measured. */
+    size: number | null;
+    /** `image/jpeg`, `image/png` or `image/webp`; the original's own type when `compressed` is false. */
+    mimeType: string;
+    /** Extension without the dot: `jpg`, `png`, `webp`. */
+    extension: string;
+    /** `<name>.<extension>`. */
+    fileName: string;
+    /** False when the encoder failed and this is the untouched original. */
+    compressed: boolean;
+    /** The quality the output was encoded at; null for PNG and for an original. */
+    quality: number | null;
+    /** The file part React Native's `FormData` wants: `formData.append('file', part)`. */
+    part: {
+        uri: string;
+        name: string;
+        type: string;
+    };
+}
+/** The source was missing or empty, or the encoder produced an empty file. */
+export declare class ImageUnreadableError extends Error {
+    readonly uri: string;
+    constructor(uri: string, reason: string);
+}
+export interface ImageFileStat {
+    exists: boolean;
+    size: number;
+}
+export interface EncodeOptions {
+    /** Target size; one side only, the other follows the aspect ratio. Omit both to keep the size. */
+    width?: number;
+    height?: number;
+    quality: number;
+    format: 'jpeg' | 'png' | 'webp';
+}
+export interface EncodedImage {
+    uri: string;
+    width: number;
+    height: number;
+}
+/** A decoded image, held in memory until `close`. */
+export interface OpenedImage {
+    width: number;
+    height: number;
+    encode: (options: EncodeOptions) => Promise<EncodedImage>;
+    close: () => void;
+}
+/**
+ * What the algorithm needs from a backend. The default is built on
+ * expo-image-manipulator and expo-file-system.
+ */
+export interface ImageCompressorLike {
+    /** Size and existence of a local file; null when the URI cannot be measured (unsupported scheme). */
+    stat: (uri: string) => Promise<ImageFileStat | null>;
+    /** Delete a file this module wrote; errors are swallowed by the caller. */
+    remove: (uri: string) => Promise<void>;
+    /** Decode once; `encode` re-renders from the decoded image, not the file. */
+    open: (uri: string) => Promise<OpenedImage>;
+}
+/**
+ * Replace the backend. Intended for TESTS and for the showcase; an app gets
+ * the expo modules without wiring anything. Pass `null` to restore them.
+ */
+export declare const setImageCompressorImplementation: (impl: ImageCompressorLike | null) => void;
+/**
+ * Bigger source files get compressed harder: a fixed quality either
+ * over-compresses small photos or leaves large ones too heavy to upload
+ * quickly. Unknown size falls back to the middle rung rather than assuming
+ * either extreme. The fleet ladder (`react-native.md`).
+ */
+export declare const qualityForFileSize: (fileSize?: number | null) => number;
+/**
+ * Compress an image for upload. See the module comment for the contract.
+ *
+ * @throws ImageUnreadableError when the source is missing or empty, or the
+ * encoder produced an empty file. Any other failure returns the original with
+ * `compressed: false`.
+ */
+export declare const compressImage: (uri: string, options?: CompressImageOptions) => Promise<CompressedImage>;
+//# sourceMappingURL=imageCompression.d.ts.map

package/lib/typescript/commonjs/utils/index.d.ts

@@ -0,0 +1,3 @@
+export type { CompressImageOptions, ImageCompressorLike } from './imageCompression';
+export { compressImage, setImageCompressorImplementation } from './imageCompression';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/validators/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Generic validators returning `boolean`. All accept `null`/`undefined` safely.
+ *
+ * Tradeoff: regexes are pragmatic, not RFC-strict. They reject the things real users
+ * typo and accept the long tail of legitimate inputs. For RFC-grade validation use
+ * a dedicated library at the boundary.
+ */
+export declare const isNonEmpty: (value: unknown) => boolean;
+export declare const isEmail: (value: unknown) => boolean;
+/**
+ * Validate an Indian mobile number. Accepts:
+ * - 10-digit number starting with 6-9
+ * - Optional `+91` or `91` country code prefix
+ */
+export declare const isIndianMobile: (value: unknown) => boolean;
+/**
+ * Generic phone validator: 7–15 digits, optional `+` prefix.
+ * Use `isIndianMobile` when you specifically need an Indian mobile number.
+ */
+export declare const isPhone: (value: unknown) => boolean;
+export declare const isUrl: (value: unknown) => boolean;
+export declare const isNumeric: (value: unknown) => boolean;
+export declare const isInteger: (value: unknown) => boolean;
+export declare const isAlphanumeric: (value: unknown) => boolean;
+export interface PasswordRules {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumber?: boolean;
+    requireSymbol?: boolean;
+}
+/**
+ * Common password complexity check. Defaults to 8+ chars,
+ * one uppercase, one lowercase, one digit.
+ */
+export declare const isStrongPassword: (value: unknown, rules?: PasswordRules) => boolean;
+export declare const isIndianPincode: (value: unknown) => boolean;
+export declare const isPan: (value: unknown) => boolean;
+export declare const isGstin: (value: unknown) => boolean;
+/**
+ * The same rules the Webority servers apply: spaces and hyphens stripped (as
+ * printed on the card), twelve digits, no leading 0 or 1, and a correct
+ * Verhoeff check digit.
+ */
+export declare const isAadhaar: (value: unknown) => boolean;
+export declare const isIfsc: (value: unknown) => boolean;
+export declare const isHexColor: (value: unknown) => boolean;
+export declare const isBetween: (value: unknown, min: number, max: number, inclusive?: boolean) => boolean;
+export declare const minLength: (value: unknown, length: number) => boolean;
+export declare const maxLength: (value: unknown, length: number) => boolean;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/versionCheck/index.d.ts

@@ -0,0 +1,80 @@
+import { type Environment } from '../config';
+/**
+ * Minimal device-info shape we depend on.
+ *
+ * This is a LAST RESORT, not the primary path. `Platform.OS` already gives the
+ * platform, and every Webority app carries its own store id and version in
+ * `appsettings.Compiled.json` — so `setConfig({ appId, appVersion })` covers
+ * both remaining values without a native module. The injector below exists for
+ * apps that would rather hand us a `react-native-device-info` instance than
+ * wire two config keys.
+ */
+interface DeviceInfoLike {
+    getBundleId: () => string;
+    getVersion: () => string;
+}
+/**
+ * Supply the app identity from a native module instead of config.
+ * Prefer `setConfig({ appId, appVersion })` — it needs no native dependency.
+ * Pass `null` to clear.
+ */
+export declare const setDeviceInfoImplementation: (impl: DeviceInfoLike | null) => void;
+export type Platform = 'ios' | 'android' | string;
+export type UpdateType = 'major' | 'minor' | 'patch' | 'prerelease' | null;
+export interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string;
+}
+export interface VersionData {
+    version: string | null;
+    released?: string | null;
+    releasedAt?: string;
+    notes: string;
+    url: string | null;
+    country?: string;
+    lastChecked: string;
+}
+export interface VersionComparison {
+    needsUpdate: boolean;
+    updateType: UpdateType;
+    notice?: string;
+}
+export interface VersionCheckResult {
+    isNewVersionAvailable: boolean;
+    updateType: UpdateType;
+    url: string | null;
+}
+export interface UpdateInfo {
+    isUpdateRequired: boolean;
+    updateUrl: string | null;
+}
+export interface VersionCheckType {
+    /**
+     * Check if a new version is available.
+     * Includes retry logic and proper error handling.
+     */
+    isNewVersionAvailable: () => Promise<VersionCheckResult>;
+    /**
+     * Opens the appropriate store URL to update the app.
+     * Uses the provided URL or falls back to direct store URLs.
+     */
+    openUpdateUrl: (url?: string | null) => Promise<boolean>;
+    /**
+     * Get the fallback store URL.
+     * Useful when URL from version check fails.
+     */
+    getFallbackStoreUrl: () => string;
+}
+export declare const VersionCheck: VersionCheckType;
+/**
+ * Custom hook to check for required app updates.
+ *
+ * @param isAppReady - Whether the app is ready to perform the check
+ * @param environment - The app environment (defaults to the one in config)
+ */
+export declare const useVersionCheck: (isAppReady: boolean, environment?: Environment) => UpdateInfo;
+export default VersionCheck;
+export type { DeviceInfoLike };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/api/baseUrl.d.ts

@@ -0,0 +1,20 @@
+import type { AxiosInstance } from 'axios';
+/**
+ * Resolves `baseURL` PER REQUEST rather than at module evaluation.
+ *
+ * `axios.create({ baseURL: getConfigValue('baseUrl') })` reads the value once,
+ * when the module is first imported — which happens the moment anything touches
+ * the package barrel, long before an app's startup code can call `setConfig`.
+ * The result was a client permanently pinned to `undefined` and a `setConfig`
+ * that appeared to do nothing, with no error anywhere: requests just went to a
+ * relative URL.
+ *
+ * A consumer cannot fix that by ordering its own imports, because the import
+ * that loses the race is usually one it never wrote. So the clients stop
+ * capturing the value and ask for it per request instead.
+ *
+ * An explicit per-request `baseURL` still wins, which is what keeps a one-off
+ * call to a different host possible.
+ */
+export declare const applyConfiguredBaseUrl: (client: AxiosInstance) => void;
+//# sourceMappingURL=baseUrl.d.ts.map

package/lib/typescript/module/api/curl.d.ts

@@ -0,0 +1,18 @@
+import type { AxiosRequestConfig } from 'axios';
+/**
+ * Builds a copy-pasteable curl command for a request, with every credential
+ * replaced by a placeholder.
+ *
+ * The redaction is the point, not a nicety. An unredacted version of this in a
+ * consumer app put `Authorization: Bearer <token>` and the login request's
+ * plaintext password into the device console of a *release* staging build.
+ * A curl line is worth having; a curl line that has to be trusted not to be
+ * enabled in the wrong build is not.
+ */
+export declare const buildCurl: (config: AxiosRequestConfig) => string;
+/**
+ * Logs the curl equivalent of a request. Never throws: a failure to describe a
+ * request must not be able to fail the request itself.
+ */
+export declare const logCurl: (config: AxiosRequestConfig) => void;
+//# sourceMappingURL=curl.d.ts.map

package/lib/typescript/module/api/publicClient.d.ts

@@ -0,0 +1,11 @@
+import { type AxiosInstance } from 'axios';
+/**
+ * Public Axios Client
+ * - Base URL: Set your public API base URL.
+ * - No Authorization header is attached.
+ * - Includes timeout configuration and error handling.
+ * - Handles specific HTTP status codes.
+ */
+declare const publicClient: AxiosInstance;
+export default publicClient;
+//# sourceMappingURL=publicClient.d.ts.map