@cranberry-money/shared-services 1.0.0

package/dist/auth/AuthManager.js

@@ -0,0 +1,223 @@
+/**
+ * Cross-platform Authentication Manager
+ *
+ * Centralizes authentication logic and state management across web and mobile platforms.
+ * Handles token storage, automatic refresh, and authentication state persistence.
+ */
+import { AuthService } from '../services/AuthService';
+export class AuthManager {
+    constructor(config) {
+        this.currentState = {
+            isAuthenticated: false,
+            isLoading: false,
+            user: null,
+            error: null,
+        };
+        this.apiClient = config.apiClient;
+        this.tokenStorage = config.tokenStorage;
+        this.authService = new AuthService(config.apiClient);
+        this.onAuthStateChange = config.onAuthStateChange;
+        this.autoRefreshEnabled = config.autoRefreshEnabled ?? true;
+        // Set token storage on API client
+        this.apiClient.setTokenStorage(this.tokenStorage);
+    }
+    /**
+     * Get current authentication state
+     */
+    getState() {
+        return { ...this.currentState };
+    }
+    /**
+     * Initialize authentication manager
+     * Checks for existing tokens and validates authentication state
+     */
+    async initialize() {
+        this.updateState({ isLoading: true, error: null });
+        try {
+            const hasTokens = await this.tokenStorage.hasTokens();
+            if (!hasTokens) {
+                this.updateState({
+                    isAuthenticated: false,
+                    isLoading: false,
+                    user: null
+                });
+                return this.currentState;
+            }
+            // Validate tokens by fetching user profile
+            const user = await this.authService.getProfile();
+            this.updateState({
+                isAuthenticated: true,
+                isLoading: false,
+                user,
+                error: null,
+            });
+            // Start auto-refresh if enabled
+            if (this.autoRefreshEnabled) {
+                this.startAutoRefresh();
+            }
+        }
+        catch (error) {
+            // Tokens are invalid, clear them
+            await this.tokenStorage.clearTokens();
+            this.updateState({
+                isAuthenticated: false,
+                isLoading: false,
+                user: null,
+                error: error instanceof Error ? error.message : 'Authentication failed',
+            });
+        }
+        return this.currentState;
+    }
+    /**
+     * Sign in user with credentials
+     */
+    async signin(credentials) {
+        this.updateState({ isLoading: true, error: null });
+        try {
+            const response = await this.authService.signin(credentials);
+            // Store tokens if provided in response (mobile)
+            if (response && typeof response === 'object' && 'access' in response && 'refresh' in response) {
+                await this.tokenStorage.storeTokens(response);
+            }
+            // Fetch user profile
+            const user = await this.authService.getProfile();
+            this.updateState({
+                isAuthenticated: true,
+                isLoading: false,
+                user,
+                error: null,
+            });
+            // Start auto-refresh if enabled
+            if (this.autoRefreshEnabled) {
+                this.startAutoRefresh();
+            }
+        }
+        catch (error) {
+            this.updateState({
+                isAuthenticated: false,
+                isLoading: false,
+                user: null,
+                error: error instanceof Error ? error.message : 'Sign in failed',
+            });
+        }
+        return this.currentState;
+    }
+    /**
+     * Sign out user
+     */
+    async signout() {
+        this.updateState({ isLoading: true, error: null });
+        try {
+            // Call sign out endpoint
+            await this.authService.signout();
+        }
+        catch (error) {
+            // Log error but continue with local cleanup
+            console.warn('Sign out API call failed:', error);
+        }
+        // Always clear local state regardless of API call result
+        await this.tokenStorage.clearTokens();
+        this.stopAutoRefresh();
+        this.updateState({
+            isAuthenticated: false,
+            isLoading: false,
+            user: null,
+            error: null,
+        });
+        return this.currentState;
+    }
+    /**
+     * Sign up new user
+     */
+    async signup(userData) {
+        this.updateState({ isLoading: true, error: null });
+        try {
+            await this.authService.signup(userData);
+            this.updateState({ isLoading: false, error: null });
+            return { success: true };
+        }
+        catch (error) {
+            this.updateState({
+                isLoading: false,
+                error: error instanceof Error ? error.message : 'Sign up failed',
+            });
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Sign up failed'
+            };
+        }
+    }
+    /**
+     * Refresh authentication tokens
+     */
+    async refreshTokens() {
+        try {
+            const tokens = await this.tokenStorage.retrieveTokens();
+            if (!tokens?.refresh) {
+                return false;
+            }
+            const newTokens = await this.authService.refreshToken({ refresh: tokens.refresh });
+            await this.tokenStorage.storeTokens(newTokens);
+            return true;
+        }
+        catch (error) {
+            console.error('Token refresh failed:', error);
+            // Clear invalid tokens
+            await this.tokenStorage.clearTokens();
+            this.updateState({
+                isAuthenticated: false,
+                user: null,
+                error: 'Session expired',
+            });
+            return false;
+        }
+    }
+    /**
+     * Update user profile in state
+     */
+    async refreshProfile() {
+        if (!this.currentState.isAuthenticated)
+            return;
+        try {
+            const user = await this.authService.getProfile();
+            this.updateState({ user });
+        }
+        catch (error) {
+            console.error('Profile refresh failed:', error);
+        }
+    }
+    /**
+     * Start automatic token refresh
+     */
+    startAutoRefresh() {
+        this.stopAutoRefresh();
+        // Check every 5 minutes
+        this.refreshTimer = setInterval(async () => {
+            if (this.currentState.isAuthenticated) {
+                await this.refreshTokens();
+            }
+        }, 5 * 60 * 1000);
+    }
+    /**
+     * Stop automatic token refresh
+     */
+    stopAutoRefresh() {
+        if (this.refreshTimer) {
+            clearInterval(this.refreshTimer);
+            this.refreshTimer = undefined;
+        }
+    }
+    /**
+     * Update authentication state and notify listeners
+     */
+    updateState(updates) {
+        this.currentState = { ...this.currentState, ...updates };
+        this.onAuthStateChange?.(this.currentState);
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        this.stopAutoRefresh();
+    }
+}

package/dist/auth/createAuthManager.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Factory functions to create platform-specific AuthManager instances
+ *
+ * Provides convenient setup for web and mobile authentication with
+ * appropriate API clients and token storage implementations.
+ */
+import { AuthManager, type AuthManagerConfig } from './AuthManager';
+import { type SecureStoreInterface } from '../adapters/MobileTokenStorage';
+export interface WebAuthManagerConfig {
+    apiBaseUrl: string;
+    onAuthStateChange?: AuthManagerConfig['onAuthStateChange'];
+    autoRefreshEnabled?: boolean;
+    apiTimeout?: number;
+}
+export interface MobileAuthManagerConfig {
+    apiBaseUrl: string;
+    secureStore: SecureStoreInterface;
+    onAuthStateChange?: AuthManagerConfig['onAuthStateChange'];
+    autoRefreshEnabled?: boolean;
+    retryAttempts?: number;
+    offlineQueueEnabled?: boolean;
+    apiTimeout?: number;
+}
+/**
+ * Create AuthManager for web applications
+ * Uses cookie-based authentication with fetch API
+ */
+export declare function createWebAuthManager(config: WebAuthManagerConfig): AuthManager;
+/**
+ * Create AuthManager for mobile applications
+ * Uses secure storage with token-based authentication
+ */
+export declare function createMobileAuthManager(config: MobileAuthManagerConfig): AuthManager;
+/**
+ * Create Expo-specific AuthManager
+ * Convenience function for Expo applications using SecureStore
+ */
+export declare function createExpoAuthManager(config: Omit<MobileAuthManagerConfig, 'secureStore'> & {
+    expoSecureStore: SecureStoreInterface;
+}): AuthManager;
+/**
+ * AuthManager factory for different platforms
+ */
+export declare const authManagerFactory: {
+    readonly web: typeof createWebAuthManager;
+    readonly mobile: typeof createMobileAuthManager;
+    readonly expo: typeof createExpoAuthManager;
+};
+/**
+ * Platform detection utility
+ */
+export declare function detectPlatform(): 'web' | 'mobile';
+/**
+ * Auto-create AuthManager based on platform
+ */
+export declare function createAuthManagerForPlatform(config: {
+    apiBaseUrl: string;
+    onAuthStateChange?: AuthManagerConfig['onAuthStateChange'];
+    secureStore?: SecureStoreInterface;
+    retryAttempts?: number;
+    offlineQueueEnabled?: boolean;
+}): AuthManager;
+//# sourceMappingURL=createAuthManager.d.ts.map

package/dist/auth/createAuthManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAuthManager.d.ts","sourceRoot":"","sources":["../../src/auth/createAuthManager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIpE,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAE/F,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC;IAC3D,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,oBAAoB,CAAC;IAClC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC;IAC3D,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,WAAW,CAe9E;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,uBAAuB,GAAG,WAAW,CAgBpF;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,IAAI,CAAC,uBAAuB,EAAE,aAAa,CAAC,GAAG;IACrD,eAAe,EAAE,oBAAoB,CAAC;CACvC,GACA,WAAW,CAKb;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;CAIrB,CAAC;AAEX;;GAEG;AACH,wBAAgB,cAAc,IAAI,KAAK,GAAG,QAAQ,CAajD;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC;IAE3D,WAAW,CAAC,EAAE,oBAAoB,CAAC;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,GAAG,WAAW,CAqBd"}

package/dist/auth/createAuthManager.js

@@ -0,0 +1,103 @@
+/**
+ * Factory functions to create platform-specific AuthManager instances
+ *
+ * Provides convenient setup for web and mobile authentication with
+ * appropriate API clients and token storage implementations.
+ */
+import { AuthManager } from './AuthManager';
+import { WebApiClient } from '../adapters/WebApiClient';
+import { WebTokenStorage } from '../adapters/WebTokenStorage';
+import { MobileApiClient } from '../adapters/MobileApiClient';
+import { MobileTokenStorage } from '../adapters/MobileTokenStorage';
+/**
+ * Create AuthManager for web applications
+ * Uses cookie-based authentication with fetch API
+ */
+export function createWebAuthManager(config) {
+    const apiClient = new WebApiClient({
+        baseURL: config.apiBaseUrl,
+        withCredentials: true, // Enable cookies
+        timeout: config.apiTimeout || 30000,
+    });
+    const tokenStorage = new WebTokenStorage();
+    return new AuthManager({
+        apiClient,
+        tokenStorage,
+        onAuthStateChange: config.onAuthStateChange,
+        autoRefreshEnabled: config.autoRefreshEnabled ?? true,
+    });
+}
+/**
+ * Create AuthManager for mobile applications
+ * Uses secure storage with token-based authentication
+ */
+export function createMobileAuthManager(config) {
+    const apiClient = new MobileApiClient({
+        baseURL: config.apiBaseUrl,
+        timeout: config.apiTimeout || 30000,
+        retryAttempts: config.retryAttempts || 3,
+        offlineQueueEnabled: config.offlineQueueEnabled ?? true,
+    });
+    const tokenStorage = new MobileTokenStorage(config.secureStore);
+    return new AuthManager({
+        apiClient,
+        tokenStorage,
+        onAuthStateChange: config.onAuthStateChange,
+        autoRefreshEnabled: config.autoRefreshEnabled ?? true,
+    });
+}
+/**
+ * Create Expo-specific AuthManager
+ * Convenience function for Expo applications using SecureStore
+ */
+export function createExpoAuthManager(config) {
+    return createMobileAuthManager({
+        ...config,
+        secureStore: config.expoSecureStore,
+    });
+}
+/**
+ * AuthManager factory for different platforms
+ */
+export const authManagerFactory = {
+    web: createWebAuthManager,
+    mobile: createMobileAuthManager,
+    expo: createExpoAuthManager,
+};
+/**
+ * Platform detection utility
+ */
+export function detectPlatform() {
+    // Simple platform detection
+    if (typeof window !== 'undefined' && window.document) {
+        return 'web';
+    }
+    // Check for React Native environment
+    if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+        return 'mobile';
+    }
+    // Default to web for SSR environments
+    return 'web';
+}
+/**
+ * Auto-create AuthManager based on platform
+ */
+export function createAuthManagerForPlatform(config) {
+    const platform = detectPlatform();
+    if (platform === 'mobile') {
+        if (!config.secureStore) {
+            throw new Error('SecureStore is required for mobile platform');
+        }
+        return createMobileAuthManager({
+            apiBaseUrl: config.apiBaseUrl,
+            secureStore: config.secureStore,
+            onAuthStateChange: config.onAuthStateChange,
+            retryAttempts: config.retryAttempts,
+            offlineQueueEnabled: config.offlineQueueEnabled,
+        });
+    }
+    return createWebAuthManager({
+        apiBaseUrl: config.apiBaseUrl,
+        onAuthStateChange: config.onAuthStateChange,
+    });
+}

package/dist/auth/useAuthManager.d.ts

@@ -0,0 +1,66 @@
+/**
+ * React hook for AuthManager integration
+ *
+ * Provides a React-friendly interface to the AuthManager with
+ * automatic state synchronization and React Query integration.
+ */
+import React from 'react';
+import type { AuthManager, AuthState } from './AuthManager';
+import type { SigninPayload, SignupPayload } from '../services/AuthService';
+export interface UseAuthManagerOptions {
+    authManager: AuthManager;
+    enableQueryInvalidation?: boolean;
+}
+export declare function useAuthManager({ authManager, enableQueryInvalidation }: UseAuthManagerOptions): {
+    getState: () => AuthState;
+    clearError: () => void;
+    signin: (credentials: SigninPayload) => Promise<AuthState>;
+    signout: () => Promise<AuthState>;
+    signup: (userData: SignupPayload) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    refreshTokens: () => Promise<boolean>;
+    refreshProfile: () => Promise<void>;
+    isSignedIn: boolean;
+    isSignedOut: boolean;
+    hasUser: boolean;
+    hasError: boolean;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    user: import("..").UserProfile | null;
+    error: string | null;
+};
+/**
+ * Higher-order component for AuthManager integration
+ */
+export declare function withAuthManager<P extends object>(Component: React.ComponentType<P & {
+    authManager: ReturnType<typeof useAuthManager>;
+}>, authManager: AuthManager): (props: P) => import("react/jsx-runtime").JSX.Element;
+export declare function AuthManagerProvider({ children, authManager }: {
+    children: React.ReactNode;
+    authManager: AuthManager;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useAuthManagerContext(options?: {
+    enableQueryInvalidation?: boolean;
+}): {
+    getState: () => AuthState;
+    clearError: () => void;
+    signin: (credentials: SigninPayload) => Promise<AuthState>;
+    signout: () => Promise<AuthState>;
+    signup: (userData: SignupPayload) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    refreshTokens: () => Promise<boolean>;
+    refreshProfile: () => Promise<void>;
+    isSignedIn: boolean;
+    isSignedOut: boolean;
+    hasUser: boolean;
+    hasError: boolean;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    user: import("..").UserProfile | null;
+    error: string | null;
+};
+//# sourceMappingURL=useAuthManager.d.ts.map

package/dist/auth/useAuthManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuthManager.d.ts","sourceRoot":"","sources":["../../src/auth/useAuthManager.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAA+E,MAAM,OAAO,CAAC;AAEpG,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAG5E,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,WAAW,CAAC;IACzB,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED,wBAAgB,cAAc,CAAC,EAAE,WAAW,EAAE,uBAA8B,EAAE,EAAE,qBAAqB;;;0BA4DrE,aAAa;;uBAYhB,aAAa;;;;;;;;;;;;;;EAsCzC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAC9C,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,GAAG;IAAE,WAAW,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAA;CAAE,CAAC,EACtF,WAAW,EAAE,WAAW,IAEW,OAAO,CAAC,6CAK5C;AAOD,wBAAgB,mBAAmB,CAAC,EAClC,QAAQ,EACR,WAAW,EACZ,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,WAAW,EAAE,WAAW,CAAC;CAC1B,2CAMA;AAED,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAAE,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAAE;;;0BArFrD,aAAa;;uBAYhB,aAAa;;;;;;;;;;;;;;EAoFzC"}

package/dist/auth/useAuthManager.js

@@ -0,0 +1,133 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * React hook for AuthManager integration
+ *
+ * Provides a React-friendly interface to the AuthManager with
+ * automatic state synchronization and React Query integration.
+ */
+import { useEffect, useState, useCallback, useMemo, createContext, useContext } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { queryKeys } from '../query/QueryClient';
+export function useAuthManager({ authManager, enableQueryInvalidation = true }) {
+    const queryClient = useQueryClient();
+    const [authState, setAuthState] = useState(() => authManager.getState());
+    // Initialize auth manager on mount
+    useEffect(() => {
+        let mounted = true;
+        const initialize = async () => {
+            try {
+                await authManager.initialize();
+                if (mounted) {
+                    setAuthState(authManager.getState());
+                }
+            }
+            catch (error) {
+                console.error('AuthManager initialization failed:', error);
+            }
+        };
+        initialize();
+        return () => {
+            mounted = false;
+        };
+    }, [authManager]);
+    // Subscribe to auth state changes
+    useEffect(() => {
+        const unsubscribe = (newState) => {
+            setAuthState(newState);
+            // Invalidate auth-related queries when authentication state changes
+            if (enableQueryInvalidation) {
+                if (newState.isAuthenticated && !authState.isAuthenticated) {
+                    // User signed in - invalidate all queries to refresh data
+                    queryClient.invalidateQueries();
+                }
+                else if (!newState.isAuthenticated && authState.isAuthenticated) {
+                    // User signed out - clear all queries
+                    queryClient.clear();
+                }
+                else if (newState.user && newState.user !== authState.user) {
+                    // User profile changed - invalidate auth queries
+                    queryClient.invalidateQueries({ queryKey: queryKeys.auth.profile() });
+                }
+            }
+        };
+        // Set up state change listener
+        const originalOnChange = authManager['onAuthStateChange'];
+        authManager['onAuthStateChange'] = (state) => {
+            unsubscribe(state);
+            originalOnChange?.(state);
+        };
+        return () => {
+            authManager['onAuthStateChange'] = originalOnChange;
+        };
+    }, [authManager, authState, queryClient, enableQueryInvalidation]);
+    // Memoized action functions
+    const actions = useMemo(() => ({
+        signin: async (credentials) => {
+            const result = await authManager.signin(credentials);
+            setAuthState(result);
+            return result;
+        },
+        signout: async () => {
+            const result = await authManager.signout();
+            setAuthState(result);
+            return result;
+        },
+        signup: async (userData) => {
+            return authManager.signup(userData);
+        },
+        refreshTokens: async () => {
+            return authManager.refreshTokens();
+        },
+        refreshProfile: async () => {
+            await authManager.refreshProfile();
+            setAuthState(authManager.getState());
+        },
+    }), [authManager]);
+    // Convenience getters
+    const derived = useMemo(() => ({
+        isSignedIn: authState.isAuthenticated,
+        isSignedOut: !authState.isAuthenticated && !authState.isLoading,
+        hasUser: !!authState.user,
+        hasError: !!authState.error,
+    }), [authState]);
+    return {
+        // State
+        ...authState,
+        ...derived,
+        // Actions
+        ...actions,
+        // Utilities
+        getState: useCallback(() => authManager.getState(), [authManager]),
+        clearError: useCallback(() => {
+            if (authState.error) {
+                setAuthState((prev) => ({ ...prev, error: null }));
+            }
+        }, [authState.error]),
+    };
+}
+/**
+ * Higher-order component for AuthManager integration
+ */
+export function withAuthManager(Component, authManager) {
+    return function AuthManagerWrapper(props) {
+        const authManagerHook = useAuthManager({ authManager });
+        return _jsx(Component, { ...props, authManager: authManagerHook });
+    };
+}
+/**
+ * Context provider for AuthManager (optional pattern)
+ */
+const AuthManagerContext = createContext(null);
+export function AuthManagerProvider({ children, authManager }) {
+    return (_jsx(AuthManagerContext.Provider, { value: authManager, children: children }));
+}
+export function useAuthManagerContext(options) {
+    const authManager = useContext(AuthManagerContext);
+    if (!authManager) {
+        throw new Error('useAuthManagerContext must be used within an AuthManagerProvider');
+    }
+    return useAuthManager({
+        authManager,
+        enableQueryInvalidation: options?.enableQueryInvalidation
+    });
+}

package/dist/core/BaseApiClient.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Base API Client abstraction for cross-platform HTTP requests
+ *
+ * This provides a platform-agnostic interface for making HTTP requests
+ * with consistent error handling, authentication, and response processing.
+ */
+import type { TokenStorage } from './TokenStorage';
+export interface RequestConfig {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    data?: unknown;
+    params?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+export interface ApiResponse<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+}
+export interface ApiError {
+    message: string;
+    status?: number;
+    code?: string;
+    data?: unknown;
+}
+export interface ApiClientConfig {
+    baseURL: string;
+    timeout?: number;
+    defaultHeaders?: Record<string, string>;
+    withCredentials?: boolean;
+}
+/**
+ * Abstract base class for API clients
+ * Platform-specific implementations should extend this class
+ */
+export declare abstract class BaseApiClient {
+    protected baseURL: string;
+    protected timeout: number;
+    protected defaultHeaders: Record<string, string>;
+    protected tokenStorage?: TokenStorage;
+    protected withCredentials: boolean;
+    constructor(config: ApiClientConfig);
+    /**
+     * Set token storage implementation
+     */
+    setTokenStorage(storage: TokenStorage): void;
+    /**
+     * Make HTTP request - must be implemented by platform-specific clients
+     */
+    abstract request<T = unknown>(config: RequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Convenience methods for common HTTP operations
+     */
+    get<T = unknown>(url: string, params?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    post<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>>;
+    put<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>>;
+    patch<T = unknown>(url: string, data?: unknown): Promise<ApiResponse<T>>;
+    delete<T = unknown>(url: string): Promise<ApiResponse<T>>;
+    /**
+     * Build full URL from relative path
+     */
+    protected buildUrl(url: string): string;
+    /**
+     * Merge headers with defaults and authentication
+     */
+    protected buildHeaders(headers?: Record<string, string>): Promise<Record<string, string>>;
+    /**
+     * Handle API errors consistently
+     */
+    protected createError(message: string, status?: number, code?: string, data?: unknown): ApiError;
+    /**
+     * Check if error is authentication related
+     */
+    protected isAuthError(error: ApiError): boolean;
+    /**
+     * Handle token refresh logic (to be implemented by platform adapters)
+     */
+    protected handleTokenRefresh(): Promise<boolean>;
+}
+//# sourceMappingURL=BaseApiClient.d.ts.map

package/dist/core/BaseApiClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseApiClient.d.ts","sourceRoot":"","sources":["../../src/core/BaseApiClient.ts"],"names":[],"mappings":"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"}