@webority-technologies/mobile 0.0.1

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

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { ViewStyle } from 'react-native';
+export interface NetworkStatusBannerProps {
+    /** Override the default offline message. */
+    message?: string;
+    /** Render at the top (default) or bottom of the screen. */
+    position?: 'top' | 'bottom';
+    /** Optional style override for the banner container. */
+    style?: ViewStyle;
+    /** Hide the banner entirely (useful for screens that handle offline themselves). */
+    disabled?: boolean;
+}
+/**
+ * A subtle animated banner that slides in when the device goes offline.
+ * Mount once near the app root (above your navigation tree).
+ */
+export declare const NetworkStatusBanner: React.FC<NetworkStatusBannerProps>;
+export default NetworkStatusBanner;
+//# sourceMappingURL=NetworkStatusBanner.d.ts.map

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

@@ -0,0 +1,5 @@
+export { useNetworkStatus, getNetworkStatus, addNetworkStatusListener } from './networkStatus';
+export type { NetworkStatus, NetworkConnectionType, NetworkStatusListener } from './networkStatus';
+export { NetworkStatusBanner } from './NetworkStatusBanner';
+export type { NetworkStatusBannerProps } from './NetworkStatusBanner';
+//# 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/theme/ThemeContext.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { ColorMode, Theme, ThemeOverrides } from './types';
+export type ColorSchemePreference = 'light' | 'dark' | 'system';
+export interface ThemeProviderProps {
+    children: React.ReactNode;
+    initialPreference?: ColorSchemePreference;
+    lightOverrides?: ThemeOverrides;
+    darkOverrides?: ThemeOverrides;
+}
+export declare const ThemeProvider: React.FC<ThemeProviderProps>;
+export declare const useTheme: () => Theme;
+export declare const useThemeMode: () => {
+    mode: ColorMode;
+    preference: ColorSchemePreference;
+    setPreference: (preference: ColorSchemePreference) => void;
+    toggleColorMode: () => void;
+};
+//# sourceMappingURL=ThemeContext.d.ts.map

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

@@ -0,0 +1,13 @@
+import type { ColorMode, Theme, ThemeOverrides } from './types';
+export declare const setTheme: (overrides: ThemeOverrides, mode?: ColorMode) => void;
+export declare const setColorMode: (mode: ColorMode) => void;
+export declare const getColorMode: () => ColorMode;
+export declare const getTheme: () => Theme;
+export declare const resetTheme: () => void;
+export declare const subscribeTheme: (callback: () => void) => (() => void);
+export { ThemeProvider, useTheme, useThemeMode } from './ThemeContext';
+export type { ThemeProviderProps, ColorSchemePreference } from './ThemeContext';
+export { lightTheme, darkTheme } from './tokens';
+export { mergeTheme } from './merge';
+export type { ColorMode, ColorPalette, RadiusScale, ShadowDefinition, ShadowScale, SpacingScale, Theme, ThemeOverrides, TypographyScale, MotionScale, DeepPartial } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/theme/merge.d.ts

@@ -0,0 +1,3 @@
+import type { Theme, ThemeOverrides } from './types';
+export declare const mergeTheme: (base: Theme, overrides: ThemeOverrides) => Theme;
+//# sourceMappingURL=merge.d.ts.map

package/lib/typescript/commonjs/theme/tokens.d.ts

@@ -0,0 +1,4 @@
+import type { Theme } from './types';
+export declare const lightTheme: Theme;
+export declare const darkTheme: Theme;
+//# sourceMappingURL=tokens.d.ts.map

package/lib/typescript/commonjs/theme/types.d.ts

@@ -0,0 +1,161 @@
+import type { TextStyle, ViewStyle } from 'react-native';
+export type ColorMode = 'light' | 'dark';
+export interface ColorPalette {
+    primary: string;
+    primaryHover: string;
+    primaryPressed: string;
+    primaryMuted: string;
+    secondary: string;
+    secondaryHover: string;
+    success: string;
+    warning: string;
+    error: string;
+    info: string;
+    text: {
+        primary: string;
+        secondary: string;
+        tertiary: string;
+        inverse: string;
+        disabled: string;
+        link: string;
+    };
+    background: {
+        primary: string;
+        secondary: string;
+        tertiary: string;
+        elevated: string;
+        overlay: string;
+        inverse: string;
+    };
+    border: {
+        primary: string;
+        secondary: string;
+        focus: string;
+        error: string;
+    };
+    surface: {
+        pressed: string;
+        hovered: string;
+        selected: string;
+        disabled: string;
+    };
+    skeleton: {
+        background: string;
+        highlight: string;
+    };
+}
+export interface TypographyScale {
+    fontSize: {
+        xs: number;
+        sm: number;
+        base: number;
+        lg: number;
+        xl: number;
+        '2xl': number;
+        '3xl': number;
+        '4xl': number;
+    };
+    fontWeight: {
+        normal: TextStyle['fontWeight'];
+        medium: TextStyle['fontWeight'];
+        semibold: TextStyle['fontWeight'];
+        bold: TextStyle['fontWeight'];
+    };
+    lineHeight: {
+        tight: number;
+        normal: number;
+        relaxed: number;
+    };
+    letterSpacing: {
+        tight: number;
+        normal: number;
+        wide: number;
+    };
+}
+export interface SpacingScale {
+    none: 0;
+    xxs: number;
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    '2xl': number;
+    '3xl': number;
+    '4xl': number;
+}
+export interface RadiusScale {
+    none: 0;
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    '2xl': number;
+    full: 9999;
+}
+export interface ShadowDefinition {
+    shadowColor: string;
+    shadowOffset: {
+        width: number;
+        height: number;
+    };
+    shadowOpacity: number;
+    shadowRadius: number;
+    elevation: number;
+}
+export interface ShadowScale {
+    none: ViewStyle;
+    xs: ShadowDefinition;
+    sm: ShadowDefinition;
+    md: ShadowDefinition;
+    lg: ShadowDefinition;
+    xl: ShadowDefinition;
+    '2xl': ShadowDefinition;
+}
+export interface MotionScale {
+    duration: {
+        instant: number;
+        fast: number;
+        normal: number;
+        slow: number;
+        slower: number;
+    };
+    easing: {
+        standard: readonly [number, number, number, number];
+        accelerate: readonly [number, number, number, number];
+        decelerate: readonly [number, number, number, number];
+        sharp: readonly [number, number, number, number];
+    };
+    spring: {
+        gentle: {
+            damping: number;
+            stiffness: number;
+            mass: number;
+        };
+        bouncy: {
+            damping: number;
+            stiffness: number;
+            mass: number;
+        };
+        snappy: {
+            damping: number;
+            stiffness: number;
+            mass: number;
+        };
+    };
+}
+export interface Theme {
+    mode: ColorMode;
+    colors: ColorPalette;
+    typography: TypographyScale;
+    spacing: SpacingScale;
+    radius: RadiusScale;
+    shadows: ShadowScale;
+    motion: MotionScale;
+}
+export type DeepPartial<T> = T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+export type ThemeOverrides = DeepPartial<Theme>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,3 @@
+export { ScreenDimensions, Breakpoints, isScreenSize, isTablet } from './responsive';
+export type { BreakpointKey } from './responsive';
+//# sourceMappingURL=dimensions.d.ts.map

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

@@ -0,0 +1,4 @@
+export type HapticType = 'selection' | 'impactLight' | 'impactMedium' | 'impactHeavy' | 'notificationSuccess' | 'notificationWarning' | 'notificationError';
+export declare const triggerHaptic: (type?: HapticType) => void;
+export declare const setHapticImplementation: (impl: ((type: HapticType) => void) | null) => void;
+//# sourceMappingURL=hapticUtils.d.ts.map

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

@@ -0,0 +1,15 @@
+export interface CompressImageOptions {
+    /** Max image width / height in pixels (preserves aspect ratio). Defaults to 1600. */
+    maxSize?: number;
+    /** JPEG/WebP quality, 0–1. Defaults to 0.7. */
+    quality?: number;
+    /** Output format. Defaults to `'jpg'`. */
+    output?: 'jpg' | 'png' | 'webp';
+}
+/**
+ * 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,10 @@
+export { ScreenDimensions, Breakpoints, Responsive, isScreenSize, isTablet } from './responsive';
+export type { BreakpointKey } from './responsive';
+export { Spacing, Padding, Margin } from './spacing';
+export type { SpacingToken } from './spacing';
+export { triggerHaptic, setHapticImplementation } from './hapticUtils';
+export type { HapticType } from './hapticUtils';
+export { shadowStyle } from './shadows';
+export { compressImage } from './imageCompression';
+export type { CompressImageOptions } from './imageCompression';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,23 @@
+export declare const ScreenDimensions: {
+    readonly width: number;
+    readonly height: number;
+    readonly pixelRatio: number;
+    readonly fontScale: number;
+};
+export declare const Breakpoints: {
+    readonly xs: 0;
+    readonly sm: 360;
+    readonly md: 414;
+    readonly lg: 768;
+    readonly xl: 1024;
+};
+export type BreakpointKey = keyof typeof Breakpoints;
+export declare const isScreenSize: (size: BreakpointKey) => boolean;
+export declare const isTablet: () => boolean;
+export declare const Responsive: {
+    readonly width: (size: number) => number;
+    readonly height: (size: number) => number;
+    readonly size: (size: number) => number;
+    readonly font: (size: number) => number;
+};
+//# sourceMappingURL=responsive.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { ViewStyle } from 'react-native';
+import type { ShadowScale } from '../theme/types';
+export declare const shadowStyle: (shadows: ShadowScale, level: keyof ShadowScale) => ViewStyle;
+//# sourceMappingURL=shadows.d.ts.map

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

@@ -0,0 +1,61 @@
+import type { SpacingScale } from '../theme/types';
+export type SpacingToken = keyof SpacingScale;
+export declare const Spacing: {
+    readonly none: 0;
+    readonly xxs: number;
+    readonly xs: number;
+    readonly sm: number;
+    readonly md: number;
+    readonly lg: number;
+    readonly xl: number;
+    readonly '2xl': number;
+    readonly '3xl': number;
+    readonly '4xl': number;
+};
+export declare const Padding: {
+    readonly all: (token: SpacingToken) => {
+        padding: number;
+    };
+    readonly horizontal: (token: SpacingToken) => {
+        paddingHorizontal: number;
+    };
+    readonly vertical: (token: SpacingToken) => {
+        paddingVertical: number;
+    };
+    readonly top: (token: SpacingToken) => {
+        paddingTop: number;
+    };
+    readonly bottom: (token: SpacingToken) => {
+        paddingBottom: number;
+    };
+    readonly left: (token: SpacingToken) => {
+        paddingLeft: number;
+    };
+    readonly right: (token: SpacingToken) => {
+        paddingRight: number;
+    };
+};
+export declare const Margin: {
+    readonly all: (token: SpacingToken) => {
+        margin: number;
+    };
+    readonly horizontal: (token: SpacingToken) => {
+        marginHorizontal: number;
+    };
+    readonly vertical: (token: SpacingToken) => {
+        marginVertical: number;
+    };
+    readonly top: (token: SpacingToken) => {
+        marginTop: number;
+    };
+    readonly bottom: (token: SpacingToken) => {
+        marginBottom: number;
+    };
+    readonly left: (token: SpacingToken) => {
+        marginLeft: number;
+    };
+    readonly right: (token: SpacingToken) => {
+        marginRight: number;
+    };
+};
+//# sourceMappingURL=spacing.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,59 @@
+import { type Environment } from '../config';
+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;
+//# 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,18 @@
+import { type AxiosInstance } from 'axios';
+import type { AuthActions } from '../initUserAuth';
+/**
+ * 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

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

@@ -0,0 +1,20 @@
+/**
+ * Token data persisted in the keychain.
+ */
+export interface StoredToken {
+    token: string;
+    expiry: string;
+}
+/**
+ * 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>;
+//# sourceMappingURL=authStore.d.ts.map

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

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