@webority-technologies/mobile-core 0.0.1 → 0.0.3

package/lib/typescript/commonjs/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 {
@@ -34,7 +56,7 @@ export interface StorageApi {
  * All operations swallow errors (logging them) and return a falsy result
  * so that storage problems never crash the app.
  *
- * Backed by `@react-native-async-storage/async-storage` by default;
+ * Backed by `expo-sqlite/kv-store` by default;
  * override with `setStorageImplementation()` for MMKV or custom adapters.
  */
 export declare const Storage: StorageApi;

package/lib/typescript/commonjs/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/commonjs/utils/index.d.ts

@@ -1,3 +1,3 @@
-export type { CompressImageOptions } from './imageCompression';
-export { compressImage } from './imageCompression';
+export type { CompressImageOptions, ImageCompressorLike } from './imageCompression';
+export { compressImage, setImageCompressorImplementation } from './imageCompression';
 //# 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/retry.d.ts

@@ -0,0 +1,27 @@
+import type { AxiosError, AxiosInstance } from 'axios';
+export interface RetryPolicy {
+    retries?: number;
+    /** `attempt` is 1-based: 1 is the first retry, not the original request. */
+    retryDelayMs?: (attempt: number) => number;
+    shouldRetry?: (error: AxiosError) => boolean;
+    onRetry?: (attempt: number, error: AxiosError) => void;
+}
+declare module 'axios' {
+    interface AxiosRequestConfig {
+        /** `false` opts a single request out of retrying; an object overrides the client policy. */
+        retry?: boolean | RetryPolicy;
+    }
+}
+/**
+ * Status-based ONLY, deliberately: a bare network error (no `error.response`)
+ * is never retryable. Both clients carry non-idempotent requests, login and OTP
+ * on the public one and every write on the user one, and a broken connection
+ * says nothing about whether the request reached the server. Retrying can
+ * therefore create a second session, or a duplicate record, that the user never
+ * sees. A generic network-error retry rule is not a substitute: it decides on
+ * the transport alone and never looks at the HTTP method, so it retries POSTs
+ * as readily as GETs.
+ */
+export declare const isRetryableStatus: (status: number | undefined) => boolean;
+export declare const attachRetry: (client: AxiosInstance, policy?: RetryPolicy) => void;
+//# sourceMappingURL=retry.d.ts.map

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

@@ -45,5 +45,16 @@ export interface RefreshableStore {
 declare const userClient: AxiosInstance;
 export declare const injectStore: <S>(_store: S) => void;
 export declare const injectAuthActions: (actions: AuthActions) => void;
+/**
+ * Clear any in-flight token refresh and reject everything queued behind it.
+ * Call this on logout.
+ *
+ * Without it, a refresh that was already in flight when the user logged out
+ * resolves afterwards and replays every queued request with a token for a
+ * session that has ended. The queue is module state, so it survives the logout
+ * entirely: nothing else clears it. A consumer app hit this and hand-wrote the
+ * same function locally, which is how it was found.
+ */
+export declare const resetRefreshState: () => void;
 export default userClient;
 //# sourceMappingURL=userClient.d.ts.map

package/lib/typescript/module/auth/authStore.d.ts

@@ -2,6 +2,15 @@ import type * as KeychainModule from 'react-native-keychain';
 /**
  * Token data persisted in the keychain.
  */
+/**
+ * The two keys the library itself reads. Everything in the library that needs
+ * the bearer token, the HTTP client, the download module and the authenticated
+ * image cache, resolves it through these rather than repeating the literal, so
+ * one of them cannot silently drift and start reading a key nothing writes.
+ * Apps are free to store their own tokens under any other key.
+ */
+export declare const ACCESS_TOKEN_KEY = "accessToken";
+export declare const REFRESH_TOKEN_KEY = "refreshToken";
 export interface StoredToken {
     token: string;
     expiry: string;
@@ -11,20 +20,34 @@ export interface StoredToken {
  * Lets us avoid a hard import on `react-native-keychain`, so an app that never
  * stores a token does not have to install it.
  */
+/**
+ * The GENERIC password API, not the internet-credentials one.
+ *
+ * `kSecClassInternetPassword` exists for credentials bound to a server, protocol
+ * and port, and it integrates with Safari and AutoFill. A bearer token keyed by
+ * a name like "accessToken" is none of those things, and the library was only
+ * satisfying that API's required `server` argument by passing the key twice,
+ * once as the server and once as the service. That is misuse of the class.
+ *
+ * `kSecClassGenericPassword` is the class for app-local secrets, which is what a
+ * token is. It is what expo-secure-store uses underneath, and what the consumer
+ * app being migrated had already chosen for itself.
+ */
 interface KeychainLike {
-    setInternetCredentials: (server: string, username: string, password: string, options?: {
+    setGenericPassword: (username: string, password: string, options?: {
         service?: string;
     }) => Promise<unknown>;
-    getInternetCredentials: (server: string, options?: {
+    getGenericPassword: (options?: {
         service?: string;
     }) => Promise<KeychainModule.UserCredentials | false>;
-    resetInternetCredentials: (options: {
-        service: string;
+    resetGenericPassword: (options?: {
+        service?: string;
     }) => Promise<unknown>;
 }
 /**
- * Inject a custom keychain backend at runtime.
- * Pass `null` to reset to the default react-native-keychain backend.
+ * Replace the secure-store backend. Intended for TESTS and for the showcase,
+ * which injects a failing store to demo the write-failure path; it is not how
+ * an app configures the library. Pass `null` to restore expo-secure-store.
  */
 export declare const setKeychainImplementation: (impl: KeychainLike | null) => void;
 /**

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

@@ -27,6 +27,12 @@ export interface Config {
     appId: string | null;
     /** The app's user-visible version string, e.g. `'1.4.2'`. Same rationale as `appId`. */
     appVersion: string | null;
+    /**
+     * Log a copy-pasteable curl command for every API request. Credentials are
+     * redacted either way, but this is still request-level noise, so it stays off
+     * unless an app asks for it while debugging.
+     */
+    logCurl: boolean;
 }
 /**
  * Set global configuration for all Webority packages

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

@@ -0,0 +1,54 @@
+export interface ParsedLink {
+    /** The original URL, trimmed. */
+    url: string;
+    /** Lower-cased scheme without `://`, or '' when the URL carried none. */
+    scheme: string;
+    /**
+     * The authority for http(s) URLs. Custom schemes put the first route segment
+     * there (`myapp://order/12`), so for those `host` is `segments[0]` and stays
+     * part of `path` so one route pattern matches both link shapes.
+     */
+    host: string;
+    /** Route path with no leading or trailing slash. */
+    path: string;
+    segments: string[];
+    /** Query values, decoded. A repeated key keeps its last occurrence. */
+    query: Record<string, string>;
+}
+export interface DeepLinkRoute {
+    /** A path pattern with `:param` segments (`order/:id`), or a RegExp on `path`. */
+    match: string | RegExp;
+    requiresAuth?: boolean;
+    handler: (link: ParsedLink, params: Record<string, string>) => void;
+}
+export interface DeepLinkConfig {
+    routes: DeepLinkRoute[];
+    /** Navigator readiness. Links arriving before this is true are queued. */
+    isReady?: () => boolean;
+    isAuthenticated?: () => boolean;
+    /** Called when an auth-gated link is stashed; the app sends the user to login. */
+    onUnauthenticated?: (link: ParsedLink) => void;
+    onUnmatched?: (link: ParsedLink) => void;
+}
+/**
+ * Parse a deep-link URL. Returns null for anything that is not a usable URL so
+ * a hostile or truncated link can never throw on the native event path.
+ */
+export declare const parseDeepLink: (url: string) => ParsedLink | null;
+export declare const DeepLink: {
+    configure: (next: DeepLinkConfig) => void;
+    start: () => Promise<void>;
+    stop: () => void;
+    handleUrl: (url: string) => void;
+    setReady: (ready: boolean) => void;
+    /** Replay the stashed link, once. Call after a successful login. */
+    replayPending: () => void;
+    getPending: () => ParsedLink | null;
+};
+/**
+ * Configure and start the deep-link service for the lifetime of a component.
+ * The stored config delegates to the latest render, so new route closures do
+ * not tear down and re-subscribe the native listener.
+ */
+export declare const useDeepLink: (deepLinkConfig: DeepLinkConfig) => void;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/download/adapters/expoFs.d.ts

@@ -0,0 +1,45 @@
+import type { FileSystemLike } from '../index.js';
+/**
+ * expo-file-system. Shape verified against 57.0.6, where the legacy function
+ * API (`downloadAsync`, `getInfoAsync`) still exists on the main entry point
+ * but every one of those functions THROWS at runtime; they now live behind
+ * `expo-file-system/legacy`. This adapter therefore uses the class API only.
+ *
+ * The REQUIRE lives in the entry point beside this file, never here.
+ */
+interface ExpoFileLike {
+    readonly uri: string;
+    readonly exists: boolean;
+    readonly size: number;
+    delete: () => void;
+}
+interface ExpoDirectoryLike {
+    readonly uri: string;
+    create: (options?: {
+        intermediates?: boolean;
+        idempotent?: boolean;
+    }) => void;
+}
+interface ExpoDownloadTaskLike {
+    downloadAsync: () => Promise<ExpoFileLike | null>;
+    cancel: () => void;
+}
+export interface ExpoFileSystemModuleLike {
+    File: (new (uri: string) => ExpoFileLike) & {
+        createDownloadTask: (url: string, destination: ExpoFileLike, options?: {
+            headers?: Record<string, string>;
+            onProgress?: (progress: {
+                bytesWritten: number;
+                totalBytes: number;
+            }) => void;
+        }) => ExpoDownloadTaskLike;
+    };
+    Directory: new (uri: string) => ExpoDirectoryLike;
+    Paths: {
+        document: ExpoDirectoryLike;
+        cache: ExpoDirectoryLike;
+    };
+}
+export declare const adaptExpoFileSystem: (mod: unknown) => FileSystemLike | null;
+export {};
+//# sourceMappingURL=expoFs.d.ts.map

package/lib/typescript/module/download/adapters/shared.d.ts

@@ -0,0 +1,3 @@
+/** Coerce a driver-supplied size, which some report as a string. */
+export declare const asNumber: (value: unknown) => number;
+//# sourceMappingURL=shared.d.ts.map

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

@@ -0,0 +1,76 @@
+export interface FileSystemDirs {
+    documents: string;
+    cache: string;
+    downloads: string;
+}
+export interface FileSystemDownloadRequest {
+    url: string;
+    path: string;
+    headers: Record<string, string>;
+    onProgress?: (received: number, total: number) => void;
+}
+export interface FileSystemDownloadHandle {
+    promise: Promise<{
+        status?: number;
+        bytes?: number;
+    }>;
+    cancel?: () => void;
+}
+/**
+ * The slice of a native filesystem module this module actually uses. Both
+ * `react-native-blob-util` and `react-native-fs` are adapted onto it, and an app
+ * can inject its own with `setFileSystemImplementation`.
+ */
+export interface FileSystemLike {
+    dirs: FileSystemDirs;
+    download: (request: FileSystemDownloadRequest) => FileSystemDownloadHandle;
+    exists: (path: string) => Promise<boolean>;
+    stat: (path: string) => Promise<{
+        size: number;
+    }>;
+    unlink: (path: string) => Promise<void>;
+    mkdir: (path: string) => Promise<void>;
+}
+export type DownloadDestination = 'documents' | 'cache' | 'downloads';
+export interface DownloadOptions {
+    url: string;
+    fileName?: string;
+    destination?: DownloadDestination;
+    headers?: Record<string, string>;
+    authenticated?: boolean;
+    mimeType?: string;
+    onProgress?: (received: number, total: number, fraction: number) => void;
+    overwrite?: boolean;
+    signal?: AbortSignal;
+}
+export interface DownloadResult {
+    path: string;
+    bytes: number;
+    mimeType?: string;
+    fromCache: boolean;
+}
+export type DownloadErrorCode = 'unsupported' | 'permission-denied' | 'network' | 'http-error' | 'write-failed' | 'aborted' | 'empty-file';
+export declare class DownloadError extends Error {
+    readonly code: DownloadErrorCode;
+    readonly status?: number;
+    constructor(code: DownloadErrorCode, message: string, status?: number);
+}
+/**
+ * Replace the filesystem backend. Intended for TESTS and for the showcase,
+ * which injects a denying backend to demo the permission error; an app gets
+ * expo-file-system without wiring anything. Pass `null` to restore it.
+ */
+export declare const setFileSystemImplementation: (impl: FileSystemLike | null) => void;
+/**
+ * Download a file to the device, attaching the stored bearer token by default.
+ *
+ * A finished download is always verified to be non-empty: a 0-byte file looks
+ * like a success to every caller and then wedges whatever consumes it, so it is
+ * deleted and reported as `empty-file`.
+ */
+export declare const downloadFile: (options: DownloadOptions) => Promise<DownloadResult>;
+/**
+ * Hand a downloaded file to the OS, to open in whichever app claims it.
+ */
+export declare const openFile: (path: string, mimeType?: string) => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -4,5 +4,6 @@ export type { DateInput, DateStyle, TimeStyle } from './date.js';
 export { formatDate, formatDateTime, formatRelativeTime, formatTime } from './date.js';
 export { getInitials } from './initials.js';
 export { formatCompactNumber, formatNumber, formatPercent } from './number.js';
-export { formatPhone, normalizePhone } from './phone.js';
+export type { FormatPhoneOptions, PhoneCountry, PhoneNumber } from './phone.js';
+export { detectPhoneCountry, formatPhone, isValidPhoneNumber, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString } from './phone.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/formatters/phone.d.ts

@@ -1,13 +1,39 @@
+/**
+ * Real cross-country validation, re-exported rather than reimplemented.
+ * formatPhone/normalizePhone/detectPhoneCountry below are a fast, dependency-
+ * light DISPLAY formatter for a fixed set of countries; they are not a
+ * validator. Real phone number plans have country-specific area-code and
+ * mobile-prefix rules that only a maintained metadata table gets right -
+ * hand-rolling that risks silently-wrong validation for a country nobody
+ * tests against. Both live here so consumers get one phone module, not two.
+ */
+export type { PhoneNumber } from 'libphonenumber-js';
+export { isValidPhoneNumber, parsePhoneNumber, parsePhoneNumberFromString } from 'libphonenumber-js';
+export type PhoneCountry = 'IN' | 'US' | 'GB' | 'AE' | 'AU' | 'SG' | 'CA';
+export interface FormatPhoneOptions {
+    defaultCountryCode?: string;
+    country?: PhoneCountry;
+    includeCountryCode?: boolean;
+}
 /**
  * Strip everything except digits and a leading `+` (preserved if present).
  */
 export declare const normalizePhone: (input: string) => string;
+/**
+ * Detect the country of a phone number: from its own `+` country code when
+ * present, otherwise from `defaultCountryCode`. Returns null when neither
+ * carries a recognised calling code.
+ */
+export declare const detectPhoneCountry: (input: string, defaultCountryCode?: string) => PhoneCountry | null;
 /**
  * Format a phone number for human display.
  *
  * - Indian mobile (10 digits) → `XXXXX XXXXX`
  * - With `+91` country code → `+91 XXXXX XXXXX`
+ * - A number that already carries a recognised country code is grouped for
+ *   that country regardless of `defaultCountryCode`.
  * - Other inputs are returned as `+CC NNNN NNNN…` best-effort grouping.
  */
-export declare const formatPhone: (input: string, defaultCountryCode?: string) => string;
+export declare function formatPhone(input: string, defaultCountryCode?: string): string;
+export declare function formatPhone(input: string, options?: FormatPhoneOptions): string;
 //# sourceMappingURL=phone.d.ts.map

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

@@ -0,0 +1,42 @@
+import type { GeolocationLike } from '../index.js';
+/**
+ * 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/module/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