@webority-technologies/mobile-core 0.0.1

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

@@ -0,0 +1,49 @@
+/**
+ * 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;
+}
+/**
+ * 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/commonjs/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/commonjs/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/commonjs/formatters/index.d.ts

@@ -0,0 +1,8 @@
+export type { FormatCurrencyOptions } from './currency';
+export { formatCurrency } from './currency';
+export type { DateInput, DateStyle, TimeStyle } from './date';
+export { formatDate, formatDateTime, formatRelativeTime, formatTime } from './date';
+export { getInitials } from './initials';
+export { formatCompactNumber, formatNumber, formatPercent } from './number';
+export { formatPhone, normalizePhone } from './phone';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/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/commonjs/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

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

@@ -0,0 +1,13 @@
+/**
+ * Strip everything except digits and a leading `+` (preserved if present).
+ */
+export declare const normalizePhone: (input: string) => string;
+/**
+ * Format a phone number for human display.
+ *
+ * - Indian mobile (10 digits) → `XXXXX XXXXX`
+ * - With `+91` country code → `+91 XXXXX XXXXX`
+ * - Other inputs are returned as `+CC NNNN NNNN…` best-effort grouping.
+ */
+export declare const formatPhone: (input: string, defaultCountryCode?: string) => string;
+//# sourceMappingURL=phone.d.ts.map

package/lib/typescript/commonjs/index.d.ts

@@ -0,0 +1,30 @@
+export { default as publicClient } from './api/publicClient';
+export type { RefreshableStore, SessionTerminationCode } from './api/userClient';
+export { default as userClient, injectAuthActions, injectStore, RequestOfflineError, SESSION_TERMINATION_CODES } from './api/userClient';
+export type { KeychainLike, StoredToken } from './auth/authStore';
+export { getToken, removeToken, setKeychainImplementation, storeToken } from './auth/authStore';
+export type { JwtClaims } from './auth/jwt';
+export { decodeJWT, getJWTExpiry, isJWTExpired } from './auth/jwt';
+export type { Config, Environment, LogLevel } from './config';
+export { getConfig, getConfigValue, resetConfig, setConfig } from './config';
+export type { DateInput, DateStyle, FormatCurrencyOptions, TimeStyle } from './formatters';
+export { formatCompactNumber, formatCurrency, formatDate, formatDateTime, formatNumber, formatPercent, formatPhone, formatRelativeTime, formatTime, getInitials, normalizePhone } from './formatters';
+export type { InitConfig } from './initSDK';
+export { initWebority } from './initSDK';
+export type { AuthActions } from './initUserAuth';
+export { initUserAuth } from './initUserAuth';
+export type { LoggerType, RemoteLogger } from './logger';
+export { Logger, setRemoteLogger } from './logger';
+export type { NetworkConnectionType, NetworkStatus, NetworkStatusListener } from './network';
+export { addNetworkStatusListener, getNetworkStatus, useNetworkStatus } from './network';
+export type { PermissionKind, PermissionStatus } from './permissions';
+export { Permissions } from './permissions';
+export type { AsyncStorageLike, StorageApi } from './storage';
+export { Storage, setStorageImplementation } from './storage';
+export type { CompressImageOptions } from './utils';
+export { compressImage } from './utils';
+export type { PasswordRules } from './validators';
+export { isAadhaar, isAlphanumeric, isBetween, isEmail, isGstin, isHexColor, isIfsc, isIndianMobile, isIndianPincode, isInteger, isNonEmpty, isNumeric, isPan, isPhone, isStrongPassword, isUrl, maxLength, minLength } from './validators';
+export type { DeviceInfoLike, ParsedVersion, Platform, UpdateInfo, UpdateType, VersionCheckResult, VersionCheckType, VersionComparison, VersionData } from './versionCheck';
+export { setDeviceInfoImplementation, useVersionCheck, VersionCheck } from './versionCheck';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,40 @@
+/**
+ * Simple initialization API for Webority packages
+ * One function to configure everything needed
+ */
+import { type Environment, type LogLevel } from './config';
+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;
+}
+/**
+ * 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/commonjs/initUserAuth.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Simple initialization API for Webority User package
+ * Easy setup for Redux integration
+ */
+/**
+ * Auth action creators required by the user package.
+ */
+export interface AuthActions {
+    logout: () => unknown;
+    refreshToken: () => unknown;
+}
+/**
+ * Initialize user package with Redux store and auth actions.
+ *
+ * @example
+ * import store from './store';
+ * import { logout, refreshToken } from './actions/authActions';
+ *
+ * initUserAuth(store, { logout, refreshToken });
+ */
+export declare const initUserAuth: <S>(store: S, authActions: AuthActions) => void;
+//# sourceMappingURL=initUserAuth.d.ts.map

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

@@ -0,0 +1,42 @@
+import { type LogLevel } from '../config';
+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;
+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;
+}
+export declare const Logger: LoggerType;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

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

package/lib/typescript/commonjs/network/networkStatus.d.ts

@@ -0,0 +1,27 @@
+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;
+/**
+ * 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;
+//# sourceMappingURL=networkStatus.d.ts.map

package/lib/typescript/commonjs/package.json

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

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

@@ -0,0 +1,20 @@
+export type PermissionKind = 'camera' | 'microphone' | 'photos' | 'photosAdd' | 'mediaLibrary' | 'location' | 'locationAlways' | 'contacts' | 'calendar' | 'reminders' | 'notifications' | 'bluetooth' | 'storage';
+export type PermissionStatus = 'unavailable' | 'denied' | 'limited' | 'granted' | 'blocked';
+/**
+ * Cross-platform permissions wrapper. Maps an abstract `PermissionKind`
+ * (camera, photos, location, notifications, …) to the right
+ * iOS / Android permission string under the hood.
+ *
+ * Requires `react-native-permissions` as an optional peer dependency;
+ * when missing, every check/request resolves to `'unavailable'`.
+ */
+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>;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,42 @@
+/**
+ * Minimal AsyncStorage shape we depend on.
+ * Lets us avoid a hard import on `@react-native-async-storage/async-storage`.
+ */
+interface AsyncStorageLike {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: 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>;
+    clear?: () => Promise<void>;
+    getAllKeys?: () => Promise<readonly string[]>;
+}
+/**
+ * Inject a custom storage backend (e.g. MMKV adapter) at runtime.
+ * Pass `null` to reset to the default AsyncStorage backend.
+ */
+export declare const setStorageImplementation: (impl: AsyncStorageLike | null) => void;
+export interface StorageApi {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<boolean>;
+    removeItem: (key: string) => Promise<boolean>;
+    getJson: <T>(key: string) => Promise<T | null>;
+    setJson: <T>(key: string, value: T) => Promise<boolean>;
+    multiGet: (keys: readonly string[]) => Promise<Record<string, string | null>>;
+    multiSet: (entries: Record<string, string>) => Promise<boolean>;
+    multiRemove: (keys: readonly string[]) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    getAllKeys: () => Promise<string[]>;
+}
+/**
+ * Typed AsyncStorage wrapper with safe JSON helpers.
+ * 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;
+ * override with `setStorageImplementation()` for MMKV or custom adapters.
+ */
+export declare const Storage: StorageApi;
+export type { AsyncStorageLike };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,31 @@
+export interface CompressImageOptions {
+    /** Max image width / height in pixels (preserves aspect ratio). Defaults to 1500. */
+    maxSize?: number;
+    /**
+     * JPEG/WebP quality, 0–1. Overrides the size-based quality ladder when set.
+     * When omitted, quality is derived from `fileSize` (see `qualityForFileSize`).
+     */
+    quality?: number;
+    /** Output format. Defaults to `'jpg'`. */
+    output?: 'jpg' | 'png' | 'webp';
+    /**
+     * Size of the source file in bytes, if known. Callers usually already have
+     * this from the picker response (e.g. `fileSize` on the selected asset) —
+     * pass it through rather than re-deriving it. Drives the adaptive quality
+     * ladder; when omitted, quality falls back to the middle rung.
+     */
+    fileSize?: number;
+}
+/**
+ * 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
+ * back to the middle rung rather than assuming either extreme.
+ */
+export declare const qualityForFileSize: (fileSize?: number) => number;
+/**
+ * Compress an image referenced by a URI. Returns a new URI on success, or the
+ * original URI on failure / when the optional `react-native-compressor`
+ * dependency is missing — so callers can rely on always getting a usable URI.
+ */
+export declare const compressImage: (uri: string, options?: CompressImageOptions) => Promise<string>;
+//# sourceMappingURL=imageCompression.d.ts.map

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

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

package/lib/typescript/commonjs/validators/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generic validators returning `boolean`. All accept `null`/`undefined` safely.
+ *
+ * Tradeoff: regexes are pragmatic, not RFC-strict. They reject the things real users
+ * typo and accept the long tail of legitimate inputs. For RFC-grade validation use
+ * a dedicated library at the boundary.
+ */
+export declare const isNonEmpty: (value: unknown) => boolean;
+export declare const isEmail: (value: unknown) => boolean;
+/**
+ * Validate an Indian mobile number. Accepts:
+ * - 10-digit number starting with 6-9
+ * - Optional `+91` or `91` country code prefix
+ */
+export declare const isIndianMobile: (value: unknown) => boolean;
+/**
+ * Generic phone validator: 7–15 digits, optional `+` prefix.
+ * Use `isIndianMobile` when you specifically need an Indian mobile number.
+ */
+export declare const isPhone: (value: unknown) => boolean;
+export declare const isUrl: (value: unknown) => boolean;
+export declare const isNumeric: (value: unknown) => boolean;
+export declare const isInteger: (value: unknown) => boolean;
+export declare const isAlphanumeric: (value: unknown) => boolean;
+export interface PasswordRules {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumber?: boolean;
+    requireSymbol?: boolean;
+}
+/**
+ * Common password complexity check. Defaults to 8+ chars,
+ * one uppercase, one lowercase, one digit.
+ */
+export declare const isStrongPassword: (value: unknown, rules?: PasswordRules) => boolean;
+export declare const isIndianPincode: (value: unknown) => boolean;
+export declare const isPan: (value: unknown) => boolean;
+export declare const isGstin: (value: unknown) => boolean;
+export declare const isAadhaar: (value: unknown) => boolean;
+export declare const isIfsc: (value: unknown) => boolean;
+export declare const isHexColor: (value: unknown) => boolean;
+export declare const isBetween: (value: unknown, min: number, max: number, inclusive?: boolean) => boolean;
+export declare const minLength: (value: unknown, length: number) => boolean;
+export declare const maxLength: (value: unknown, length: number) => boolean;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/versionCheck/index.d.ts

@@ -0,0 +1,80 @@
+import { type Environment } from '../config';
+/**
+ * Minimal device-info shape we depend on.
+ *
+ * This is a LAST RESORT, not the primary path. `Platform.OS` already gives the
+ * platform, and every Webority app carries its own store id and version in
+ * `appsettings.Compiled.json` — so `setConfig({ appId, appVersion })` covers
+ * both remaining values without a native module. The injector below exists for
+ * apps that would rather hand us a `react-native-device-info` instance than
+ * wire two config keys.
+ */
+interface DeviceInfoLike {
+    getBundleId: () => string;
+    getVersion: () => string;
+}
+/**
+ * Supply the app identity from a native module instead of config.
+ * Prefer `setConfig({ appId, appVersion })` — it needs no native dependency.
+ * Pass `null` to clear.
+ */
+export declare const setDeviceInfoImplementation: (impl: DeviceInfoLike | null) => void;
+export type Platform = 'ios' | 'android' | string;
+export type UpdateType = 'major' | 'minor' | 'patch' | 'prerelease' | null;
+export interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string;
+}
+export interface VersionData {
+    version: string | null;
+    released?: string | null;
+    releasedAt?: string;
+    notes: string;
+    url: string | null;
+    country?: string;
+    lastChecked: string;
+}
+export interface VersionComparison {
+    needsUpdate: boolean;
+    updateType: UpdateType;
+    notice?: string;
+}
+export interface VersionCheckResult {
+    isNewVersionAvailable: boolean;
+    updateType: UpdateType;
+    url: string | null;
+}
+export interface UpdateInfo {
+    isUpdateRequired: boolean;
+    updateUrl: string | null;
+}
+export interface VersionCheckType {
+    /**
+     * Check if a new version is available.
+     * Includes retry logic and proper error handling.
+     */
+    isNewVersionAvailable: () => Promise<VersionCheckResult>;
+    /**
+     * Opens the appropriate store URL to update the app.
+     * Uses the provided URL or falls back to direct store URLs.
+     */
+    openUpdateUrl: (url?: string | null) => Promise<boolean>;
+    /**
+     * Get the fallback store URL.
+     * Useful when URL from version check fails.
+     */
+    getFallbackStoreUrl: () => string;
+}
+export declare const VersionCheck: VersionCheckType;
+/**
+ * Custom hook to check for required app updates.
+ *
+ * @param isAppReady - Whether the app is ready to perform the check
+ * @param environment - The app environment (defaults to the one in config)
+ */
+export declare const useVersionCheck: (isAppReady: boolean, environment?: Environment) => UpdateInfo;
+export default VersionCheck;
+export type { DeviceInfoLike };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+import { type AxiosInstance } from 'axios';
+/**
+ * Public Axios Client
+ * - Base URL: Set your public API base URL.
+ * - No Authorization header is attached.
+ * - Includes timeout configuration and error handling.
+ * - Handles specific HTTP status codes.
+ */
+declare const publicClient: AxiosInstance;
+export default publicClient;
+//# sourceMappingURL=publicClient.d.ts.map

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

@@ -0,0 +1,49 @@
+import { type AxiosInstance } from 'axios';
+import type { AuthActions } from '../initUserAuth.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";
+/**
+ * Minimal Redux-store shape required by the user client to dispatch
+ * refresh-token / logout actions.
+ */
+export interface RefreshableStore {
+    dispatch: (action: unknown) => Promise<{
+        error?: {
+            message?: string;
+        };
+    }>;
+}
+declare const userClient: AxiosInstance;
+export declare const injectStore: <S>(_store: S) => void;
+export declare const injectAuthActions: (actions: AuthActions) => void;
+export default userClient;
+//# sourceMappingURL=userClient.d.ts.map