@cranberry-money/shared-services 3.0.1 → 4.1.0

package/dist/auth/functional/auth-operations.js

@@ -1,246 +0,0 @@
-"use strict";
-/**
- * Pure Authentication Operations
- *
- * All authentication operations as pure functions with explicit dependencies.
- * No side effects, no global state - everything is explicit and testable.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSignupData = exports.validateSigninCredentials = exports.initializeFromStorage = exports.resendVerificationCode = exports.verifyEmail = exports.getUserProfile = exports.refreshTokens = exports.signup = exports.signout = exports.signin = void 0;
-// Pure authentication operations
-/**
- * Sign in with credentials
- *
- * @param credentials - User login credentials
- * @param deps - Required dependencies (API client and token storage)
- * @returns Promise resolving to user profile and tokens
- */
-const signin = async (credentials, deps) => {
-    try {
-        // Call signin API
-        const response = await deps.apiClient.post('/api/signin/', credentials);
-        // Extract tokens from response
-        const tokens = {
-            access: response.access,
-            refresh: response.refresh,
-        };
-        // Store tokens
-        await deps.tokenStorage.storeTokens(tokens);
-        // Get user profile (either from signin response or separate call)
-        const user = response.user || await (0, exports.getUserProfile)(deps.apiClient);
-        return { user, tokens };
-    }
-    catch (error) {
-        throw new Error(extractErrorMessage(error));
-    }
-};
-exports.signin = signin;
-/**
- * Sign out user
- *
- * @param deps - Required dependencies
- * @returns Promise resolving when signout is complete
- */
-const signout = async (deps) => {
-    try {
-        // Best effort API call - don't fail signout if API call fails
-        await deps.apiClient.post('/api/signout/');
-    }
-    catch (error) {
-        console.warn('API signout failed, continuing with local cleanup:', error);
-    }
-    finally {
-        // Always clear local tokens
-        await deps.tokenStorage.clearTokens();
-    }
-};
-exports.signout = signout;
-/**
- * Sign up new user
- *
- * @param userData - User registration data
- * @param deps - Required dependencies
- * @returns Promise resolving to success status and optional message
- */
-const signup = async (userData, deps) => {
-    try {
-        const response = await deps.apiClient.post('/api/signup/', userData);
-        return {
-            success: true,
-            message: response.message || 'Account created successfully'
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            message: extractErrorMessage(error)
-        };
-    }
-};
-exports.signup = signup;
-/**
- * Refresh authentication tokens
- *
- * @param currentTokens - Current token pair
- * @param deps - Required dependencies
- * @returns Promise resolving to new token pair
- */
-const refreshTokens = async (currentTokens, deps) => {
-    try {
-        const response = await deps.apiClient.post('/api/token/refresh/', { refresh: currentTokens.refresh });
-        const newTokens = {
-            access: response.access,
-            refresh: response.refresh,
-        };
-        // Store new tokens
-        await deps.tokenStorage.storeTokens(newTokens);
-        return newTokens;
-    }
-    catch (error) {
-        // If refresh fails, clear stored tokens
-        await deps.tokenStorage.clearTokens();
-        throw new Error('Token refresh failed');
-    }
-};
-exports.refreshTokens = refreshTokens;
-/**
- * Get user profile from API
- *
- * @param apiClient - API client instance
- * @returns Promise resolving to user profile
- */
-const getUserProfile = async (apiClient) => {
-    try {
-        return await apiClient.get('/api/profile/');
-    }
-    catch (error) {
-        throw new Error(`Failed to fetch user profile: ${extractErrorMessage(error)}`);
-    }
-};
-exports.getUserProfile = getUserProfile;
-/**
- * Verify email address
- *
- * @param verificationData - Email verification data
- * @param deps - Required dependencies
- * @returns Promise resolving to success status
- */
-const verifyEmail = async (verificationData, deps) => {
-    try {
-        await deps.apiClient.post('/api/email-verification/', verificationData);
-        return { success: true, message: 'Email verified successfully' };
-    }
-    catch (error) {
-        return { success: false, message: extractErrorMessage(error) };
-    }
-};
-exports.verifyEmail = verifyEmail;
-/**
- * Resend verification code
- *
- * @param deps - Required dependencies
- * @returns Promise resolving to success status
- */
-const resendVerificationCode = async (deps) => {
-    try {
-        await deps.apiClient.post('/api/resend-verification/');
-        return { success: true, message: 'Verification code sent' };
-    }
-    catch (error) {
-        return { success: false, message: extractErrorMessage(error) };
-    }
-};
-exports.resendVerificationCode = resendVerificationCode;
-/**
- * Initialize authentication from stored tokens
- *
- * @param deps - Required dependencies
- * @returns Promise resolving to user and tokens if valid, null otherwise
- */
-const initializeFromStorage = async (deps) => {
-    try {
-        // Try to retrieve stored tokens
-        const tokens = await deps.tokenStorage.retrieveTokens();
-        if (!tokens) {
-            return null;
-        }
-        // Verify tokens are still valid by fetching user profile
-        const user = await (0, exports.getUserProfile)(deps.apiClient);
-        return { user, tokens };
-    }
-    catch (error) {
-        // If verification fails, clear invalid tokens
-        await deps.tokenStorage.clearTokens();
-        return null;
-    }
-};
-exports.initializeFromStorage = initializeFromStorage;
-// Utility functions
-/**
- * Extract error message from various error formats
- */
-const extractErrorMessage = (error) => {
-    if (typeof error === 'string') {
-        return error;
-    }
-    if (error && typeof error === 'object') {
-        const errorObj = error;
-        // API error format
-        if (errorObj.message) {
-            return errorObj.message;
-        }
-        // Django REST framework format
-        if (errorObj.detail) {
-            return errorObj.detail;
-        }
-        // Standard Error object
-        if (errorObj.message) {
-            return errorObj.message;
-        }
-    }
-    return 'An unexpected error occurred';
-};
-/**
- * Validate signin credentials
- */
-const validateSigninCredentials = (credentials) => {
-    const errors = [];
-    if (!credentials.email || !credentials.email.trim()) {
-        errors.push('Email is required');
-    }
-    else if (!isValidEmail(credentials.email)) {
-        errors.push('Invalid email format');
-    }
-    if (!credentials.password || credentials.password.length < 1) {
-        errors.push('Password is required');
-    }
-    return errors;
-};
-exports.validateSigninCredentials = validateSigninCredentials;
-/**
- * Validate signup data
- */
-const validateSignupData = (userData) => {
-    const errors = [];
-    if (!userData.email || !userData.email.trim()) {
-        errors.push('Email is required');
-    }
-    else if (!isValidEmail(userData.email)) {
-        errors.push('Invalid email format');
-    }
-    if (!userData.password || userData.password.length < 8) {
-        errors.push('Password must be at least 8 characters');
-    }
-    if (userData.password !== userData.passwordConfirm) {
-        errors.push('Passwords do not match');
-    }
-    return errors;
-};
-exports.validateSignupData = validateSignupData;
-/**
- * Simple email validation
- */
-const isValidEmail = (email) => {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return emailRegex.test(email);
-};

package/dist/auth/functional/auth-state.d.ts

@@ -1,38 +0,0 @@
-/**
- * Pure Authentication State Management
- *
- * Immutable state structures and pure functions for managing authentication state.
- * All state transitions are explicit and predictable.
- */
-export interface TokenPair {
-    readonly access: string;
-    readonly refresh: string;
-}
-export interface UserProfile {
-    readonly id: string;
-    readonly email: string;
-    readonly firstName: string;
-    readonly lastName: string;
-    readonly isVerified: boolean;
-    readonly isSignupCompleted: boolean;
-}
-export interface AuthState {
-    readonly isAuthenticated: boolean;
-    readonly isLoading: boolean;
-    readonly user: UserProfile | null;
-    readonly tokens: TokenPair | null;
-    readonly error: string | null;
-}
-export declare const createInitialAuthState: () => AuthState;
-export declare const createLoadingAuthState: (currentState: AuthState) => AuthState;
-export declare const createAuthenticatedState: (user: UserProfile, tokens: TokenPair) => AuthState;
-export declare const createUnauthenticatedState: () => AuthState;
-export declare const createErrorState: (currentState: AuthState, error: string) => AuthState;
-export declare const updateTokens: (currentState: AuthState, tokens: TokenPair) => AuthState;
-export declare const clearError: (currentState: AuthState) => AuthState;
-export declare const isValidAuthState: (state: AuthState) => boolean;
-export declare const hasValidTokens: (state: AuthState) => boolean;
-export declare const getDisplayName: (user: UserProfile | null) => string;
-export declare const requiresVerification: (user: UserProfile | null) => boolean;
-export declare const requiresSignupCompletion: (user: UserProfile | null) => boolean;
-//# sourceMappingURL=auth-state.d.ts.map

package/dist/auth/functional/auth-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth-state.d.ts","sourceRoot":"","sources":["../../../src/auth/functional/auth-state.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAGD,eAAO,MAAM,sBAAsB,QAAO,SAMxC,CAAC;AAEH,eAAO,MAAM,sBAAsB,GAAI,cAAc,SAAS,KAAG,SAI/D,CAAC;AAEH,eAAO,MAAM,wBAAwB,GACnC,MAAM,WAAW,EACjB,QAAQ,SAAS,KAChB,SAMD,CAAC;AAEH,eAAO,MAAM,0BAA0B,QAAO,SAM5C,CAAC;AAEH,eAAO,MAAM,gBAAgB,GAC3B,cAAc,SAAS,EACvB,OAAO,MAAM,KACZ,SAID,CAAC;AAEH,eAAO,MAAM,YAAY,GACvB,cAAc,SAAS,EACvB,QAAQ,SAAS,KAChB,SAGD,CAAC;AAEH,eAAO,MAAM,UAAU,GAAI,cAAc,SAAS,KAAG,SAGnD,CAAC;AAGH,eAAO,MAAM,gBAAgB,GAAI,OAAO,SAAS,KAAG,OAQnD,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,OAAO,SAAS,KAAG,OAIjD,CAAC;AAGF,eAAO,MAAM,cAAc,GAAI,MAAM,WAAW,GAAG,IAAI,KAAG,MAGzD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,MAAM,WAAW,GAAG,IAAI,KAAG,OAE/D,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,MAAM,WAAW,GAAG,IAAI,KAAG,OAEnE,CAAC"}

package/dist/auth/functional/auth-state.js

@@ -1,87 +0,0 @@
-"use strict";
-/**
- * Pure Authentication State Management
- *
- * Immutable state structures and pure functions for managing authentication state.
- * All state transitions are explicit and predictable.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requiresSignupCompletion = exports.requiresVerification = exports.getDisplayName = exports.hasValidTokens = exports.isValidAuthState = exports.clearError = exports.updateTokens = exports.createErrorState = exports.createUnauthenticatedState = exports.createAuthenticatedState = exports.createLoadingAuthState = exports.createInitialAuthState = void 0;
-// State factory functions - all pure functions that return new state
-const createInitialAuthState = () => ({
-    isAuthenticated: false,
-    isLoading: false,
-    user: null,
-    tokens: null,
-    error: null,
-});
-exports.createInitialAuthState = createInitialAuthState;
-const createLoadingAuthState = (currentState) => ({
-    ...currentState,
-    isLoading: true,
-    error: null,
-});
-exports.createLoadingAuthState = createLoadingAuthState;
-const createAuthenticatedState = (user, tokens) => ({
-    isAuthenticated: true,
-    isLoading: false,
-    user,
-    tokens,
-    error: null,
-});
-exports.createAuthenticatedState = createAuthenticatedState;
-const createUnauthenticatedState = () => ({
-    isAuthenticated: false,
-    isLoading: false,
-    user: null,
-    tokens: null,
-    error: null,
-});
-exports.createUnauthenticatedState = createUnauthenticatedState;
-const createErrorState = (currentState, error) => ({
-    ...currentState,
-    isLoading: false,
-    error,
-});
-exports.createErrorState = createErrorState;
-const updateTokens = (currentState, tokens) => ({
-    ...currentState,
-    tokens,
-});
-exports.updateTokens = updateTokens;
-const clearError = (currentState) => ({
-    ...currentState,
-    error: null,
-});
-exports.clearError = clearError;
-// State validation functions
-const isValidAuthState = (state) => {
-    // If authenticated, must have user and tokens
-    if (state.isAuthenticated) {
-        return state.user !== null && state.tokens !== null;
-    }
-    // If not authenticated, should not have user or tokens
-    return state.user === null && state.tokens === null;
-};
-exports.isValidAuthState = isValidAuthState;
-const hasValidTokens = (state) => {
-    return state.tokens !== null &&
-        state.tokens.access.length > 0 &&
-        state.tokens.refresh.length > 0;
-};
-exports.hasValidTokens = hasValidTokens;
-// Utility functions for working with auth state
-const getDisplayName = (user) => {
-    if (!user)
-        return '';
-    return `${user.firstName} ${user.lastName}`.trim() || user.email;
-};
-exports.getDisplayName = getDisplayName;
-const requiresVerification = (user) => {
-    return user !== null && !user.isVerified;
-};
-exports.requiresVerification = requiresVerification;
-const requiresSignupCompletion = (user) => {
-    return user !== null && !user.isSignupCompleted;
-};
-exports.requiresSignupCompletion = requiresSignupCompletion;

package/dist/auth/functional/token-storage.d.ts

@@ -1,44 +0,0 @@
-/**
- * Token Storage Implementations
- *
- * Platform-specific token storage implementations that follow the simple TokenStorage interface.
- * Pure functions with explicit error handling.
- */
-import type { TokenStorage } from './auth-operations';
-export interface SecureStoreInterface {
-    setItemAsync(key: string, value: string): Promise<void>;
-    getItemAsync(key: string): Promise<string | null>;
-    deleteItemAsync(key: string): Promise<void>;
-    isAvailableAsync?(): Promise<boolean>;
-}
-/**
- * Create web token storage using localStorage
- *
- * @returns TokenStorage implementation for web browsers
- */
-export declare const createWebTokenStorage: () => TokenStorage;
-/**
- * Create mobile token storage using secure storage
- *
- * @param secureStore - Platform-specific secure storage implementation
- * @returns TokenStorage implementation for mobile apps
- */
-export declare const createMobileTokenStorage: (secureStore: SecureStoreInterface) => TokenStorage;
-/**
- * Create in-memory token storage (for testing)
- *
- * @returns TokenStorage implementation that stores tokens in memory
- */
-export declare const createMemoryTokenStorage: () => TokenStorage;
-/**
- * Utility function to check if secure storage is available (for mobile)
- */
-export declare const isSecureStorageAvailable: (secureStore: SecureStoreInterface) => Promise<boolean>;
-/**
- * Migrate tokens from old storage format (if needed)
- *
- * This function can be used to migrate from the old AuthManager token storage
- * to the new simplified format.
- */
-export declare const migrateTokensFromLegacyStorage: (newStorage: TokenStorage) => Promise<boolean>;
-//# sourceMappingURL=token-storage.d.ts.map

package/dist/auth/functional/token-storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"token-storage.d.ts","sourceRoot":"","sources":["../../../src/auth/functional/token-storage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAa,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjE,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAClD,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,gBAAgB,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CACvC;AAKD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,QAAO,YAwCvC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GAAI,aAAa,oBAAoB,KAAG,YA2C3E,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,QAAO,YAgB3C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAU,aAAa,oBAAoB,KAAG,OAAO,CAAC,OAAO,CAkBjG,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,GACzC,YAAY,YAAY,KACvB,OAAO,CAAC,OAAO,CA2BjB,CAAC"}

package/dist/auth/functional/token-storage.js

@@ -1,178 +0,0 @@
-"use strict";
-/**
- * Token Storage Implementations
- *
- * Platform-specific token storage implementations that follow the simple TokenStorage interface.
- * Pure functions with explicit error handling.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.migrateTokensFromLegacyStorage = exports.isSecureStorageAvailable = exports.createMemoryTokenStorage = exports.createMobileTokenStorage = exports.createWebTokenStorage = void 0;
-// Storage keys
-const TOKENS_STORAGE_KEY = 'auth_tokens';
-/**
- * Create web token storage using localStorage
- *
- * @returns TokenStorage implementation for web browsers
- */
-const createWebTokenStorage = () => ({
-    async storeTokens(tokens) {
-        try {
-            const tokenData = JSON.stringify(tokens);
-            localStorage.setItem(TOKENS_STORAGE_KEY, tokenData);
-        }
-        catch (error) {
-            throw new Error(`Failed to store tokens: ${error}`);
-        }
-    },
-    async retrieveTokens() {
-        try {
-            const stored = localStorage.getItem(TOKENS_STORAGE_KEY);
-            if (!stored) {
-                return null;
-            }
-            const tokens = JSON.parse(stored);
-            // Validate token structure
-            if (!tokens.access || !tokens.refresh) {
-                throw new Error('Invalid token structure');
-            }
-            return tokens;
-        }
-        catch (error) {
-            // If parsing fails, clear corrupted data
-            localStorage.removeItem(TOKENS_STORAGE_KEY);
-            return null;
-        }
-    },
-    async clearTokens() {
-        try {
-            localStorage.removeItem(TOKENS_STORAGE_KEY);
-        }
-        catch (error) {
-            // localStorage.removeItem doesn't typically throw, but handle just in case
-            console.warn('Failed to clear tokens from localStorage:', error);
-        }
-    },
-});
-exports.createWebTokenStorage = createWebTokenStorage;
-/**
- * Create mobile token storage using secure storage
- *
- * @param secureStore - Platform-specific secure storage implementation
- * @returns TokenStorage implementation for mobile apps
- */
-const createMobileTokenStorage = (secureStore) => ({
-    async storeTokens(tokens) {
-        try {
-            const tokenData = JSON.stringify(tokens);
-            await secureStore.setItemAsync(TOKENS_STORAGE_KEY, tokenData);
-        }
-        catch (error) {
-            throw new Error(`Failed to store tokens in secure storage: ${error}`);
-        }
-    },
-    async retrieveTokens() {
-        try {
-            const stored = await secureStore.getItemAsync(TOKENS_STORAGE_KEY);
-            if (!stored) {
-                return null;
-            }
-            const tokens = JSON.parse(stored);
-            // Validate token structure
-            if (!tokens.access || !tokens.refresh) {
-                throw new Error('Invalid token structure');
-            }
-            return tokens;
-        }
-        catch (error) {
-            // If parsing fails, clear corrupted data
-            try {
-                await secureStore.deleteItemAsync(TOKENS_STORAGE_KEY);
-            }
-            catch (clearError) {
-                console.warn('Failed to clear corrupted tokens:', clearError);
-            }
-            return null;
-        }
-    },
-    async clearTokens() {
-        try {
-            await secureStore.deleteItemAsync(TOKENS_STORAGE_KEY);
-        }
-        catch (error) {
-            console.warn('Failed to clear tokens from secure storage:', error);
-        }
-    },
-});
-exports.createMobileTokenStorage = createMobileTokenStorage;
-/**
- * Create in-memory token storage (for testing)
- *
- * @returns TokenStorage implementation that stores tokens in memory
- */
-const createMemoryTokenStorage = () => {
-    let storedTokens = null;
-    return {
-        async storeTokens(tokens) {
-            storedTokens = { ...tokens };
-        },
-        async retrieveTokens() {
-            return storedTokens ? { ...storedTokens } : null;
-        },
-        async clearTokens() {
-            storedTokens = null;
-        },
-    };
-};
-exports.createMemoryTokenStorage = createMemoryTokenStorage;
-/**
- * Utility function to check if secure storage is available (for mobile)
- */
-const isSecureStorageAvailable = async (secureStore) => {
-    try {
-        if (secureStore.isAvailableAsync) {
-            return await secureStore.isAvailableAsync();
-        }
-        // Test availability by trying to set/get a test value
-        const testKey = '_secure_storage_test';
-        const testValue = 'test';
-        await secureStore.setItemAsync(testKey, testValue);
-        const retrieved = await secureStore.getItemAsync(testKey);
-        await secureStore.deleteItemAsync(testKey);
-        return retrieved === testValue;
-    }
-    catch (error) {
-        return false;
-    }
-};
-exports.isSecureStorageAvailable = isSecureStorageAvailable;
-/**
- * Migrate tokens from old storage format (if needed)
- *
- * This function can be used to migrate from the old AuthManager token storage
- * to the new simplified format.
- */
-const migrateTokensFromLegacyStorage = async (newStorage) => {
-    try {
-        // Try to find tokens in old locations
-        const legacyAccessToken = localStorage.getItem('access_token');
-        const legacyRefreshToken = localStorage.getItem('refresh_token');
-        if (legacyAccessToken && legacyRefreshToken) {
-            const tokens = {
-                access: legacyAccessToken,
-                refresh: legacyRefreshToken,
-            };
-            // Store in new format
-            await newStorage.storeTokens(tokens);
-            // Clean up old storage
-            localStorage.removeItem('access_token');
-            localStorage.removeItem('refresh_token');
-            return true;
-        }
-        return false;
-    }
-    catch (error) {
-        console.warn('Failed to migrate legacy tokens:', error);
-        return false;
-    }
-};
-exports.migrateTokensFromLegacyStorage = migrateTokensFromLegacyStorage;

package/dist/auth/react/AuthProvider.d.ts

@@ -1,92 +0,0 @@
-/**
- * React Authentication Provider
- *
- * Pure functional authentication with React state management.
- * Uses the pure auth functions with React context for state management.
- */
-import React from 'react';
-import type { AuthState } from '../functional/auth-state';
-import type { AuthDependencies, SigninPayload, SignupPayload } from '../functional/auth-operations';
-interface AuthContextValue {
-    state: AuthState;
-    signin: (credentials: SigninPayload) => Promise<void>;
-    signout: () => Promise<void>;
-    signup: (userData: SignupPayload) => Promise<{
-        success: boolean;
-        message?: string;
-    }>;
-    refreshTokens: () => Promise<void>;
-    verifyEmail: (token: string) => Promise<{
-        success: boolean;
-        message?: string;
-    }>;
-    resendVerificationCode: () => Promise<{
-        success: boolean;
-        message?: string;
-    }>;
-    clearError: () => void;
-    validateSigninCredentials: (credentials: SigninPayload) => string[];
-    validateSignupData: (userData: SignupPayload) => string[];
-}
-interface AuthProviderProps {
-    children: React.ReactNode;
-    dependencies: AuthDependencies;
-    autoInitialize?: boolean;
-}
-/**
- * Authentication Provider Component
- *
- * Manages authentication state using pure functions and React state.
- * Provides a clean, predictable interface for authentication operations.
- */
-export declare const AuthProvider: React.FC<AuthProviderProps>;
-/**
- * Hook to use authentication context
- *
- * @returns Authentication context value
- * @throws Error if used outside AuthProvider
- */
-export declare const useAuth: () => AuthContextValue;
-/**
- * Hook to get authentication state only (for components that only need to read state)
- */
-export declare const useAuthState: () => AuthState;
-/**
- * Hook for authentication actions only (for components that only need actions)
- */
-export declare const useAuthActions: () => {
-    signin: (credentials: SigninPayload) => Promise<void>;
-    signout: () => Promise<void>;
-    signup: (userData: SignupPayload) => Promise<{
-        success: boolean;
-        message?: string;
-    }>;
-    refreshTokens: () => Promise<void>;
-    verifyEmail: (token: string) => Promise<{
-        success: boolean;
-        message?: string;
-    }>;
-    resendVerificationCode: () => Promise<{
-        success: boolean;
-        message?: string;
-    }>;
-    clearError: () => void;
-    validateSigninCredentials: (credentials: SigninPayload) => string[];
-    validateSignupData: (userData: SignupPayload) => string[];
-};
-/**
- * Higher-order component for components that require authentication
- */
-export declare const withAuth: <P extends object>(Component: React.ComponentType<P>) => React.ComponentType<P>;
-/**
- * Component for conditional rendering based on authentication state
- */
-interface AuthGuardProps {
-    children: React.ReactNode;
-    fallback?: React.ReactNode;
-    requireAuth?: boolean;
-    requireVerification?: boolean;
-}
-export declare const AuthGuard: React.FC<AuthGuardProps>;
-export {};
-//# sourceMappingURL=AuthProvider.d.ts.map