@webority/mobile-core 0.0.23

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/tokenRefresh.d.ts

@@ -0,0 +1,43 @@
+import type { UserAuthOptions } from '../initUserAuth.js';
+/**
+ * The one token-refresh flow in the library, run by userClient's interceptors.
+ * The library calls the refresh endpoint itself, so it can tell a rejected
+ * refresh token (400 or 401: the session is over) from a transient failure
+ * (network, timeout, 5xx: the session is kept and the caller sees the error).
+ * A refresh is single flight. A download goes through the app's client, so it
+ * reaches this only when that client is userClient.
+ */
+/**
+ * Minimal Redux-store shape required by the user client to dispatch logout.
+ */
+export interface RefreshableStore {
+    dispatch: (action: unknown) => unknown;
+}
+export declare const injectStore: <S>(_store: S) => void;
+export declare const injectUserAuth: (options: UserAuthOptions) => 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 declare const getErrorMessage: (error: unknown) => string;
+/** The refresh endpoint's path, once initUserAuth has run. */
+export declare const getRefreshPath: () => string | undefined;
+export declare const dispatchLogout: () => Promise<void>;
+export declare const isRefreshInFlight: () => boolean;
+/** Wait for the in-flight refresh without joining it: resolved or rejected by processQueue. */
+export declare const queueBehindRefresh: () => Promise<string>;
+/**
+ * Refresh the access token, joining a refresh already in flight rather than
+ * starting a second one. Every request queued behind it is replayed on success
+ * and rejected on failure. Logs out only when the failure proves the session
+ * is over; a network error, timeout or 5xx keeps it and rejects.
+ */
+export declare const refreshAccessToken: () => Promise<string>;
+//# sourceMappingURL=tokenRefresh.d.ts.map

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

@@ -0,0 +1,37 @@
+import { type AxiosInstance } from 'axios';
+export type { RefreshableStore } from './tokenRefresh.js';
+export { injectStore, injectUserAuth, resetRefreshState } from './tokenRefresh.js';
+/**
+ * Thrown by the request interceptor when the device is offline, before the
+ * request ever reaches the adapter (and therefore the network). Distinct from
+ * an AxiosError so callers can show an offline message instead of a generic
+ * request failure.
+ */
+export declare class RequestOfflineError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Sub-codes a 401 response body carries when the session itself is dead
+ * (terminated by an admin, or expired server-side) rather than merely
+ * out-of-date. These never warrant a refresh attempt — only logout.
+ */
+export declare const SESSION_TERMINATION_CODES: {
+    readonly TERMINATED: "SESSION_TERMINATED";
+    readonly EXPIRED: "SESSION_EXPIRED";
+};
+export type SessionTerminationCode = (typeof SESSION_TERMINATION_CODES)[keyof typeof SESSION_TERMINATION_CODES];
+/**
+ * The header is the AUTHORITATIVE signal, verified against the backend:
+ * `WeborityJwtMiddleware.ReturnUnauthorized` answers an invalidated session with
+ * `401` + `X-Security-Stamp-Invalid: true` and a body of
+ * `{ error: 'Unauthorized', message: '...' }` — no code field at all, and
+ * `error` is a string rather than an object. An earlier version of this checked
+ * only body fields and would therefore never have fired against a real server.
+ *
+ * The body codes below are kept as a secondary path for any head that does send
+ * an explicit sub-code; they match on exact strings, so looking is free.
+ */
+export declare const SESSION_INVALID_HEADER = "x-security-stamp-invalid";
+declare const userClient: AxiosInstance;
+export default userClient;
+//# sourceMappingURL=userClient.d.ts.map

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

@@ -0,0 +1,79 @@
+/**
+ * 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 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;
+}
+/**
+ * The shape this module speaks to its store through. expo-secure-store is
+ * adapted to it below; an app or a test can supply anything else of this shape
+ * through `setKeychainImplementation`.
+ */
+/**
+ * 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.
+ */
+/**
+ * The credential shape the seam reads back, declared here rather than imported
+ * from whichever package a consumer's backend comes from. A type-only import of
+ * a package this library does not declare survives into the published `.d.ts`,
+ * where a consumer that has not installed it either fails to typecheck or,
+ * under the RN template's `skipLibCheck: true`, loses all checking on these
+ * members with no signal. Any credential object with these three members
+ * satisfies it structurally.
+ */
+interface SecureCredentials {
+    username: string;
+    password: string;
+    service: string;
+}
+interface KeychainLike {
+    setGenericPassword: (username: string, password: string, options?: {
+        service?: string;
+    }) => Promise<unknown>;
+    getGenericPassword: (options?: {
+        service?: string;
+    }) => Promise<SecureCredentials | false>;
+    resetGenericPassword: (options?: {
+        service?: string;
+    }) => Promise<unknown>;
+}
+/**
+ * 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;
+/**
+ * Store token with expiry.
+ */
+export declare const storeToken: (key: string, token: string, expiry: string) => Promise<void>;
+/**
+ * Retrieve token and check if expired.
+ */
+export declare const getToken: (key: string) => Promise<StoredToken | null>;
+/**
+ * Remove token by key.
+ */
+export declare const removeToken: (key: string) => Promise<void>;
+export type { KeychainLike, SecureCredentials };
+//# sourceMappingURL=authStore.d.ts.map

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

@@ -0,0 +1,5 @@
+export type { StoredToken } from './authStore.js';
+export { getToken, removeToken, storeToken } from './authStore.js';
+export type { JwtClaims } from './jwt.js';
+export { decodeJWT, getJWTExpiry, isJWTExpired } from './jwt.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,31 @@
+/**
+ * Standard claims plus arbitrary keys.
+ * `sub`, `exp`, `iat`, `nbf` follow RFC 7519 conventions.
+ */
+export interface JwtClaims {
+    sub?: string;
+    exp?: number;
+    iat?: number;
+    nbf?: number;
+    iss?: string;
+    aud?: string | string[];
+    [key: string]: unknown;
+}
+/**
+ * Decode a JWT's payload claims. Does **not** verify the signature.
+ *
+ * @returns claims object on success, `null` if the token is malformed.
+ */
+export declare const decodeJWT: <T extends JwtClaims = JwtClaims>(token: string) => T | null;
+/**
+ * Returns true when the token is expired (or unparseable / missing `exp`).
+ *
+ * @param token JWT string
+ * @param leewaySeconds amount of clock-skew tolerance to apply (default 30s)
+ */
+export declare const isJWTExpired: (token: string, leewaySeconds?: number) => boolean;
+/**
+ * Returns the token's expiry as a Date, or `null` when no `exp` claim exists.
+ */
+export declare const getJWTExpiry: (token: string) => Date | null;
+//# sourceMappingURL=jwt.d.ts.map

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

@@ -0,0 +1,55 @@
+/**
+ * Configuration management for Webority packages
+ * Provides a flexible way to inject configuration without hard dependencies
+ */
+export type LogLevel = 'info' | 'warn' | 'error';
+export type Environment = 'Development' | 'Production' | 'Staging';
+export interface Config {
+    /** API base URL (required before making API calls) */
+    baseUrl: string | null;
+    /** Enable/disable logging globally */
+    loggingEnabled: boolean;
+    /** Minimum log level to emit */
+    logLevel: LogLevel;
+    /** Current runtime environment */
+    environment: Environment;
+    /**
+     * ISO 3166-1 alpha-2 country code (lowercase) used by the version-check
+     * module to scope App Store / Play Store lookups. Defaults to `'in'`.
+     */
+    country: string;
+    /**
+     * The app's store identifier — Android package name / iOS bundle id. Every
+     * Webority app already has this in its `appsettings.Compiled.json`, so the
+     * version-check module reads it from here rather than crossing the native
+     * bridge for a value the app already knows.
+     */
+    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
+ */
+export declare const setConfig: (config: Partial<Config>) => void;
+/**
+ * Get current configuration
+ */
+export declare const getConfig: () => Config;
+/**
+ * Get a specific config value with optional fallback.
+ * If the stored value is `null`, the fallback is returned (when provided).
+ */
+export declare function getConfigValue<K extends keyof Config>(key: K): Config[K];
+export declare function getConfigValue<K extends keyof Config>(key: K, fallback: Config[K]): Config[K];
+/**
+ * Reset configuration to defaults
+ */
+export declare const resetConfig: () => void;
+//# sourceMappingURL=index.d.ts.map

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,38 @@
+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;
+    create: (options?: {
+        intermediates?: boolean;
+        overwrite?: boolean;
+    }) => void;
+    write: (content: Uint8Array) => void;
+    delete: () => void;
+}
+interface ExpoDirectoryLike {
+    readonly uri: string;
+    create: (options?: {
+        intermediates?: boolean;
+        idempotent?: boolean;
+    }) => void;
+}
+export interface ExpoFileSystemModuleLike {
+    File: new (uri: string) => ExpoFileLike;
+    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,86 @@
+export interface FileSystemDirs {
+    documents: string;
+    cache: string;
+    downloads: string;
+}
+/**
+ * The slice of a filesystem module this module actually uses. expo-file-system
+ * is adapted onto it, and a test or the showcase can inject its own with
+ * `setFileSystemImplementation`.
+ */
+export interface FileSystemLike {
+    dirs: FileSystemDirs;
+    write: (path: string, bytes: Uint8Array) => Promise<void>;
+    exists: (path: string) => Promise<boolean>;
+    stat: (path: string) => Promise<{
+        size: number;
+    }>;
+    unlink: (path: string) => Promise<void>;
+    mkdir: (path: string) => Promise<void>;
+}
+export interface DownloadHttpRequestConfig {
+    headers?: Record<string, string>;
+    responseType: 'arraybuffer';
+    timeout?: number;
+    signal?: AbortSignal;
+    onDownloadProgress?: (event: {
+        loaded: number;
+        total?: number;
+    }) => void;
+}
+/**
+ * The slice of an HTTP client a download needs. The app's axios instance
+ * (mobile-core's `userClient` or `publicClient`, or its own) satisfies it as is,
+ * so whatever that client adds to a request (bearer token, tenant header, refresh
+ * and retry on 401) applies to the download too. Declared structurally, as
+ * mobile-support's client is, so no axios type leaks into the declarations.
+ */
+export interface DownloadHttpClient {
+    get<T = unknown>(url: string, config?: DownloadHttpRequestConfig): Promise<{
+        data: T;
+    }>;
+}
+export type DownloadDestination = 'documents' | 'cache' | 'downloads';
+export interface DownloadOptions {
+    /** Sends the request: `userClient` for a signed-in download, `publicClient` for an open one. */
+    client: DownloadHttpClient;
+    url: string;
+    fileName?: string;
+    destination?: DownloadDestination;
+    /** Sent with the request, beside whatever the client adds itself. */
+    headers?: Record<string, string>;
+    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 through the app's own HTTP client, so it is
+ * authenticated exactly as the app's other calls are. The whole file is held
+ * in memory before it is written, which suits documents and reports rather
+ * than large media.
+ *
+ * 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
+ * reported as `empty-file` and nothing is kept.
+ */
+export declare const downloadFile: (options: DownloadOptions) => Promise<DownloadResult>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,24 @@
+export interface FormatCurrencyOptions {
+    /** ISO 4217 currency code. Defaults to `'INR'`. */
+    currency?: string;
+    /** BCP-47 locale tag. Defaults to `'en-IN'` (Indian numbering system). */
+    locale?: string;
+    /** Minimum fraction digits. Defaults to 0 for whole amounts, 2 otherwise. */
+    minimumFractionDigits?: number;
+    /** Maximum fraction digits. Defaults to 2. */
+    maximumFractionDigits?: number;
+    /** Strip the currency symbol — useful when the symbol is rendered separately. */
+    stripSymbol?: boolean;
+}
+/**
+ * Format an amount as currency. Defaults to **INR** with Indian numbering (`en-IN`),
+ * which matches the standard convention across Webority projects.
+ *
+ * @example
+ * formatCurrency(150000)            // ₹1,50,000
+ * formatCurrency(1234.5)            // ₹1,234.50
+ * formatCurrency(99, { currency: 'USD', locale: 'en-US' }) // $99.00
+ * formatCurrency(150000, { stripSymbol: true })            // 1,50,000
+ */
+export declare const formatCurrency: (amount: number | null | undefined, options?: FormatCurrencyOptions) => string;
+//# sourceMappingURL=currency.d.ts.map

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

@@ -0,0 +1,22 @@
+export type DateInput = Date | string | number;
+export type DateStyle = 'short' | 'medium' | 'long' | 'full';
+export type TimeStyle = 'short' | 'medium' | 'long';
+/**
+ * Locale-aware date formatter. Defaults to `'medium'` style and `'en-IN'` locale,
+ * matching the Indian-locale convention used across Webority apps.
+ */
+export declare const formatDate: (value: DateInput, style?: DateStyle, locale?: string) => string;
+/**
+ * Locale-aware time formatter (24-hour fallback when Intl is unavailable).
+ */
+export declare const formatTime: (value: DateInput, style?: TimeStyle, locale?: string) => string;
+/**
+ * Combined date + time formatter.
+ */
+export declare const formatDateTime: (value: DateInput, dateStyle?: DateStyle, timeStyle?: TimeStyle, locale?: string) => string;
+/**
+ * Returns a humanized relative-time string (e.g. "5 minutes ago", "in 3 days").
+ * Uses `Intl.RelativeTimeFormat` when available; otherwise a sensible English fallback.
+ */
+export declare const formatRelativeTime: (value: DateInput, base?: DateInput, locale?: string) => string;
+//# sourceMappingURL=date.d.ts.map

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

@@ -0,0 +1,88 @@
+import type { DateInput } from './date.js';
+/**
+ * Whether two values fall on the same calendar day in the device's local
+ * timezone. Invalid input on either side returns false rather than throwing.
+ */
+export declare const isSameDay: (a: DateInput, b: DateInput) => boolean;
+/** `a` is strictly before `b`. Invalid input on either side returns false. */
+export declare const isDateBefore: (a: DateInput, b: DateInput) => boolean;
+/** `a` is strictly after `b`. Invalid input on either side returns false. */
+export declare const isDateAfter: (a: DateInput, b: DateInput) => boolean;
+/**
+ * `a - b` in milliseconds, matching dayjs's `a.diff(b)` sign convention
+ * (positive when `a` is later than `b`). Returns `NaN` if either side fails
+ * to parse, the same way subtracting two invalid dayjs objects would.
+ */
+export declare const diffMs: (a: DateInput, b: DateInput) => number;
+/**
+ * Midnight of the given date, in the device's local timezone. Returns null
+ * for unparseable input.
+ */
+export declare const startOfDay: (value: DateInput) => Date | null;
+/**
+ * Adds (or, with a negative count, subtracts) whole calendar days in the
+ * device's local timezone. Returns null for unparseable input.
+ */
+export declare const addDays: (value: DateInput, count: number) => Date | null;
+/**
+ * Small dayjs/moment-style token formatter — YYYY/YY, MMMM/MMM/MM/M,
+ * DD/D, dddd/ddd, HH/H (24h), hh/h (12h), mm/m, ss/s, A/a (upper/lower AM/PM).
+ * Everything else in the pattern (spaces, commas, colons) passes through
+ * literally. Hand-rolled rather than a dependency because this fleet's date
+ * formatting needs are a small, closed token set, not general i18n — for
+ * genuinely locale-aware output, `formatDate`/`formatTime` (Intl-backed, in
+ * `./date`) are the ones to reach for; this is for matching an exact
+ * existing pattern (a legacy display string, an API's expected shape).
+ *
+ * `utc: true` reads every field from the UTC calendar/clock instead of the
+ * device's local one — see `formatDateDDMMMYYYY`'s note on why this isn't
+ * cosmetic.
+ */
+export declare const formatDatePattern: (value: DateInput, pattern: string, options?: {
+    utc?: boolean;
+}) => string;
+/**
+ * `DD MMM, YYYY` — zero-padded day, short month, comma, year (e.g.
+ * `05 Sep, 2025`). A specific legacy pattern some apps already display,
+ * not the fleet's own product convention: `formatDate` (the Intl `style`-based
+ * formatter in `./date`) is the one to reach for in new code. This exists so
+ * an app already showing this exact pattern can move off a date library
+ * without a visible change.
+ *
+ * `utc: true` reads the calendar day from the UTC fields instead of the
+ * device's local ones — matching `dayjs.utc(x).format(...)`, not
+ * `dayjs(x).format(...)`. The two disagree whenever local time has crossed a
+ * day boundary UTC hasn't yet (or vice versa), so this is not a cosmetic
+ * option; pass it only to match a call site that was genuinely UTC-explicit.
+ */
+export declare const formatDateDDMMMYYYY: (value: DateInput, options?: {
+    utc?: boolean;
+}) => string;
+/** `YYYY-MM-DD`, in the device's local timezone. */
+export declare const formatDateISO: (value: DateInput) => string;
+/**
+ * `hh:mm A` in the device's local timezone — zero-padded 12-hour clock,
+ * uppercase AM/PM (e.g. `09:30 PM`).
+ */
+export declare const formatTime12h: (value: DateInput) => string;
+/**
+ * `hh:mm a` (zero-padded 12-hour, lowercase am/pm) of the given instant as
+ * seen in `ianaTimeZone` (e.g. `Asia/Kolkata`) — not the device's own
+ * timezone. Reads the hour/minute/period through `Intl.DateTimeFormat`'s
+ * `formatToParts` rather than its assembled string, because the assembled
+ * string's spacing before AM/PM varies by JS engine (some insert a narrow
+ * no-break space, U+202F, instead of a plain space) and isn't reliably
+ * zero-padded either. Throws if `ianaTimeZone` isn't a timezone Intl
+ * recognises — the same failure mode as handing dayjs.tz() a bad zone name.
+ */
+export declare const formatTimeInZone: (value: DateInput, ianaTimeZone: string) => string;
+/**
+ * Same as {@link formatTimeInZone}, but for a .NET-style Windows timezone ID
+ * (e.g. `"India Standard Time"`) rather than an IANA one. .NET's own
+ * `TimeZoneInfo` API only knows Windows IDs, so a backend built on it hands
+ * these to clients directly — `Intl`, by contrast, only recognises IANA
+ * names, so the ID has to be translated before it can be used here. Throws
+ * if `windowsTimeZoneId` has no known IANA mapping.
+ */
+export declare const formatTimeInWindowsZone: (value: DateInput, windowsTimeZoneId: string) => string;
+//# sourceMappingURL=dateMath.d.ts.map

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

@@ -0,0 +1,10 @@
+export type { FormatCurrencyOptions } from './currency.js';
+export { formatCurrency } from './currency.js';
+export type { DateInput, DateStyle, TimeStyle } from './date.js';
+export { formatDate, formatDateTime, formatRelativeTime, formatTime } from './date.js';
+export { addDays, diffMs, formatDateDDMMMYYYY, formatDateISO, formatDatePattern, formatTime12h, formatTimeInWindowsZone, formatTimeInZone, isDateAfter, isDateBefore, isSameDay, startOfDay } from './dateMath.js';
+export { getInitials } from './initials.js';
+export { formatCompactNumber, formatNumber, formatPercent } from './number.js';
+export type { FormatPhoneOptions, PhoneCountry, PhoneCountryEntry, PhoneNumber, PhoneNumberType, PhoneParts, PhoneValidationKind } from './phone.js';
+export { AsYouType, clampNationalNumber, countryFlagEmoji, detectPhoneCountry, formatPhone, formatPhoneAsTyped, getCountries, getCountryCallingCode, getPhoneCountries, isSupportedCountry, isValidNationalNumber, isValidPhoneNumber, maxNationalNumberLength, normalizePhone, parsePhoneNumber, parsePhoneNumberFromString, splitPhoneNumber, validatePhoneNumberLength } from './phone.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * Returns up to `maxChars` uppercase initials from a name.
+ *
+ * @example
+ * getInitials('Navneet Singh')       // 'NS'
+ * getInitials('mary anne lee', 3)    // 'MAL'
+ * getInitials('navneet')             // 'NA'
+ * getInitials('  ')                  // ''
+ */
+export declare const getInitials: (name: string | null | undefined, maxChars?: number) => string;
+//# sourceMappingURL=initials.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * Locale-aware number formatter. Defaults to `'en-IN'` (Indian grouping).
+ */
+export declare const formatNumber: (value: number | null | undefined, fractionDigits?: number, locale?: string) => string;
+/**
+ * Format a 0–1 ratio (or 0–100 percent) as a percent string.
+ * Pass `asRatio: false` if your input is already on the 0–100 scale.
+ */
+export declare const formatPercent: (value: number | null | undefined, fractionDigits?: number, asRatio?: boolean, locale?: string) => string;
+/**
+ * Format a number compactly (1.2K, 3.4M, 1.5L, 2.3Cr).
+ * Defaults to Indian compact notation via `'en-IN'` locale (lakh / crore).
+ */
+export declare const formatCompactNumber: (value: number | null | undefined, locale?: string) => string;
+//# sourceMappingURL=number.d.ts.map