@voltro/react-native 0.81.0 → 0.82.0

package/THIRD-PARTY-NOTICES.md

@@ -5,7 +5,7 @@ property of its respective copyright holders and is used under the terms of
 its license. This file is provided for attribution; it grants no rights in
 @voltro/react-native itself, which is proprietary (see LICENSE).
 
-Generated from the resolved runtime dependency closure (13 packages).
+Generated from the resolved runtime dependency closure (17 packages).
 
 ---
 
@@ -205,6 +205,34 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
+## isomorphic.js@0.2.5
+
+License: MIT
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2020 Kevin Jahns <kevin.jahns@protonmail.com>.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
 ## jose@6.2.12
 
 License: MIT
@@ -261,6 +289,34 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
+## lib0@0.2.117
+
+License: MIT
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2019 Kevin Jahns <kevin.jahns@protonmail.com>.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
 ## typeid-js@1.2.0
 
 License: Apache-2.0
@@ -541,3 +597,61 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ```
 
+## y-protocols@1.0.7
+
+License: MIT
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2019 Kevin Jahns <kevin.jahns@protonmail.com>.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## yjs@13.6.32
+
+License: MIT
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2023
+  - Kevin Jahns <kevin.jahns@protonmail.com>.
+  - Chair of Computer Science 5 (Databases & Information Systems), RWTH Aachen University, Germany
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+

package/dist/index.d.ts

@@ -1,10 +1,42 @@
 import { ApiHandle } from '@voltro/client';
+import { BiometricSource } from '@voltro/client';
+import { browserOnlineSource } from '@voltro/client';
 import { ClientDescriptorMap } from '@voltro/client';
+import { DeepLinkDescriptor } from '@voltro/client';
+import { DeepLinkHandler } from '@voltro/client';
+import { deepLinkHref } from '@voltro/client';
+import { DeepLinkParams } from '@voltro/client';
+import { DeepLinkSource } from '@voltro/client';
+import { defineDeepLink } from '@voltro/client';
+import { DefineDeepLinkConfig } from '@voltro/client';
+import { dispatchDeepLink } from '@voltro/client';
+import { KvStore } from '@voltro/local-first';
+import { LifecycleSource } from '@voltro/client';
+import { matchDeepLink } from '@voltro/client';
+import { matchFirstDeepLink } from '@voltro/client';
 import { MountedApi } from '@voltro/client';
+import { NotificationSurface } from '@voltro/client';
+import { OnlineSource } from '@voltro/client';
+import { PersistenceAdapter } from '@voltro/local-first';
+import { PlatformAdapter } from '@voltro/client';
+import { PlatformCapabilities } from '@voltro/client';
 import { ResolvableHeaders } from '@voltro/client';
 import { ResolvedClient } from '@voltro/client';
+import { runDeepLink } from '@voltro/client';
 import { StoreStorageProvider } from '@voltro/client';
 import { SupervisorHandle } from '@voltro/client';
+import { TokenStore } from '@voltro/client';
+import { UpdateChannel } from '@voltro/client';
+
+export declare const appStateLifecycle: (appState: AppStateLike) => LifecycleSource;
+
+/** `react-native`'s `AppState`, structurally. */
+export declare interface AppStateLike {
+    readonly currentState: string;
+    readonly addEventListener: (type: 'change', handler: (state: string) => void) => {
+        readonly remove: () => void;
+    };
+}
 
 /**
  * The async storage this adapter writes through to — `AsyncStorage` from
@@ -64,6 +96,8 @@ export declare interface AsyncStoragePersistenceOptions {
     readonly onError?: (key: string, error: unknown) => void;
 }
 
+export declare type BackgroundFetchOutcome = 'new-data' | 'no-data' | 'failed';
+
 export declare type BackgroundSyncAction = {
     readonly type: 'foreground';
 } | {
@@ -82,6 +116,8 @@ export declare type BackgroundSyncAction = {
     readonly type: 'reset';
 };
 
+export declare type BackgroundSyncAvailability = 'available' | 'denied' | 'restricted' | 'unknown';
+
 export declare const backgroundSyncReducer: (state: BackgroundSyncState, action: BackgroundSyncAction) => BackgroundSyncState;
 
 export declare interface BackgroundSyncState {
@@ -102,9 +138,35 @@ export declare interface BackgroundSyncState {
 
 export declare type BackgroundSyncStatus = 'idle' | 'syncing' | 'success' | 'error';
 
-/** The browser's `navigator.onLine` + its events. The default, and the reason
- *  the same screen still behaves under jsdom or in a web preview. */
-export declare const browserOnlineSource: OnlineSource;
+export declare interface BackgroundSyncTask {
+    readonly name: string;
+    /** Define the task with the OS and register it. Idempotent. */
+    readonly register: () => Promise<void>;
+    readonly unregister: () => Promise<void>;
+    /** Whether the OS lets this app fetch in the background at all. */
+    readonly availability: () => Promise<BackgroundSyncAvailability>;
+    /** Run the task body now (the same code the OS runs) — for a manual trigger or a test. */
+    readonly runNow: () => Promise<BackgroundFetchOutcome>;
+}
+
+export declare interface BackgroundSyncTaskOptions {
+    /** The task's name — stable across builds; the OS keys registrations by it. */
+    readonly name?: string;
+    readonly taskManager: ExpoTaskManagerLike;
+    readonly backgroundFetch: ExpoBackgroundFetchLike;
+    /** The sync itself: `'new-data'` when something was pulled or pushed. Throw = `'failed'`. */
+    readonly run: () => Promise<BackgroundFetchOutcome | void>;
+    /** Android's hint; iOS ignores it. Default 15 minutes (the platform floor). */
+    readonly minimumIntervalSeconds?: number;
+    /** Keep the task after the user swipes the app away (Android). Default true. */
+    readonly survivesTermination?: boolean;
+    /** Register again after a reboot (Android). Default true. */
+    readonly startOnBoot?: boolean;
+    /** Observe each background run's outcome (the sync banner's `reportFailure`). */
+    readonly onOutcome?: (outcome: BackgroundFetchOutcome, error?: unknown) => void;
+}
+
+export { browserOnlineSource }
 
 /**
  * Build a React-Native persistence adapter over an async key-value storage.
@@ -122,68 +184,58 @@ export declare const browserOnlineSource: OnlineSource;
 export declare const createAsyncStoragePersistence: (options: AsyncStoragePersistenceOptions) => AsyncStoragePersistence;
 
 /**
- * The descriptor a `*.deepLink.ts` file default-exports. `_tag` marks it for
- * the (future) discovery walk without relying on structural guessing.
+ * Build the Expo adapter. Hydrates the persisted stores first — await it, then
+ * `installPlatform(result.adapter)`, then render.
  */
-export declare interface DeepLinkDescriptor<Pattern extends string = string> {
-    readonly _tag: 'VoltroDeepLink';
-    readonly pattern: Pattern;
-    readonly handler: DeepLinkHandler<Pattern>;
+export declare const createExpoPlatform: (options: CreateExpoPlatformOptions) => Promise<ExpoPlatform>;
+
+export declare interface CreateExpoPlatformOptions {
+    /** `Platform.OS` — `'ios'` | `'android'` | `'web'`. */
+    readonly os: string;
+    readonly netInfo: NetInfoLike;
+    readonly appState: AppStateLike;
+    readonly linking: LinkingLike;
+    readonly secureStore: SecureStoreLike;
+    /** AsyncStorage (or any async key-value store) for persisted stores. */
+    readonly storage: AsyncKeyValueStorage;
+    /** Which persisted keys to hydrate — see `createAsyncStoragePersistence`. */
+    readonly persistedKeys?: ReadonlyArray<string>;
+    readonly notifications?: NotificationsLike;
+    /** Expo project id for `getExpoPushTokenAsync`. */
+    readonly expoProjectId?: string;
+    readonly updates?: UpdatesLike;
+    readonly localAuthentication?: LocalAuthenticationLike;
+    /** The app's version (`Constants.expoConfig?.version`). */
+    readonly appVersion?: string;
+    readonly webSocket?: PlatformAdapter['webSocket'];
+    readonly capabilities?: Partial<PlatformCapabilities>;
+    readonly extensions?: Readonly<Record<string, unknown>>;
 }
 
-/** A handler for a matched deep link. May be async (navigation can await). */
-export declare type DeepLinkHandler<Pattern extends string> = (params: DeepLinkParams<Pattern>) => void | Promise<void>;
+export declare const createExpoSqliteLocalFirst: (db: SqliteDatabaseLike) => Promise<ExpoSqliteLocalFirst>;
 
-/**
- * Substitute captured params back into a pattern, producing a concrete path.
- *
- * `deepLinkHref('/orders/:id', { id: '42' })` → `'/orders/42'`. This is the
- * inverse of {@link matchDeepLink} and it exists because a DERIVED deep link
- * (one the generator built from an Expo Router screen) navigates to the very
- * path it matched — the screen's own route.
- *
- * It lives here rather than being emitted into the generated module on purpose:
- * generated code that carries logic is logic nothing tests. A missing param
- * would silently produce `/orders/` (a different, probably-existing route), so
- * it throws instead.
- */
-export declare const deepLinkHref: (pattern: string, params: Readonly<Record<string, string>>) => string;
+export { DeepLinkDescriptor }
 
-/**
- * The params a pattern yields, inferred from its `:name` segments.
- *
- * `'/orders/:id'` → `{ id: string }`, `'/t/:tenant/u/:user'` →
- * `{ tenant: string; user: string }`, a param-less pattern →
- * `Record<string, never>`. This is what makes `handler: ({ id }) => …`
- * type-check against exactly the params the pattern declares.
- */
-export declare type DeepLinkParams<Pattern extends string> = Pattern extends `${string}:${infer Param}/${infer Rest}` ? {
-    readonly [K in Param | keyof DeepLinkParams<`/${Rest}`>]: string;
-} : Pattern extends `${string}:${infer Param}` ? {
-    readonly [K in Param]: string;
-} : Record<string, never>;
+export { DeepLinkHandler }
+
+export { deepLinkHref }
+
+export { DeepLinkParams }
+
+export declare const DEFAULT_BACKGROUND_SYNC_TASK = "voltro-background-sync";
 
 /** The default constructor: React Native's global `WebSocket`. Exported so the
  *  refusal below is testable — an untestable error message is one nobody has
  *  ever read. */
 export declare const defaultWebSocketConstructor: (url: string, protocols?: string | ReadonlyArray<string>) => WebSocket;
 
-/**
- * Declare a deep link.
- *
- * ```ts
- * export default defineDeepLink({
- *   pattern: '/orders/:id',
- *   handler: ({ id }) => navigateTo(`/orders/${id}`),
- * })
- * ```
- */
-export declare const defineDeepLink: <const Pattern extends string>(config: DefineDeepLinkConfig<Pattern>) => DeepLinkDescriptor<Pattern>;
+/** `expo-task-manager` requires `defineTask` at module scope, once; this
+ *  keeps the task body reachable from there while `register` stays lazy. */
+export declare const defineBackgroundSyncTask: (options: BackgroundSyncTaskOptions) => BackgroundSyncTask;
 
-export declare interface DefineDeepLinkConfig<Pattern extends string> {
-    readonly pattern: Pattern;
-    readonly handler: DeepLinkHandler<Pattern>;
-}
+export { defineDeepLink }
+
+export { DefineDeepLinkConfig }
 
 /**
  * The status mapping, pure and standalone (mirrors `@voltro/client`'s):
@@ -254,23 +306,61 @@ export declare const DEVICES_TABLE = "_voltro_devices";
  */
 export declare type DeviceUpsert<Result = unknown> = (registration: DeviceRegistration) => Promise<Result>;
 
-/**
- * Match `path` against the table and RUN the winning handler. Returns the
- * captured params, or `null` when nothing matched.
- *
- * This exists because `matchFirstDeepLink` alone is not usable for the thing it
- * is for. Its descriptors come from a HETEROGENEOUS array, so `Pattern` erases
- * to `string`, and `DeepLinkParams<string>` is `Record<string, never>` — the
- * handler it hands back rejects the params it hands back with it. Every caller
- * had to cast, and the template's did not, which nothing noticed because no
- * harness typechecked the template.
- *
- * The erasure happens ONCE, here, where it is defensible: at runtime a matched
- * pattern's params ARE `Record<string, string>`, and the per-pattern type is a
- * derivation of a literal the caller no longer has. `runDeepLink` keeps the
- * fully-typed single-descriptor path for a caller that does.
- */
-export declare const dispatchDeepLink: (descriptors: ReadonlyArray<DeepLinkDescriptor>, path: string) => Record<string, string> | null;
+export { dispatchDeepLink }
+
+/** `expo-background-fetch`, as much of it as this binding touches. The
+ *  `BackgroundFetchResult` values are passed in because the enum lives in
+ *  the module and this file imports nothing from it. */
+export declare interface ExpoBackgroundFetchLike {
+    readonly registerTaskAsync: (name: string, options?: {
+        readonly minimumInterval?: number;
+        readonly stopOnTerminate?: boolean;
+        readonly startOnBoot?: boolean;
+    }) => Promise<void>;
+    readonly unregisterTaskAsync: (name: string) => Promise<void>;
+    readonly getStatusAsync?: () => Promise<number | null>;
+    readonly BackgroundFetchResult: {
+        readonly NewData: unknown;
+        readonly NoData: unknown;
+        readonly Failed: unknown;
+    };
+    readonly BackgroundFetchStatus?: {
+        readonly Available: number;
+        readonly Denied: number;
+        readonly Restricted: number;
+    };
+}
+
+export declare const expoBiometrics: (auth: LocalAuthenticationLike) => BiometricSource;
+
+export declare const expoNotifications: (notifications: NotificationsLike, expoProjectId?: string) => NotificationSurface;
+
+export declare interface ExpoPlatform {
+    readonly adapter: PlatformAdapter;
+    /** The hydrated persistence — `flush()` before backgrounding if needed. */
+    readonly persistence: AsyncStoragePersistence;
+}
+
+export declare const expoSecureTokenStore: (secureStore: SecureStoreLike) => TokenStore;
+
+export declare interface ExpoSqliteLocalFirst {
+    readonly persistence: PersistenceAdapter;
+    readonly kv: KvStore;
+    /** Create the tables. Called by `createExpoSqliteLocalFirst`; exposed for a
+     *  caller that opens the database itself. */
+    readonly migrate: () => Promise<void>;
+}
+
+/** `expo-task-manager`, as much of it as this binding touches. */
+export declare interface ExpoTaskManagerLike {
+    readonly defineTask: (name: string, task: (body: {
+        readonly data?: unknown;
+        readonly error?: unknown;
+    }) => Promise<unknown>) => void;
+    readonly isTaskRegisteredAsync?: (name: string) => Promise<boolean>;
+}
+
+export declare const expoUpdates: (updates: UpdatesLike) => UpdateChannel;
 
 /**
  * Subscribe to "app returned to the foreground". Returns an unsubscribe.
@@ -287,32 +377,32 @@ export declare const initialBackgroundSyncState: BackgroundSyncState;
 /** Narrow an untrusted string to a {@link DevicePlatform}. */
 export declare const isDevicePlatform: (value: unknown) => value is DevicePlatform;
 
-/**
- * Match a `pattern` against a `path`, returning the captured params or `null`
- * when it does not match. Pure — no navigation, no side effects.
- *
- * ```ts
- * matchDeepLink('/orders/:id', '/orders/42')      // → { id: '42' }
- * matchDeepLink('/orders/:id', '/orders/42/edit') // → null
- * matchDeepLink('/health', '/health')             // → {}
- * ```
- *
- * A `*` segment matches exactly one segment without capturing; a trailing `*`
- * is not a catch-all (keep the model boringly predictable — one pattern
- * segment matches one path segment).
- */
-export declare const matchDeepLink: <Pattern extends string>(pattern: Pattern, path: string) => DeepLinkParams<Pattern> | null;
+export declare const linkingDeepLinks: (linking: LinkingLike) => DeepLinkSource;
 
-/**
- * First descriptor whose pattern matches `path`, with its captured params.
- * Declaration order wins, so list more-specific patterns first — which is why
- * the generated table puts hand-written `*.deepLink.ts` descriptors ahead of
- * the router-derived ones.
- */
-export declare const matchFirstDeepLink: (descriptors: ReadonlyArray<DeepLinkDescriptor>, path: string) => {
-    readonly descriptor: DeepLinkDescriptor;
-    readonly params: Record<string, string>;
-} | null;
+/** `expo-linking` / `react-native`'s `Linking`, structurally. */
+export declare interface LinkingLike {
+    readonly getInitialURL: () => Promise<string | null>;
+    readonly addEventListener: (type: 'url', handler: (event: {
+        readonly url: string;
+    }) => void) => {
+        readonly remove: () => void;
+    };
+}
+
+/** `expo-local-authentication`, the subset used. */
+export declare interface LocalAuthenticationLike {
+    readonly hasHardwareAsync: () => Promise<boolean>;
+    readonly isEnrolledAsync: () => Promise<boolean>;
+    readonly authenticateAsync: (options?: {
+        readonly promptMessage?: string;
+    }) => Promise<{
+        readonly success: boolean;
+    }>;
+}
+
+export { matchDeepLink }
+
+export { matchFirstDeepLink }
 
 /** One api this app talks to. `group` and `descriptors` come from the api's
  *  generated rpc surface — on mobile, from the file `voltro codegen` writes
@@ -377,6 +467,29 @@ export declare interface NetInfoState {
     readonly isInternetReachable?: boolean | null;
 }
 
+/** `expo-notifications`, the subset used. */
+export declare interface NotificationsLike {
+    readonly getPermissionsAsync: () => Promise<{
+        readonly status: string;
+    }>;
+    readonly requestPermissionsAsync: () => Promise<{
+        readonly status: string;
+    }>;
+    readonly getExpoPushTokenAsync?: (options?: {
+        readonly projectId?: string;
+    }) => Promise<{
+        readonly data: string;
+    }>;
+    readonly scheduleNotificationAsync?: (request: {
+        readonly content: {
+            readonly title: string;
+            readonly body?: string;
+            readonly data?: Record<string, unknown>;
+        };
+        readonly trigger: null;
+    }) => Promise<string>;
+}
+
 /**
  * The mobile client posture. Spread into the client config on RN:
  *
@@ -401,18 +514,7 @@ export declare interface OfflineFirstDefaults {
 
 export declare const offlineFirstDefaults: OfflineFirstDefaults;
 
-/**
- * A source of reachability. `subscribe` reports every change and returns an
- * unsubscribe; `read` gives the value to start from.
- *
- * Injected rather than detected, because detection is exactly what went wrong:
- * a `typeof navigator === 'undefined' ? true : …` fallback answers "online" on
- * every platform that does not implement the API it is testing for.
- */
-export declare interface OnlineSource {
-    readonly read: () => boolean;
-    readonly subscribe: (onChange: (online: boolean) => void) => () => void;
-}
+export { OnlineSource }
 
 /**
  * Register (or re-register, on token rotation) the current device.
@@ -456,11 +558,14 @@ export declare const resolveDeviceRegistration: (input: DeviceRegistrationInput,
  */
 export declare const resolveDevWsUrl: (hostUri: string | undefined, port: number, path?: string) => string;
 
-/**
- * Match `path` against a descriptor and, on a hit, invoke its handler with the
- * captured params. Returns the params (so callers know it matched) or `null`.
- */
-export declare const runDeepLink: <Pattern extends string>(descriptor: DeepLinkDescriptor<Pattern>, path: string) => DeepLinkParams<Pattern> | null;
+export { runDeepLink }
+
+/** `expo-secure-store`, structurally. */
+export declare interface SecureStoreLike {
+    readonly getItemAsync: (key: string) => Promise<string | null>;
+    readonly setItemAsync: (key: string, value: string) => Promise<void>;
+    readonly deleteItemAsync: (key: string) => Promise<void>;
+}
 
 /**
  * Should a trigger run a sync right now? Pure — the single place the timing
@@ -484,6 +589,14 @@ export declare interface ShouldSyncOptions {
     readonly enabled: boolean;
 }
 
+/** The subset of `expo-sqlite`'s `SQLiteDatabase` this adapter uses. */
+export declare interface SqliteDatabaseLike {
+    readonly execAsync: (sql: string) => Promise<void>;
+    readonly runAsync: (sql: string, params?: ReadonlyArray<string | number | Uint8Array | null>) => Promise<unknown>;
+    readonly getFirstAsync: <T = Record<string, unknown>>(sql: string, params?: ReadonlyArray<string | number | Uint8Array | null>) => Promise<T | null>;
+    readonly getAllAsync: <T = Record<string, unknown>>(sql: string, params?: ReadonlyArray<string | number | Uint8Array | null>) => Promise<ReadonlyArray<T>>;
+}
+
 /**
  * Connect every api and keep them connected.
  *
@@ -530,6 +643,20 @@ export declare interface StartMobileApisOptions {
  */
 export declare const toApiHandles: (apis: ReadonlyArray<MobileApiBinding>, clients: ReadonlyMap<string, ResolvedClient>) => ReadonlyMap<string, ApiHandle>;
 
+/** `expo-updates`, the subset used. */
+export declare interface UpdatesLike {
+    readonly checkForUpdateAsync: () => Promise<{
+        readonly isAvailable: boolean;
+        readonly manifest?: {
+            readonly id?: string;
+        };
+    }>;
+    readonly fetchUpdateAsync: () => Promise<unknown>;
+    readonly reloadAsync: () => Promise<void>;
+    readonly updateId?: string | null;
+    readonly runtimeVersion?: string | null;
+}
+
 /**
  * Register a periodic + foreground-triggered sync callback.
  *