@webority/mobile-core 0.0.23

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

@@ -0,0 +1,133 @@
+import { type CountryCode } from 'libphonenumber-js/max';
+export type { NumberType as PhoneNumberType, PhoneNumber } from 'libphonenumber-js/max';
+export { AsYouType, getCountries, getCountryCallingCode, isSupportedCountry, isValidPhoneNumber, parsePhoneNumber, parsePhoneNumberFromString, validatePhoneNumberLength } from 'libphonenumber-js/max';
+/**
+ * Re-exported under our own name rather than importing CountryCode directly
+ * everywhere, so a future need to diverge (or re-narrow) has one place to do
+ * it. Every ISO 3166-1 alpha-2 code libphonenumber-js recognises - formatPhone
+ * and detectPhoneCountry below are genuinely correct for all of them, not a
+ * curated subset.
+ */
+export type PhoneCountry = CountryCode;
+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
+ * parses to a recognised country.
+ */
+export declare const detectPhoneCountry: (input: string, defaultCountryCode?: string) => PhoneCountry | null;
+/**
+ * Format a phone number for human display, via libphonenumber-js's own
+ * per-country formatting rather than a hand-rolled grouping table - correct
+ * for every country it recognises, not a curated subset.
+ *
+ * - A number that already carries a `+` country code formats for that country.
+ * - A bare national number formats for `options.country` when given, else for
+ *   the country implied by `defaultCountryCode` (default `+91`).
+ * - `includeCountryCode` controls international vs national format; defaults
+ *   to international whenever the country was detected rather than passed in
+ *   explicitly as `options.country`, and to national when it was.
+ * - Input libphonenumber-js can't parse into a valid number for the resolved
+ *   country falls back to a best-effort `+CC NNNN NNNN…` digit grouping.
+ */
+export declare function formatPhone(input: string, defaultCountryCode?: string): string;
+export declare function formatPhone(input: string, options?: FormatPhoneOptions): string;
+/** Country calling code + national digits, the way a phone field stores them. */
+export interface PhoneParts {
+    /** ISO 3166-1 alpha-2 of the country the number belongs to, when it can be told. */
+    country: PhoneCountry | null;
+    /** Dial prefix WITHOUT the plus, e.g. '91'. */
+    callingCode: string;
+    /** National digits only, no prefix, no formatting. */
+    nationalNumber: string;
+}
+/**
+ * Which kinds of number count as valid. `'any'` is libphonenumber's own
+ * answer (a fixed line passes). `'mobile'` narrows to MOBILE and
+ * FIXED_LINE_OR_MOBILE, which is what an OTP or WhatsApp field wants: in India
+ * a 10-digit number starting with 1 to 5 is a real fixed line and passes
+ * `'any'`, but no SMS will ever reach it.
+ */
+export type PhoneValidationKind = 'any' | 'mobile';
+/**
+ * Split a typed or pasted number into calling code + national digits.
+ * `'+919876543210'` resolves to IN / 91 / 9876543210 from its own prefix; a
+ * bare `'9876543210'` needs `defaultCountry` to resolve at all. Returns null
+ * when the input has no digits or no country can be told. A shared calling
+ * code (`+1` for US and CA) resolves to the country whose area code matches,
+ * which is why the country comes back as part of the answer rather than being
+ * looked up again from the code.
+ */
+export declare const splitPhoneNumber: (input: string, defaultCountry?: PhoneCountry) => PhoneParts | null;
+/**
+ * Cut national digits that run past the longest number the country's plan
+ * allows, so a field stops accepting the impossible without a per-country
+ * length table. This is the PLAN's ceiling, not a mobile number's: India runs
+ * to 13 digits (toll-free 1800 numbers), the US to 10, Germany to 15. A field
+ * that should stop where a subscriber's number ends asks
+ * `maxNationalNumberLength` instead. Digits within range, including a number
+ * still too short, pass through untouched.
+ */
+export declare const clampNationalNumber: (nationalDigits: string, country: PhoneCountry) => string;
+/**
+ * The most national digits a subscriber's number can have in a country, so a
+ * field can refuse the next digit as it is typed rather than trimming after.
+ * `'any'` (default) covers mobile and fixed lines, `'mobile'` mobiles only: India
+ * is 10 either way (its plan's 13 belongs to toll-free numbers), Germany is 15
+ * for `'any'` and 11 for `'mobile'`, the UAE 9. A country whose metadata lists
+ * no lengths by type falls back to the plan's longest number.
+ */
+export declare const maxNationalNumberLength: (country: PhoneCountry, kind?: PhoneValidationKind) => number;
+/**
+ * National digits grouped the way the country writes them, updated on every
+ * keystroke: `'98765'` for IN is `'98765'`, `'9876543210'` is `'98765 43210'`,
+ * `'2025550123'` for US is `'(202) 555-0123'`. Output is for display only; the
+ * digits are what a value stores. Digits past the plan's longest possible
+ * number are dropped first, so an overflowing paste never formats as a longer
+ * number; digits that fit no pattern come back ungrouped rather than forced
+ * into a shape.
+ *
+ * Countries that write a leading 0 (the UAE, the UK, Australia, Saudi Arabia)
+ * only group in national mode when that 0 is typed, and a value never holds
+ * it. When national mode hands the digits back untouched, the grouping comes
+ * from the international form with the calling code removed: `'501234567'`
+ * for AE is `'50 123 4567'`. Countries that group nationally are unaffected.
+ */
+export declare const formatPhoneAsTyped: (nationalDigits: string, country: PhoneCountry) => string;
+/**
+ * Whether national digits form a real number for the country, by the
+ * country's own numbering plan rather than a length check. `kind: 'mobile'`
+ * additionally rejects fixed lines; a number whose type the metadata cannot
+ * tell is accepted, since the metadata, not the number, is what is missing.
+ */
+export declare const isValidNationalNumber: (nationalDigits: string, country: PhoneCountry, kind?: PhoneValidationKind) => boolean;
+/**
+ * The flag as an emoji built from the ISO code's two regional-indicator
+ * letters, so no font asset ships with the library: iOS and Android both draw
+ * these from the system font. An unknown or malformed code returns ''. (Windows
+ * browsers render the two letters instead of a flag; that is the platform, not
+ * the code.)
+ */
+export declare const countryFlagEmoji: (iso: string) => string;
+/** Calling code + ISO for one country, the shape a country picker lists. */
+export interface PhoneCountryEntry {
+    iso: PhoneCountry;
+    /** Dial prefix WITHOUT the plus, e.g. '91'. */
+    callingCode: string;
+}
+/**
+ * Every country libphonenumber-js knows, with its calling code, in metadata
+ * order. Names are deliberately not here: they are display data, in one
+ * language, and live on their own import path (`mobile-core/phone/countries`)
+ * so an app that never opens a full country list does not carry them.
+ */
+export declare const getPhoneCountries: () => ReadonlyArray<PhoneCountryEntry>;
+//# sourceMappingURL=phone.d.ts.map

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

@@ -0,0 +1,18 @@
+/**
+ * .NET-style Windows time zone ID → IANA time zone name, one entry per
+ * Windows zone, generated from CLDR's `windowsZones.xml` (the same
+ * upstream source the retired `windows-iana` npm package derived its own
+ * table from). Only the `territory="001"` (world-default) row is kept per
+ * Windows zone — `formatTimeInWindowsZone` only ever reads the first IANA
+ * candidate, and CLDR's `001` row is exactly that default candidate, so
+ * per-country territory variants (`US`, `CA`, `ZZ`, …) carry no information
+ * this table's one caller uses.
+ *
+ * Regenerate with `node packages/core/scripts/generate-windows-to-iana-table.mjs
+ * <path-to-windowsZones.xml>` (CLDR: `common/supplemental/windowsZones.xml` in
+ * https://github.com/unicode-org/cldr) whenever CLDR adds/renames a zone —
+ * this is a committed, static table; nothing fetches CLDR at build or test
+ * time.
+ */
+export declare const WINDOWS_TO_IANA: Readonly<Record<string, string>>;
+//# sourceMappingURL=windowsToIanaTable.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,90 @@
+import '../permissions/location.js';
+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/module/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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/mobile-core/permissions  per kind, its own Expo module
+ *   @webority/mobile-core/compressor   expo-image-manipulator + expo-file-system
+ *   @webority/mobile-core/geolocation  a geolocation provider
+ *   @webority/mobile-core/sqlite       expo-sqlite
+ *   @webority/mobile-core/download     a filesystem module
+ *   @webority/mobile-core/share        expo-sharing
+ *   @webority/mobile-core/smsRetriever Android only, own TurboModule
+ *
+ * One more path is separate for size, not for a native package:
+ *
+ *   @webority/mobile-core/phone/countries  245 English country names
+ *
+ * Token storage is the exception and IS on the main barrel, because the HTTP
+ * client reads the bearer token. It needs no optional peer: the backend is
+ * expo-secure-store, and `expo` is required anyway.
+ */
+export { buildCurl, logCurl } from './api/curl.js';
+export { default as publicClient } from './api/publicClient.js';
+export type { RetryPolicy } from './api/retry.js';
+export { attachRetry, isRetryableStatus } from './api/retry.js';
+export type { RefreshableStore, SessionTerminationCode } from './api/userClient.js';
+export { default as userClient, injectStore, injectUserAuth, RequestOfflineError, resetRefreshState, SESSION_TERMINATION_CODES } from './api/userClient.js';
+export type { KeychainLike, SecureCredentials, StoredToken } from './auth/authStore.js';
+export { ACCESS_TOKEN_KEY, getToken, REFRESH_TOKEN_KEY, removeToken, setKeychainImplementation, storeToken } from './auth/authStore.js';
+export type { JwtClaims } from './auth/jwt.js';
+export { decodeJWT, getJWTExpiry, isJWTExpired } from './auth/jwt.js';
+export type { Config, Environment, LogLevel } from './config/index.js';
+export { getConfig, getConfigValue, resetConfig, setConfig } from './config/index.js';
+export type { DeepLinkConfig, DeepLinkRoute, ParsedLink } from './deepLink/index.js';
+export { DeepLink, parseDeepLink, useDeepLink } from './deepLink/index.js';
+export type { DateInput, DateStyle, FormatCurrencyOptions, FormatPhoneOptions, PhoneCountry, PhoneCountryEntry, PhoneNumber, PhoneNumberType, PhoneParts, PhoneValidationKind, TimeStyle } from './formatters/index.js';
+export { AsYouType, addDays, clampNationalNumber, countryFlagEmoji, detectPhoneCountry, diffMs, formatCompactNumber, formatCurrency, formatDate, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatDateTime, formatNumber, formatPercent, formatPhone, formatPhoneAsTyped, formatRelativeTime, formatTime, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, getCountries, getCountryCallingCode, getInitials, getPhoneCountries, isDateAfter, isDateBefore, isSameDay, isSupportedCountry, isValidNationalNumber, isValidPhoneNumber, maxNationalNumberLength, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString, splitPhoneNumber, startOfDay, validatePhoneNumberLength } from './formatters/index.js';
+export type { InitConfig } from './initSDK.js';
+export { initWebority } from './initSDK.js';
+export type { TokenRefreshConfig, TokenRefreshResult, UserAuthOptions } from './initUserAuth.js';
+export { initUserAuth } from './initUserAuth.js';
+export type { DeviceContext, LoggerOptions, LoggerType, RemoteLogger } from './logger/index.js';
+export { configureLogger, getDeviceContext, Logger, setDeviceContext, setRemoteLogger } from './logger/index.js';
+export type { NetworkConnectionType, NetworkStatus, NetworkStatusLike, NetworkStatusListener } from './network/index.js';
+export { addNetworkStatusListener, getNetworkStatus, setNetworkStatusImplementation, useNetworkStatus } from './network/index.js';
+export type { AsyncStorageLike, StorageApi } from './storage/index.js';
+export { isStorageAvailable, Storage, setStorageImplementation } from './storage/index.js';
+export type { PasswordRules } from './validators/index.js';
+export { isAadhaar, isAlphanumeric, isBetween, isEmail, isGstin, isHexColor, isIfsc, isIndianMobile, isIndianPincode, isInteger, isNonEmpty, isNumeric, isPan, isPhone, isStrongPassword, isUrl, maxLength, minLength } from './validators/index.js';
+export type { DeviceInfoLike, ParsedVersion, Platform, UpdateInfo, UpdateType, VersionCheckResult, VersionCheckType, VersionComparison, VersionData } from './versionCheck/index.js';
+export { setDeviceInfoImplementation, useVersionCheck, VersionCheck } from './versionCheck/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,72 @@
+/**
+ * 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;
+    /** Enable/disable logging. Defaults to `true`. */
+    loggingEnabled?: boolean;
+    /** Log level. Defaults to `'info'`. */
+    logLevel?: LogLevel;
+    /** Environment. Defaults to `'Development'`. */
+    environment?: Environment;
+    /**
+     * ISO 3166-1 alpha-2 country code (lowercase) used for App Store / Play Store
+     * 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.
+ *
+ * @example
+ * // Basic setup
+ * initWebority({
+ *   baseUrl: 'https://api.myapp.com'
+ * });
+ *
+ * @example
+ * // Full configuration
+ * initWebority({
+ *   baseUrl: 'https://api.myapp.com',
+ *   loggingEnabled: __DEV__,
+ *   logLevel: 'warn',
+ *   environment: __DEV__ ? 'Development' : 'Production'
+ * });
+ */
+export declare const initWebority: (config: InitConfig) => void;
+//# sourceMappingURL=initSDK.d.ts.map

package/lib/typescript/module/initUserAuth.d.ts

@@ -0,0 +1,41 @@
+/** The tokens a refresh response carries, with their expiry timestamps. */
+export interface TokenRefreshResult {
+    accessToken: string;
+    accessTokenExpiry: string;
+    refreshToken: string;
+    refreshTokenExpiry: string;
+}
+/**
+ * How the library calls the app's refresh endpoint. The call goes through
+ * `publicClient`, and the new tokens are stored under the library's own keys.
+ */
+export interface TokenRefreshConfig {
+    /** The refresh endpoint, relative to the configured baseUrl, e.g. `/Account/RefreshToken`. */
+    path: string;
+    /** The request body; may return a promise. Defaults to `{ accessToken, refreshToken }`. */
+    body?: (tokens: {
+        accessToken: string | null;
+        refreshToken: string;
+    }) => unknown;
+    /**
+     * Reads the new tokens from the response body. Defaults to the Webority API's
+     * `{ accessToken, accessTokenExpiration, refreshToken, refreshTokenExpiration }`.
+     */
+    readTokens?: (data: unknown) => TokenRefreshResult;
+}
+export interface UserAuthOptions {
+    /** Action creator dispatched when the session is over. */
+    logout: () => unknown;
+    refresh: TokenRefreshConfig;
+}
+/**
+ * Wire the user client to the app: the Redux store it dispatches `logout` to,
+ * and the refresh endpoint it calls when an access token expires or a request
+ * answers 401. Only a 400 or 401 from that endpoint, or a missing or expired
+ * refresh token, logs out; a network error, timeout or 5xx keeps the session.
+ *
+ * @example
+ * initUserAuth(store, { logout, refresh: { path: '/Account/RefreshToken' } });
+ */
+export declare const initUserAuth: <S>(store: S, options: UserAuthOptions) => void;
+//# sourceMappingURL=initUserAuth.d.ts.map

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

@@ -0,0 +1,81 @@
+import { type LogLevel } from '../config/index.js';
+type LogFn = (message: string, ...optionalParams: unknown[]) => void;
+/**
+ * Optional remote sink. Apps wire this via `setRemoteLogger()` to forward errors
+ * and breadcrumbs to Crashlytics, Sentry, Bugsnag, etc. — without making the
+ * library depend on any of them.
+ *
+ * Every method is optional; the library calls only what the adapter implements.
+ */
+export interface RemoteLogger {
+    /** Append a breadcrumb (small, non-error event) for crash context. */
+    breadcrumb?: (message: string, data?: Record<string, unknown>) => void;
+    /** Record a non-fatal error with optional context. */
+    recordError?: (error: unknown, context?: Record<string, unknown>) => void;
+    /** Bind a logical user to subsequent events. */
+    setUser?: (id: string | null, attrs?: Record<string, unknown>) => void;
+    /** Attach a custom attribute / tag (e.g. `release`, `env`). */
+    setAttribute?: (key: string, value: string | number | boolean | null) => void;
+    /** Forward a leveled console message. */
+    log?: (level: LogLevel, message: string, optionalParams: unknown[]) => void;
+}
+/**
+ * Inject a remote logger adapter (e.g. Firebase Crashlytics, Sentry).
+ * 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;
+    error: LogFn;
+    /** Append a breadcrumb to the remote sink (and log at info level). */
+    breadcrumb: (message: string, data?: Record<string, unknown>) => void;
+    /** Record a non-fatal error with optional context. */
+    recordError: (error: unknown, context?: Record<string, unknown>) => void;
+    /** Bind a user identity for subsequent crash reports. */
+    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 {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,43 @@
+export type NetworkConnectionType = 'unknown' | 'none' | 'wifi' | 'cellular' | 'bluetooth' | 'ethernet' | 'wimax' | 'vpn' | 'other';
+export interface NetworkStatus {
+    /** True when the device has any network connection. */
+    isConnected: boolean;
+    /**
+     * True when the connection can reach the public internet
+     * (NetInfo's reachability probe). `null` when undetermined.
+     */
+    isInternetReachable: boolean | null;
+    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.
+ */
+export declare const getNetworkStatus: () => Promise<NetworkStatus>;
+/**
+ * Subscribe to network status changes. Returns an unsubscribe function.
+ */
+export declare const addNetworkStatusListener: (listener: NetworkStatusListener) => (() => void);
+/**
+ * React hook that returns the current network status and re-renders on change.
+ * 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/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/module/permissions/calendar.d.ts

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

package/lib/typescript/module/permissions/camera.d.ts

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

package/lib/typescript/module/permissions/contacts.d.ts

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

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

@@ -0,0 +1,48 @@
+export type PermissionKind = 'camera' | 'microphone' | 'photos' | 'photosAdd' | 'mediaLibrary' | 'location' | 'locationAlways' | 'contacts' | 'calendar' | 'reminders' | 'notifications' | 'bluetooth' | 'storage';
+export type PermissionStatus = 'unavailable' | 'denied' | 'limited' | 'granted' | 'blocked';
+/** The shared response shape every Expo permission function returns. */
+interface ExpoPermissionResponse {
+    status: 'granted' | 'denied' | 'undetermined';
+    granted: boolean;
+    canAskAgain: boolean;
+    /** iOS partial photo access, from expo-image-picker's MediaLibraryPermissionResponse. */
+    accessPrivileges?: 'all' | 'limited' | 'none';
+}
+interface ExpoPermissionFns {
+    check: () => Promise<ExpoPermissionResponse>;
+    request: () => Promise<ExpoPermissionResponse>;
+}
+export interface PermissionsBackend {
+    check: (kind: PermissionKind) => Promise<PermissionStatus>;
+    request: (kind: PermissionKind) => Promise<PermissionStatus>;
+}
+/**
+ * Inject a custom permissions backend at runtime. Pass `null` to reset to the
+ * default per-kind Expo resolution.
+ *
+ * Two legitimate reasons to call this: tests/the showcase reaching a denied,
+ * blocked or unavailable path a healthy device never takes; and an app that
+ * genuinely needs `bluetooth` or `storage`, which no Expo module covers.
+ */
+export declare const setPermissionsImplementation: (impl: PermissionsBackend | null) => void;
+/** Called by the per-package entry points to register their kind(s). Not for app code. */
+export declare const registerPermissionAdapter: (kind: PermissionKind, fns: ExpoPermissionFns) => void;
+/**
+ * Cross-platform permissions wrapper. Maps an abstract `PermissionKind`
+ * (camera, photos, location, notifications, …) to whichever Expo adapter an
+ * app has registered by importing that kind's entry point — expo-camera,
+ * expo-image-picker, expo-location, expo-contacts, expo-calendar,
+ * expo-notifications, expo-media-library. An app imports only the entry
+ * points for the kinds it actually asks for.
+ */
+export declare const Permissions: {
+    check: (kind: PermissionKind) => Promise<PermissionStatus>;
+    request: (kind: PermissionKind) => Promise<PermissionStatus>;
+    /** Convenience: returns true when the permission is `granted` or `limited`. */
+    isAuthorized: (kind: PermissionKind) => Promise<boolean>;
+    /** Convenience: check, and request only if not yet granted. */
+    ensure: (kind: PermissionKind) => Promise<PermissionStatus>;
+    openSettings: () => Promise<boolean>;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/permissions/location.d.ts

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

package/lib/typescript/module/permissions/mediaLibrary.d.ts

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