@webority-technologies/mobile-core 0.0.1 → 0.0.2

package/lib/typescript/commonjs/geolocation/adapters/expoLocation.d.ts

@@ -0,0 +1,42 @@
+import type { GeolocationLike } from '../index';
+/**
+ * The slice of expo-location this adapter uses. Verified against 57.0.14.
+ *
+ * The REQUIRE lives in the entry point beside this file, never here.
+ */
+export interface ExpoLocationObject {
+    coords?: {
+        latitude?: number;
+        longitude?: number;
+        altitude?: number | null;
+        accuracy?: number | null;
+        heading?: number | null;
+        speed?: number | null;
+    } | null;
+    timestamp?: number;
+}
+export interface ExpoLocationSubscription {
+    remove: () => void;
+}
+export interface ExpoLocationLike {
+    getCurrentPositionAsync: (options?: Record<string, unknown>) => Promise<ExpoLocationObject>;
+    watchPositionAsync: (options: Record<string, unknown>, callback: (location: ExpoLocationObject) => void) => Promise<ExpoLocationSubscription>;
+    getForegroundPermissionsAsync?: () => Promise<{
+        granted: boolean;
+    }>;
+    hasServicesEnabledAsync?: () => Promise<boolean>;
+}
+/**
+ * Adapts expo-location to the library's geolocation seam.
+ *
+ * The interesting half is `watchPosition`. The seam must hand back a numeric
+ * watch id SYNCHRONOUSLY, while `watchPositionAsync` only resolves its
+ * subscription later. So the adapter mints its own id immediately and stores
+ * the subscription against it on arrival. `clearWatch` called during that
+ * window records the id as cancelled, and the subscription is removed the
+ * moment it lands — without that, a screen that unmounts before the watch
+ * starts leaks a live GPS listener for the rest of the session, which is a
+ * battery drain nobody would attribute to this code.
+ */
+export declare const adaptExpoLocation: (mod: ExpoLocationLike) => GeolocationLike;
+//# sourceMappingURL=expoLocation.d.ts.map

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

@@ -0,0 +1,89 @@
+export interface GeoCoordinates {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+    altitude: number | null;
+    heading: number | null;
+    speed: number | null;
+}
+export interface GeoPosition {
+    coords: GeoCoordinates;
+    timestamp: number;
+}
+export type GeoErrorCode = 'permission-denied' | 'position-unavailable' | 'timeout' | 'services-disabled' | 'unsupported';
+export declare class GeolocationError extends Error {
+    readonly code: GeoErrorCode;
+    constructor(code: GeoErrorCode, message: string);
+}
+export interface GeoOptions {
+    /** `fine` maps to the platform's high-accuracy (GPS) provider. Default `fine`. */
+    accuracy?: 'fine' | 'coarse';
+    timeoutMs?: number;
+    maximumAgeMs?: number;
+    /** Extra attempts after the first, used only for `timeout` / `position-unavailable`. */
+    retries?: number;
+    /** A fix with a worse (larger) accuracy radius counts as `position-unavailable`. */
+    minimumAccuracyM?: number;
+    /**
+     * Pause between retries. Android's fused provider is frequently not ready on
+     * the first request after the permission grant or after location is switched
+     * on, and retrying immediately just re-collects the same failure.
+     */
+    retryDelayMs?: number;
+}
+export interface GeoWatchOptions extends GeoOptions {
+    /** Metres the device must move before the listener fires again. */
+    distanceFilterM?: number;
+    onError?: (error: GeolocationError) => void;
+}
+interface NativeGeoCoords {
+    latitude?: number | null;
+    longitude?: number | null;
+    accuracy?: number | null;
+    altitude?: number | null;
+    heading?: number | null;
+    speed?: number | null;
+}
+interface NativeGeoPosition {
+    coords?: NativeGeoCoords | null;
+    timestamp?: number | null;
+}
+interface NativeGeoError {
+    code?: number;
+    message?: string;
+}
+interface NativeGeoOptions {
+    enableHighAccuracy?: boolean;
+    timeout?: number;
+    maximumAge?: number;
+    distanceFilter?: number;
+}
+/** Minimal shape of the native geolocation module we depend on. */
+export interface GeolocationLike {
+    getCurrentPosition: (onSuccess: (position: NativeGeoPosition) => void, onError?: (error: NativeGeoError) => void, options?: NativeGeoOptions) => void;
+    watchPosition: (onSuccess: (position: NativeGeoPosition) => void, onError?: (error: NativeGeoError) => void, options?: NativeGeoOptions) => number;
+    clearWatch: (watchId: number) => void;
+}
+/**
+ * Replace the geolocation provider. Intended for TESTS and for the showcase,
+ * which injects a denying provider to demo the permission and services-off
+ * errors; an app gets expo-location without wiring anything. Pass `null` to
+ * restore it.
+ */
+export declare const setGeolocationImplementation: (impl: GeolocationLike | null) => void;
+export declare const Geolocation: {
+    getCurrentPosition: (options?: GeoOptions) => Promise<GeoPosition>;
+    watchPosition: (listener: (position: GeoPosition) => void, options?: GeoWatchOptions) => (() => void);
+    isAvailable: () => boolean;
+};
+export interface UseCurrentPositionResult {
+    position: GeoPosition | null;
+    error: GeolocationError | null;
+    loading: boolean;
+    refresh: () => void;
+}
+export declare const useCurrentPosition: (options?: GeoOptions & {
+    enabled?: boolean;
+}) => UseCurrentPositionResult;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -1,28 +1,45 @@
+/**
+ * The main barrel deliberately does NOT re-export the modules that need a native
+ * package. Metro resolves requires statically, so anything reachable from here
+ * is resolved for every consumer, which would make an optional peer mandatory
+ * for anyone importing anything at all. Those live behind their own import
+ * paths instead:
+ *
+ *   @webority-technologies/mobile-core/permissions  react-native-permissions
+ *   @webority-technologies/mobile-core/compressor   react-native-compressor
+ *   @webority-technologies/mobile-core/geolocation  a geolocation provider
+ *   @webority-technologies/mobile-core/sqlite       a SQLite driver
+ *   @webority-technologies/mobile-core/download     a filesystem module
+ *
+ * react-native-keychain is the exception and is a REQUIRED peer: the HTTP client
+ * reads the bearer token, so it is reachable from the main barrel by design.
+ */
+export { buildCurl, logCurl } from './api/curl';
 export { default as publicClient } from './api/publicClient';
+export type { RetryPolicy } from './api/retry';
+export { attachRetry, isRetryableStatus } from './api/retry';
 export type { RefreshableStore, SessionTerminationCode } from './api/userClient';
-export { default as userClient, injectAuthActions, injectStore, RequestOfflineError, SESSION_TERMINATION_CODES } from './api/userClient';
+export { default as userClient, injectAuthActions, injectStore, RequestOfflineError, resetRefreshState, SESSION_TERMINATION_CODES } from './api/userClient';
 export type { KeychainLike, StoredToken } from './auth/authStore';
-export { getToken, removeToken, setKeychainImplementation, storeToken } from './auth/authStore';
+export { ACCESS_TOKEN_KEY, getToken, REFRESH_TOKEN_KEY, removeToken, setKeychainImplementation, storeToken } from './auth/authStore';
 export type { JwtClaims } from './auth/jwt';
 export { decodeJWT, getJWTExpiry, isJWTExpired } from './auth/jwt';
 export type { Config, Environment, LogLevel } from './config';
 export { getConfig, getConfigValue, resetConfig, setConfig } from './config';
-export type { DateInput, DateStyle, FormatCurrencyOptions, TimeStyle } from './formatters';
-export { formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, normalizePhone } from './formatters';
+export type { DeepLinkConfig, DeepLinkRoute, ParsedLink } from './deepLink';
+export { DeepLink, parseDeepLink, useDeepLink } from './deepLink';
+export type { DateInput, DateStyle, FormatCurrencyOptions, FormatPhoneOptions, PhoneCountry, TimeStyle } from './formatters';
+export { detectPhoneCountry, formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, normalizePhone } from './formatters';
 export type { InitConfig } from './initSDK';
 export { initWebority } from './initSDK';
 export type { AuthActions } from './initUserAuth';
 export { initUserAuth } from './initUserAuth';
-export type { LoggerType, RemoteLogger } from './logger';
-export { Logger, setRemoteLogger } from './logger';
-export type { NetworkConnectionType, NetworkStatus, NetworkStatusListener } from './network';
-export { addNetworkStatusListener, getNetworkStatus, useNetworkStatus } from './network';
-export type { PermissionKind, PermissionStatus } from './permissions';
-export { Permissions } from './permissions';
+export type { DeviceContext, LoggerOptions, LoggerType, RemoteLogger } from './logger';
+export { configureLogger, getDeviceContext, Logger, setDeviceContext, setRemoteLogger } from './logger';
+export type { NetworkConnectionType, NetworkStatus, NetworkStatusLike, NetworkStatusListener } from './network';
+export { addNetworkStatusListener, getNetworkStatus, setNetworkStatusImplementation, useNetworkStatus } from './network';
 export type { AsyncStorageLike, StorageApi } from './storage';
-export { Storage, setStorageImplementation } from './storage';
-export type { CompressImageOptions } from './utils';
-export { compressImage } from './utils';
+export { isStorageAvailable, Storage, setStorageImplementation } from './storage';
 export type { PasswordRules } from './validators';
 export { isAadhaar, isAlphanumeric, isBetween, isEmail, isGstin, isHexColor, isIfsc, isIndianMobile, isIndianPincode, isInteger, isNonEmpty, isNumeric, isPan, isPhone, isStrongPassword, isUrl, maxLength, minLength } from './validators';
 export type { DeviceInfoLike, ParsedVersion, Platform, UpdateInfo, UpdateType, VersionCheckResult, VersionCheckType, VersionComparison, VersionData } from './versionCheck';

package/lib/typescript/commonjs/initSDK.d.ts

@@ -2,7 +2,10 @@
  * Simple initialization API for Webority packages
  * One function to configure everything needed
  */
+import { type KeychainLike } from './auth/authStore';
 import { type Environment, type LogLevel } from './config';
+import { type NetInfoLike } from './network/networkStatus';
+import { setStorageImplementation } from './storage';
 export interface InitConfig {
     /** Your API base URL (required) */
     baseUrl: string;
@@ -17,6 +20,35 @@ export interface InitConfig {
      * version checks. Defaults to `'in'`.
      */
     country?: string;
+    /**
+     * The app's store identifier (Android package name / iOS bundle id) and its
+     * user-visible version, both needed by the version-check module. Every
+     * Webority app already has them in `appsettings.Compiled.json`, which is why
+     * they come from config rather than across the native bridge.
+     */
+    appId?: string;
+    appVersion?: string;
+    /**
+     * Log a redacted curl line per request. Off by default; it is a debugging
+     * aid, not something to leave on.
+     */
+    logCurl?: boolean;
+    /**
+     * The native modules that fill the seams the library does not import.
+     *
+     * Passing them here is strongly preferred over calling each setter, because
+     * forgetting one is silent: storage returns falsy and network status reports
+     * optimistic online, so an app looks like it works and simply never persists
+     * anything. The pilot migration wired NONE of them and nothing said so.
+     *
+     * Every value is whatever that surface's package exports, or an Expo adapter
+     * from its own import path. See docs/expo.md.
+     */
+    backends?: {
+        storage?: Parameters<typeof setStorageImplementation>[0];
+        keychain?: KeychainLike | null;
+        network?: NetInfoLike | null;
+    };
 }
 /**
  * Initialize Webority packages with your project configuration.

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

@@ -24,6 +24,39 @@ export interface RemoteLogger {
  * Pass `null` to detach. Safe to call before or after `initWebority`.
  */
 export declare const setRemoteLogger: (impl: RemoteLogger | null) => void;
+/**
+ * Device / app context attached once at boot (platform, OS version, app version,
+ * build number, device model, etc). Merged into every `recordError` context so
+ * every crash carries it without every call site repeating it.
+ */
+export interface DeviceContext {
+    platform: string;
+    osVersion?: string;
+    appVersion?: string;
+    buildNumber?: string;
+    deviceModel?: string;
+    isEmulator?: boolean;
+    locale?: string;
+    [key: string]: unknown;
+}
+/**
+ * Set (or clear, with `null`) the device/app context merged into every
+ * `recordError` call. Each key is also forwarded to `remote.setAttribute`
+ * once, at the moment it is set.
+ */
+export declare const setDeviceContext: (context: DeviceContext | null) => void;
+export declare const getDeviceContext: () => DeviceContext | null;
+/** Tuning knobs for screen history and duplicate-error suppression. */
+export interface LoggerOptions {
+    /** Identical errors within this window are collapsed. Default 5000ms. 0 disables dedupe. */
+    dedupeWindowMs?: number;
+    /** Max identical errors forwarded per window before suppression. Default 1. */
+    dedupeMaxPerWindow?: number;
+    /** Cap on tracked screen history. Default 20. */
+    screenHistoryLimit?: number;
+}
+/** Configure dedupe window/threshold and screen history size. Merges with current options. */
+export declare const configureLogger: (options: LoggerOptions) => void;
 export interface LoggerType {
     info: LogFn;
     warn: LogFn;
@@ -36,6 +69,12 @@ export interface LoggerType {
     setUser: (id: string | null, attrs?: Record<string, unknown>) => void;
     /** Attach a custom attribute (release, build, env, role, etc.). */
     setAttribute: (key: string, value: string | number | boolean | null) => void;
+    /** Record the active screen; attaches `screen` to subsequent `recordError` context. */
+    trackScreen: (name: string, params?: Record<string, unknown>) => void;
+    /** The most recently tracked screen name, or `null` if none was tracked yet. */
+    getCurrentScreen: () => string | null;
+    /** Bounded history of tracked screen names, oldest first. */
+    getScreenHistory: () => string[];
 }
 export declare const Logger: LoggerType;
 export {};

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

@@ -1,3 +1,3 @@
-export type { NetworkConnectionType, NetworkStatus, NetworkStatusListener } from './networkStatus';
-export { addNetworkStatusListener, getNetworkStatus, useNetworkStatus } from './networkStatus';
+export type { NetworkConnectionType, NetworkStatus, NetworkStatusLike, NetworkStatusListener } from './networkStatus';
+export { addNetworkStatusListener, getNetworkStatus, setNetworkStatusImplementation, useNetworkStatus } from './networkStatus';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/network/networkStatus.d.ts

@@ -10,6 +10,21 @@ export interface NetworkStatus {
     type: NetworkConnectionType;
 }
 export type NetworkStatusListener = (status: NetworkStatus) => void;
+interface NetInfoStateLike {
+    isConnected: boolean | null;
+    isInternetReachable: boolean | null;
+    type?: string;
+}
+export interface NetInfoLike {
+    fetch: () => Promise<NetInfoStateLike>;
+    addEventListener: (cb: (state: NetInfoStateLike) => void) => () => void;
+}
+/**
+ * Replace the backend. Intended for TESTS and for the showcase, which uses it
+ * to reach error paths that a healthy device never takes; it is not the way an
+ * app is meant to configure the library. Pass `null` to restore expo-network.
+ */
+export declare const setNetworkStatusImplementation: (impl: NetInfoLike | null) => void;
 /**
  * Imperative one-shot fetch of current network status. Resolves to the default
  * online status when NetInfo is unavailable so callers never crash.
@@ -24,4 +39,5 @@ export declare const addNetworkStatusListener: (listener: NetworkStatusListener)
  * Reports an optimistic online default when NetInfo is not installed.
  */
 export declare const useNetworkStatus: () => NetworkStatus;
+export type { NetInfoLike as NetworkStatusLike };
 //# sourceMappingURL=networkStatus.d.ts.map

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

@@ -1,5 +1,39 @@
 export type PermissionKind = 'camera' | 'microphone' | 'photos' | 'photosAdd' | 'mediaLibrary' | 'location' | 'locationAlways' | 'contacts' | 'calendar' | 'reminders' | 'notifications' | 'bluetooth' | 'storage';
 export type PermissionStatus = 'unavailable' | 'denied' | 'limited' | 'granted' | 'blocked';
+export interface RNPermissionsModule {
+    PERMISSIONS: {
+        IOS: Record<string, string>;
+        ANDROID: Record<string, string>;
+    };
+    RESULTS: {
+        UNAVAILABLE: string;
+        DENIED: string;
+        LIMITED: string;
+        GRANTED: string;
+        BLOCKED: string;
+    };
+    check: (permission: string) => Promise<string>;
+    request: (permission: string) => Promise<string>;
+    openSettings: () => Promise<void>;
+}
+/**
+ * Inject a custom permissions implementation at runtime.
+ * Pass `null` to reset to the default lazily-resolved native module.
+ *
+ * `resolved` goes FALSE on null, never true. Marking it resolved with a null
+ * backend would permanently disable permissions: the resolver short-circuits and the
+ * real module is never loaded again, which contradicts this function's own
+ * documented contract. That exact bug shipped once, in the storage seam.
+ *
+ * THIS MODULE IS THE EXPO-FIRST EXCEPTION, and deliberately keeps the old
+ * shape. Expo ships no permissions package: each module carries its own
+ * (expo-location's requestForegroundPermissionsAsync, expo-image-picker's, and
+ * so on), so there is no single object to adapt and the library must not guess
+ * which Expo modules an app installed. react-native-permissions stays, behind
+ * this module's own import path so an app that never asks for permissions
+ * never names the package to Metro.
+ */
+export declare const setPermissionsImplementation: (impl: RNPermissionsModule | null) => void;
 /**
  * Cross-platform permissions wrapper. Maps an abstract `PermissionKind`
  * (camera, photos, location, notifications, …) to the right
@@ -17,4 +51,5 @@ export declare const Permissions: {
     ensure: (kind: PermissionKind) => Promise<PermissionStatus>;
     openSettings: () => Promise<boolean>;
 };
+export type { RNPermissionsModule as PermissionsLike };
 //# sourceMappingURL=index.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/adapters/op.d.ts

@@ -0,0 +1,27 @@
+import type { SqliteDriver } from '../index';
+/**
+ * @op-engineering/op-sqlite. Shape verified against 18.1.4 rather than assumed:
+ * `open({ name, location })` is synchronous and returns a DB whose `execute` is
+ * ASYNC, and whose `rows` is already a plain array of objects rather than the
+ * `{ _array, item() }` shape the older drivers use. Both differences are why it
+ * cannot share the sync adapter.
+ *
+ * The REQUIRE lives in the driver entry point beside this file, never here.
+ */
+export interface OpSqliteQueryResult {
+    rows?: Record<string, unknown>[];
+    rowsAffected?: number;
+    insertId?: number;
+}
+export interface OpSqliteModuleLike {
+    open: (options: {
+        name: string;
+        location?: string;
+    }) => {
+        execute: (sql: string, params?: unknown[]) => Promise<OpSqliteQueryResult>;
+        close: () => void;
+        closeAsync?: () => Promise<void>;
+    };
+}
+export declare const adaptOpSqlite: (mod: OpSqliteModuleLike) => SqliteDriver;
+//# sourceMappingURL=op.d.ts.map

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

@@ -0,0 +1,7 @@
+/**
+ * Row shapes differ per driver: a plain array, `{ _array, length, item() }`, or
+ * `{ length, item() }` alone. Every adapter normalises to a plain array here so
+ * nothing driver-specific escapes into the Db layer.
+ */
+export declare const rowsToArray: (rows: unknown) => Record<string, unknown>[];
+//# sourceMappingURL=rows.d.ts.map

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

@@ -0,0 +1,30 @@
+import type { SqliteDriver } from '../index';
+interface SqliteStorageResultSet {
+    rows: {
+        length: number;
+        item: (i: number) => Record<string, unknown>;
+    };
+    rowsAffected: number;
+    insertId?: number;
+}
+/** react-native-sqlite-storage: callback-based by default, promise-based once
+ * `enablePromise(true)` is called; `executeSql` resolves an array whose first
+ * element is the result set. */
+interface SqliteStorageModuleLike {
+    enablePromise: (enabled: boolean) => void;
+    openDatabase: (options: {
+        name: string;
+        location?: string;
+    }) => Promise<{
+        executeSql: (sql: string, params?: unknown[]) => Promise<[SqliteStorageResultSet]>;
+        close: () => Promise<void>;
+    }>;
+}
+/**
+ * Adapt an already-required `react-native-sqlite-storage` module. Exported for
+ * the same reason as the filesystem adapters: the library cannot name a package
+ * the app did not install without breaking the app's bundle.
+ */
+export declare const adaptSqliteStorage: (mod: SqliteStorageModuleLike) => SqliteDriver;
+export {};
+//# sourceMappingURL=storage.d.ts.map

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

@@ -0,0 +1,31 @@
+import type { SqliteDriver } from '../index';
+/**
+ * nitro-sqlite and quick-sqlite share one synchronous shape, so one adapter
+ * serves both. The REQUIRE lives in the driver entry points beside this file,
+ * never here and never in the core: Metro resolves requires statically, so a
+ * package named anywhere reachable becomes mandatory for every consumer.
+ */
+interface SyncQueryResult {
+    rows?: unknown;
+    rowsAffected?: number;
+    insertId?: number;
+}
+/** Shape shared by react-native-nitro-sqlite and react-native-quick-sqlite: a
+ * synchronous `open({ name, location })` whose `db.execute()` and `db.close()`
+ * are also synchronous. Both are wrapped in Promise.resolve to fit SqliteDriver. */
+interface SyncSqliteModuleLike {
+    open: (options: {
+        name: string;
+        location?: string;
+    }) => {
+        execute: (sql: string, params?: unknown[]) => SyncQueryResult;
+        close: () => void;
+    };
+}
+/**
+ * Adapt an already-required nitro-sqlite or quick-sqlite module. Both expose the
+ * same synchronous shape. Exported so an app on quick-sqlite can inject it.
+ */
+export declare const adaptSyncSqlite: (mod: SyncSqliteModuleLike) => SqliteDriver;
+export {};
+//# sourceMappingURL=sync.d.ts.map

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

@@ -0,0 +1,121 @@
+/**
+ * This module names NO native package. Metro resolves requires statically, so a
+ * driver named here would be bundled by every consumer and would have to be
+ * installed by every app, whichever driver it actually chose. Each driver lives
+ * behind its own import path, and the app wires one at startup:
+ *
+ *   import { setSqliteImplementation } from '@webority-technologies/mobile-core/sqlite';
+ *   import { opSqliteDriver } from '@webority-technologies/mobile-core/sqlite/op';
+ *   setSqliteImplementation(opSqliteDriver());
+ *
+ * Supported entry points: /sqlite/op, /sqlite/nitro, /sqlite/quick,
+ * /sqlite/storage. Any object matching SqliteDriver also works.
+ */
+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>;
+}
+/**
+ * Inject the SQLite driver. Pass `null` to clear it.
+ *
+ * `@webority-technologies/mobile-core` ships no database: it is pure JavaScript
+ * and defines only this interface. Wire a driver once at startup:
+ *
+ *   import { opSqliteDriver } from '@webority-technologies/mobile-core/sqlite/op';
+ *   setSqliteImplementation(opSqliteDriver());
+ */
+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/sqlite/nitro.d.ts

@@ -0,0 +1,7 @@
+import type { SqliteDriver } from './index';
+/**
+ * The one place `react-native-nitro-sqlite` is named. Import this module only if
+ * you installed it; nothing else in the library reaches it.
+ */
+export declare const nitroSqliteDriver: () => SqliteDriver;
+//# sourceMappingURL=nitro.d.ts.map

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

@@ -0,0 +1,8 @@
+import type { SqliteDriver } from './index';
+/**
+ * The one place `@op-engineering/op-sqlite` is named. It is the driver we
+ * recommend: the most actively maintained of the four, and the only one already
+ * proven in one of our apps. Import this module only if you installed it.
+ */
+export declare const opSqliteDriver: () => SqliteDriver;
+//# sourceMappingURL=op.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { SqliteDriver } from './index';
+/** The one place `react-native-quick-sqlite` is named. */
+export declare const quickSqliteDriver: () => SqliteDriver;
+//# sourceMappingURL=quick.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { SqliteDriver } from './index';
+/** The one place `react-native-sqlite-storage` is named. */
+export declare const sqliteStorageDriver: () => SqliteDriver;
+//# sourceMappingURL=storage.d.ts.map