@webority-technologies/mobile-core 0.0.1 → 0.0.2

package/lib/typescript/module/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.js';
 import { type Environment, type LogLevel } from './config/index.js';
+import { type NetInfoLike } from './network/networkStatus.js';
+import { setStorageImplementation } from './storage/index.js';
 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/module/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/module/network/index.d.ts

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

package/lib/typescript/module/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/module/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/module/sqlite/adapters/expo.d.ts

@@ -0,0 +1,30 @@
+import type { SqliteDriver } from '../index.js';
+/**
+ * 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/module/sqlite/adapters/op.d.ts

@@ -0,0 +1,27 @@
+import type { SqliteDriver } from '../index.js';
+/**
+ * @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/module/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/module/sqlite/adapters/storage.d.ts

@@ -0,0 +1,30 @@
+import type { SqliteDriver } from '../index.js';
+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/module/sqlite/adapters/sync.d.ts

@@ -0,0 +1,31 @@
+import type { SqliteDriver } from '../index.js';
+/**
+ * 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/module/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/module/sqlite/nitro.d.ts

@@ -0,0 +1,7 @@
+import type { SqliteDriver } from './index.js';
+/**
+ * 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/module/sqlite/op.d.ts

@@ -0,0 +1,8 @@
+import type { SqliteDriver } from './index.js';
+/**
+ * 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/module/sqlite/quick.d.ts

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

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

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

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

@@ -6,6 +6,22 @@ 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>;
@@ -13,8 +29,14 @@ interface AsyncStorageLike {
     getAllKeys?: () => Promise<readonly string[]>;
 }
 /**
- * Inject a custom storage backend (e.g. MMKV adapter) at runtime.
- * Pass `null` to reset to the default AsyncStorage backend.
+ * 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 {

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

@@ -16,6 +16,22 @@ export interface CompressImageOptions {
      */
     fileSize?: number;
 }
+export interface CompressorModule {
+    Image: {
+        compress: (uri: string, options: {
+            maxWidth?: number;
+            maxHeight?: number;
+            quality?: number;
+            compressionMethod?: 'auto' | 'manual';
+            output?: 'jpg' | 'png' | 'webp';
+        }) => Promise<string>;
+    };
+}
+/**
+ * Replace the compressor. Intended for TESTS and for the showcase; an app gets
+ * expo-image-manipulator without wiring anything. Pass `null` to restore it.
+ */
+export declare const setImageCompressorImplementation: (impl: CompressorModule | 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
@@ -28,4 +44,5 @@ export declare const qualityForFileSize: (fileSize?: number) => number;
  * dependency is missing — so callers can rely on always getting a usable URI.
  */
 export declare const compressImage: (uri: string, options?: CompressImageOptions) => Promise<string>;
+export type { CompressorModule as ImageCompressorLike };
 //# sourceMappingURL=imageCompression.d.ts.map

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

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