@glideidentity/web-client-sdk 5.1.3 → 6.0.0-beta.2

package/dist/esm/core/phone-auth/strategies/link.d.ts

@@ -1,89 +0,0 @@
-/**
- * Link Strategy Handler
- * Handles authentication via app links (iOS and Android)
- * Opens authentication app while keeping user on current page
- */
-import type { StrategyHandler } from './types';
-import type { PrepareResponse } from '../types';
-export interface LinkAuthOptions {
-    /** Fixed polling interval in milliseconds (default: 2000) */
-    pollingInterval?: number;
-    /** Maximum polling attempts before timeout (default: 30 = 1 minute with 2s interval) */
-    maxPollingAttempts?: number;
-    /** Custom polling endpoint (overrides backend-provided or configured endpoint) */
-    pollingEndpoint?: string;
-    /** Developer environment (adds 'developer' header to requests) */
-    devEnv?: string;
-    /** Callback when link is opened */
-    onLinkOpened?: () => void;
-    /** Callback for polling status updates */
-    onStatusUpdate?: (status: PollingStatus) => void;
-    /** Callback when authentication times out */
-    onTimeout?: () => void;
-    /** Callback when authentication is cancelled by user */
-    onCancel?: () => void;
-}
-export interface PollingStatus {
-    /** Current status of the authentication */
-    status: 'pending' | 'authenticated' | 'expired' | 'cancelled' | 'error';
-    /** Optional message */
-    message?: string;
-    /** Authentication result data if status is 'authenticated' */
-    data?: any;
-}
-export interface LinkAuthResult {
-    /** Whether authentication was successful */
-    authenticated: boolean;
-    /** Authentication credential if successful */
-    credential?: string;
-    /** Session info for subsequent requests */
-    session?: any;
-    /** Error message if authentication failed */
-    error?: string;
-}
-export declare class LinkHandler implements StrategyHandler {
-    private pollingInterval?;
-    private isPollingActive;
-    private isCancelled;
-    private onCancel?;
-    private pollingReject?;
-    private isPollingInProgress;
-    /**
-     * Invoke link-based authentication
-     * Opens authentication app while keeping user on current page
-     */
-    invoke(data: PrepareResponse, options?: LinkAuthOptions): Promise<LinkAuthResult>;
-    /**
-     * Open authentication link by navigating to the URL
-     */
-    private openAuthenticationLink;
-    /**
-     * Start polling for authentication status with constant interval
-     */
-    private startPolling;
-    /**
-     * Stop polling
-     */
-    private stopPolling;
-    /**
-     * Format response for backend processing
-     */
-    formatResponse(response: LinkAuthResult): any;
-    /**
-     * Check if link strategy is supported
-     * Returns true for mobile devices (iOS and Android)
-     */
-    isSupported(): boolean;
-    /**
-     * Clean up resources (stop polling if active)
-     */
-    cleanup(): void;
-    /**
-     * Check if polling is currently active
-     */
-    isPolling(): boolean;
-    /**
-     * Cancel the ongoing authentication
-     */
-    cancel(): void;
-}

package/dist/esm/core/phone-auth/strategies/link.js

@@ -1,380 +0,0 @@
-/**
- * Link Strategy Handler
- * Handles authentication via app links (iOS and Android)
- * Opens authentication app while keeping user on current page
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export class LinkHandler {
-    constructor() {
-        this.isPollingActive = false;
-        this.isCancelled = false;
-        this.isPollingInProgress = false;
-    }
-    /**
-     * Invoke link-based authentication
-     * Opens authentication app while keeping user on current page
-     */
-    invoke(data, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log('[Link Auth] 🔗 invoke() called with data:', JSON.stringify(data, null, 2));
-            console.log('[Link Auth] Options:', options ? JSON.stringify({
-                pollingInterval: options.pollingInterval,
-                maxPollingAttempts: options.maxPollingAttempts,
-                pollingEndpoint: options.pollingEndpoint
-            }) : 'none');
-            // Extract link data from prepare response
-            const linkData = data.data;
-            if (!linkData || !linkData.url) {
-                throw new Error('Invalid link data: missing URL');
-            }
-            const sessionKey = data.session.session_key;
-            console.log('[Link Auth] Session key:', sessionKey);
-            console.log('[Link Auth] Link URL:', linkData.url);
-            // Open authentication app without navigating away from current page
-            this.openAuthenticationLink(linkData.url);
-            // Notify that link was opened
-            if (options === null || options === void 0 ? void 0 : options.onLinkOpened) {
-                options.onLinkOpened();
-            }
-            // Start polling for authentication status
-            // Use constant interval (no exponential backoff)
-            return this.startPolling(sessionKey, linkData, options);
-        });
-    }
-    /**
-     * Open authentication link by navigating to the URL
-     */
-    openAuthenticationLink(url) {
-        // Use location.href to navigate directly - required for App Clips to open properly
-        window.location.href = url;
-    }
-    /**
-     * Start polling for authentication status with constant interval
-     */
-    startPolling(sessionKey, linkData, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const interval = (options === null || options === void 0 ? void 0 : options.pollingInterval) || 2000; // Fixed 2 second interval
-            const maxAttempts = (options === null || options === void 0 ? void 0 : options.maxPollingAttempts) || 30; // 1 minute with 2s interval
-            let attempts = 0;
-            console.log('[Link Auth] 🚀 Starting polling:', {
-                sessionKey,
-                interval: `${interval}ms`,
-                maxAttempts,
-                linkDataAvailable: !!linkData
-            });
-            return new Promise((resolve, reject) => {
-                this.isPollingActive = true;
-                this.pollingReject = reject; // Store reject function for cancel()
-                const poll = () => __awaiter(this, void 0, void 0, function* () {
-                    if (!this.isPollingActive) {
-                        return; // Polling was stopped
-                    }
-                    // Skip if another poll is already in progress
-                    if (this.isPollingInProgress) {
-                        return;
-                    }
-                    let statusUrl = ''; // Declare at function scope for catch block access
-                    try {
-                        this.isPollingInProgress = true;
-                        // Check max attempts before making the request
-                        if (attempts >= maxAttempts) {
-                            this.stopPolling();
-                            if (options === null || options === void 0 ? void 0 : options.onTimeout) {
-                                options.onTimeout();
-                            }
-                            // Calculate actual timeout duration
-                            const timeoutSeconds = Math.round((maxAttempts * interval) / 1000);
-                            const timeoutMessage = timeoutSeconds >= 60
-                                ? `${Math.floor(timeoutSeconds / 60)} minute${Math.floor(timeoutSeconds / 60) > 1 ? 's' : ''}`
-                                : `${timeoutSeconds} seconds`;
-                            if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
-                                options.onStatusUpdate({
-                                    status: 'expired',
-                                    message: `Authentication timeout after ${timeoutMessage}`
-                                });
-                            }
-                            reject(new Error(`Authentication timeout after ${timeoutMessage}`));
-                            return;
-                        }
-                        // Build public status endpoint URL
-                        // Use the same priority logic as Desktop strategy:
-                        // 1. options?.pollingEndpoint (already contains invoke options OR client config from client.ts)
-                        // 2. Backend-provided status_url from linkData
-                        // 3. Hardcoded fallback to API server
-                        let endpoint = options === null || options === void 0 ? void 0 : options.pollingEndpoint;
-                        let endpointSource = 'options';
-                        if (!endpoint && linkData.status_url) {
-                            endpoint = linkData.status_url;
-                            endpointSource = 'backend';
-                        }
-                        console.log('[Link Auth] Polling endpoint selection:');
-                        console.log('  - options?.pollingEndpoint:', options === null || options === void 0 ? void 0 : options.pollingEndpoint);
-                        console.log('  - linkData.status_url:', linkData.status_url);
-                        console.log('  - selected endpoint:', endpoint, 'from source:', endpointSource);
-                        // Build the status URL based on endpoint format (same as Desktop)
-                        if (endpoint && (endpoint.startsWith('http://') || endpoint.startsWith('https://'))) {
-                            // Full URL provided
-                            statusUrl = endpoint;
-                        }
-                        else if (endpoint && endpoint !== '') {
-                            // Relative path provided (e.g. '/api/phone-auth/status')
-                            const origin = typeof window !== 'undefined' ? window.location.origin : '';
-                            if (endpoint.includes('{{session_id}}')) {
-                                statusUrl = origin + endpoint.replace('{{session_id}}', sessionKey);
-                            }
-                            else {
-                                // Append session ID to the provided endpoint
-                                statusUrl = origin + endpoint + '/' + sessionKey;
-                            }
-                        }
-                        else {
-                            // No endpoint provided - use hardcoded fallback
-                            statusUrl = `https://api.glideidentity.app/public/status/${sessionKey}`;
-                            endpointSource = 'fallback';
-                        }
-                        console.log(`[Link Auth] Using ${endpointSource} endpoint: ${statusUrl}`);
-                        // Poll public status endpoint - no authentication required
-                        console.log(`[Link Auth] Polling status (attempt ${attempts}/${maxAttempts}): ${statusUrl}`);
-                        // Build headers
-                        const headers = {
-                            'Accept': 'application/json'
-                        };
-                        // Add developer header if devEnv is set
-                        if (options === null || options === void 0 ? void 0 : options.devEnv) {
-                            headers['developer'] = options.devEnv;
-                            console.log(`[Link Auth] Adding developer header: ${options.devEnv}`);
-                        }
-                        const response = yield fetch(statusUrl, {
-                            method: 'GET',
-                            headers
-                        });
-                        console.log(`[Link Auth] Poll response - Status: ${response.status}, OK: ${response.ok}`);
-                        // Handle based on HTTP status code
-                        if (response.status === 200) {
-                            // Session is active (pending or completed)
-                            const result = yield response.json();
-                            console.log('[Link Auth] Poll response data:', JSON.stringify(result, null, 2));
-                            if (result.status === 'completed') {
-                                // Authentication completed successfully
-                                console.log('[Link Auth] ✅ Authentication COMPLETED! Session:', sessionKey);
-                                console.log('[Link Auth] Full completion result:', JSON.stringify(result, null, 2));
-                                this.stopPolling();
-                                // Authentication completed successfully
-                                if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
-                                    options.onStatusUpdate({
-                                        status: 'authenticated',
-                                        message: 'Authentication successful',
-                                        data: result
-                                    });
-                                }
-                                // Return the authentication result
-                                this.pollingReject = undefined; // Clear reject function on success
-                                resolve({
-                                    authenticated: true,
-                                    credential: result.credential || sessionKey,
-                                    session: result.session || {
-                                        session_key: sessionKey,
-                                        status: result.status,
-                                        protocol: result.protocol || 'link',
-                                        created_at: result.created_at,
-                                        last_updated: result.last_updated
-                                    }
-                                });
-                            }
-                            else if (result.status === 'pending') {
-                                // Continue polling
-                                console.log('[Link Auth] Status still pending, continuing to poll...');
-                                attempts++; // Increment attempts after successful poll
-                                if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
-                                    options.onStatusUpdate({
-                                        status: 'pending',
-                                        message: 'Waiting for app authentication...'
-                                    });
-                                }
-                            }
-                            else {
-                                // Unexpected status value
-                                console.log('[Link Auth] ⚠️ Unexpected status value:', result.status, 'Full result:', JSON.stringify(result, null, 2));
-                                attempts++; // Increment for unexpected status too
-                            }
-                        }
-                        else if (response.status === 410) {
-                            // Session expired
-                            console.log('[Link Auth] ❌ Session expired (410)');
-                            this.stopPolling();
-                            const errorData = yield response.json().catch(() => ({ message: 'Session expired' }));
-                            if (options === null || options === void 0 ? void 0 : options.onTimeout) {
-                                options.onTimeout();
-                            }
-                            if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
-                                options.onStatusUpdate({
-                                    status: 'expired',
-                                    message: errorData.message || 'Session expired'
-                                });
-                            }
-                            reject(new Error(errorData.message || 'Session expired'));
-                        }
-                        else if (response.status === 422) {
-                            // Authentication failed
-                            console.log('[Link Auth] ❌ Authentication failed (422)');
-                            this.stopPolling();
-                            const errorData = yield response.json().catch(() => ({ message: 'Authentication failed' }));
-                            console.log('[Link Auth] Error data:', JSON.stringify(errorData, null, 2));
-                            const isUserCancelled = errorData.code === 'USER_CANCELLED';
-                            const errorMsg = isUserCancelled
-                                ? 'User cancelled authentication'
-                                : (errorData.message || 'Verification failed');
-                            // Authentication failed
-                            if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
-                                options.onStatusUpdate({
-                                    status: 'error',
-                                    message: errorMsg
-                                });
-                            }
-                            reject(new Error(errorMsg));
-                        }
-                        else if (response.status === 404) {
-                            // Session not found
-                            console.log('[Link Auth] ❌ Session not found (404)');
-                            this.stopPolling();
-                            if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
-                                options.onStatusUpdate({
-                                    status: 'error',
-                                    message: 'Session not found'
-                                });
-                            }
-                            reject(new Error('Session not found'));
-                        }
-                        else if (response.status === 400) {
-                            // Invalid session key
-                            console.log('[Link Auth] ❌ Invalid session key (400)');
-                            this.stopPolling();
-                            const errorData = yield response.json().catch(() => ({ message: 'Invalid session key' }));
-                            console.log('[Link Auth] Error data:', JSON.stringify(errorData, null, 2));
-                            reject(new Error(errorData.message || 'Invalid session key'));
-                        }
-                        else {
-                            // Unexpected status - continue polling
-                            console.log('[Link Auth] ⚠️ Unexpected HTTP status:', response.status, 'continuing to poll...');
-                            attempts++; // Increment for unexpected HTTP status
-                            try {
-                                const body = yield response.text();
-                                console.log('[Link Auth] Response body:', body);
-                            }
-                            catch (e) {
-                                console.log('[Link Auth] Could not read response body');
-                            }
-                        }
-                    }
-                    catch (error) {
-                        // Network or other error - continue polling
-                        console.error('[Link Auth] 🔴 Polling error:', error.message || error);
-                        attempts++; // Increment for error case
-                        console.error('[Link Auth] Error details:', {
-                            name: error.name,
-                            message: error.message,
-                            stack: error.stack,
-                            statusUrl: statusUrl,
-                            attempt: attempts,
-                            error: error
-                        });
-                        // Check if it's a CORS error (common on mobile)
-                        if (error.message && error.message.toLowerCase().includes('failed')) {
-                            console.error('[Link Auth] ⚠️ Possible CORS issue. Status URL:', statusUrl);
-                            console.error('[Link Auth] Make sure the API endpoint allows CORS from your ngrok domain');
-                        }
-                        if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
-                            options.onStatusUpdate({
-                                status: 'pending',
-                                message: `Connection issue, retrying... (${attempts}/${maxAttempts})`
-                            });
-                        }
-                    }
-                    finally {
-                        // Always clear the polling flag when done
-                        this.isPollingInProgress = false;
-                    }
-                });
-                // Start initial poll immediately
-                poll();
-                // Set up constant interval polling (no backoff)
-                this.pollingInterval = setInterval(poll, interval);
-            });
-        });
-    }
-    /**
-     * Stop polling
-     */
-    stopPolling() {
-        console.log('[Link Auth] 🏁 Stopping polling');
-        this.isPollingActive = false;
-        this.isPollingInProgress = false;
-        if (this.pollingInterval) {
-            clearInterval(this.pollingInterval);
-            this.pollingInterval = undefined;
-        }
-    }
-    /**
-     * Format response for backend processing
-     */
-    formatResponse(response) {
-        if (!response.authenticated || !response.credential) {
-            throw new Error('Authentication not completed');
-        }
-        return {
-            credential: response.credential,
-            session: response.session,
-            type: 'link'
-        };
-    }
-    /**
-     * Check if link strategy is supported
-     * Returns true for mobile devices (iOS and Android)
-     */
-    isSupported() {
-        // Link strategy is supported on mobile devices
-        const isMobile = /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);
-        return isMobile;
-    }
-    /**
-     * Clean up resources (stop polling if active)
-     */
-    cleanup() {
-        this.stopPolling();
-        this.isCancelled = false;
-        this.onCancel = undefined;
-        this.pollingReject = undefined;
-    }
-    /**
-     * Check if polling is currently active
-     */
-    isPolling() {
-        return this.pollingInterval !== undefined;
-    }
-    /**
-     * Cancel the ongoing authentication
-     */
-    cancel() {
-        var _a;
-        console.log('[Link Auth] Cancelling authentication');
-        this.isCancelled = true;
-        this.stopPolling();
-        (_a = this.onCancel) === null || _a === void 0 ? void 0 : _a.call(this);
-        // Immediately reject the polling promise
-        if (this.pollingReject) {
-            this.pollingReject({
-                code: 'USER_DENIED',
-                message: 'Authentication cancelled by user'
-            });
-            this.pollingReject = undefined;
-        }
-    }
-}

package/dist/esm/core/phone-auth/strategies/ts43.d.ts

@@ -1,32 +0,0 @@
-/**
- * TS-43 Strategy Handler
- * Handles Digital Credentials API authentication for Android/Chromium
- * Properly manages session objects with session_key and nonce
- */
-import type { StrategyHandler } from './types';
-import type { PrepareResponse } from '../types';
-export declare class TS43Handler implements StrategyHandler {
-    /**
-     * Invoke TS-43 authentication using Digital Credentials API
-     * The data structure from backend is already in the correct format for navigator.credentials.get
-     */
-    invoke(data: PrepareResponse): Promise<any>;
-    /**
-     * Format the credential response for backend processing
-     * Include the session key so backend can retrieve the full session
-     */
-    formatResponse(response: any): any;
-    /**
-     * Check if Digital Credentials API is supported
-     */
-    isSupported(): boolean;
-    /**
-     * Get browser support information
-     */
-    getBrowserSupportInfo(): {
-        supported: boolean;
-        browser: string;
-        message?: string;
-        helpUrl?: string;
-    };
-}

package/dist/esm/core/phone-auth/strategies/ts43.js

@@ -1,157 +0,0 @@
-/**
- * TS-43 Strategy Handler
- * Handles Digital Credentials API authentication for Android/Chromium
- * Properly manages session objects with session_key and nonce
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export class TS43Handler {
-    /**
-     * Invoke TS-43 authentication using Digital Credentials API
-     * The data structure from backend is already in the correct format for navigator.credentials.get
-     */
-    invoke(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Validate session structure - only session_key is actually required
-            if (!data.session || !data.session.session_key) {
-                throw new Error('Invalid TS43 session: missing required session_key');
-            }
-            // Check if Digital Credentials API is available
-            if (!this.isSupported()) {
-                throw new Error('Digital Credentials API not supported in this browser');
-            }
-            // Extract TS43 data from the prepare response
-            const ts43Data = data.data;
-            // The data is already in the correct format from backend
-            // Just pass it through to navigator.credentials.get
-            const credentialRequest = {
-                digital: {
-                    requests: [{
-                            protocol: ts43Data.protocol, // e.g., "openid4vp-v1-unsigned"
-                            data: ts43Data.data // Pass the entire data object as-is
-                        }]
-                }
-            };
-            try {
-                // @ts-ignore - Digital Credentials API types not yet in TypeScript
-                const credential = yield navigator.credentials.get(credentialRequest);
-                if (!credential) {
-                    throw new Error('No credential received from Digital Credentials API');
-                }
-                // Success vibration (haptic feedback)
-                if (typeof navigator !== 'undefined' && navigator.vibrate) {
-                    // Add a small delay to ensure the browser has regained focus/visibility
-                    // after the native bottom sheet closes
-                    setTimeout(() => {
-                        try {
-                            // Double tap pattern: vibrate 80ms, pause 50ms, vibrate 80ms
-                            // Slightly longer duration (80ms vs 50ms) ensures it registers on more devices
-                            navigator.vibrate([80, 50, 80]);
-                        }
-                        catch (e) {
-                            // Ignore vibration errors
-                        }
-                    }, 200);
-                }
-                // @ts-ignore - credential.data is not typed yet
-                return credential;
-            }
-            catch (error) {
-                // Handle browser-specific errors
-                if (error instanceof Error) {
-                    if (error.name === 'NotAllowedError') {
-                        throw new Error('User denied the authentication request');
-                    }
-                    if (error.name === 'NotSupportedError') {
-                        throw new Error('Digital Credentials API not supported');
-                    }
-                    if (error.name === 'AbortError') {
-                        throw new Error('Authentication was aborted');
-                    }
-                }
-                throw error;
-            }
-        });
-    }
-    /**
-     * Format the credential response for backend processing
-     * Include the session key so backend can retrieve the full session
-     */
-    formatResponse(response) {
-        var _a;
-        // Extract vp_token from the response
-        const vpToken = (_a = response.data) === null || _a === void 0 ? void 0 : _a.vp_token;
-        if (!vpToken) {
-            throw new Error('Invalid TS43 response: missing vp_token');
-        }
-        return {
-            vp_token: vpToken,
-            type: 'ts43'
-        };
-    }
-    /**
-     * Check if Digital Credentials API is supported
-     */
-    isSupported() {
-        if (typeof window === 'undefined') {
-            return false;
-        }
-        // Check for DigitalCredential constructor
-        // @ts-ignore - DigitalCredential not yet in TypeScript
-        return 'DigitalCredential' in window;
-    }
-    /**
-     * Get browser support information
-     */
-    getBrowserSupportInfo() {
-        if (typeof window === 'undefined') {
-            return {
-                supported: false,
-                browser: 'unknown',
-                message: 'Not running in a browser environment'
-            };
-        }
-        const userAgent = navigator.userAgent;
-        const isChrome = /Chrome/.test(userAgent) && /Google Inc/.test(navigator.vendor);
-        const isEdge = /Edg\//.test(userAgent);
-        const isAndroid = /Android/.test(userAgent);
-        const isSupported = this.isSupported();
-        if (isSupported) {
-            return {
-                supported: true,
-                browser: isChrome ? 'Chrome' : isEdge ? 'Edge' : 'Chromium'
-            };
-        }
-        // Provide specific guidance based on browser
-        if ((isChrome || isEdge) && isAndroid) {
-            return {
-                supported: false,
-                browser: isChrome ? 'Chrome' : 'Edge',
-                message: 'Digital Credentials API requires Chrome 128+ on Android. Please update your browser.',
-                helpUrl: 'https://play.google.com/store/apps/details?id=com.android.chrome'
-            };
-        }
-        if (isChrome || isEdge) {
-            return {
-                supported: false,
-                browser: isChrome ? 'Chrome' : 'Edge',
-                message: 'Digital Credentials API is not enabled. Please enable the #web-identity-digital-credentials flag.',
-                helpUrl: isChrome
-                    ? 'chrome://flags/#web-identity-digital-credentials'
-                    : 'edge://flags/#web-identity-digital-credentials'
-            };
-        }
-        return {
-            supported: false,
-            browser: 'unsupported',
-            message: 'Your browser does not support Digital Credentials API'
-        };
-    }
-}

package/dist/esm/core/phone-auth/strategies/types.d.ts

@@ -1,18 +0,0 @@
-/**
- * Strategy Handler Interface
- * Defines the contract for authentication strategy implementations
- */
-export interface StrategyHandler {
-    /**
-     * Invoke authentication using strategy-specific data
-     */
-    invoke(data: any): Promise<any>;
-    /**
-     * Format response for backend processing
-     */
-    formatResponse(response: any): any;
-    /**
-     * Check if this strategy is supported in the current environment
-     */
-    isSupported(): boolean;
-}