@glideidentity/web-client-sdk 4.4.8-beta.1

package/dist/esm/adapters/react/usePhoneAuth.js

@@ -0,0 +1,92 @@
+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());
+    });
+};
+import { useState, useCallback, useMemo, useRef } from 'react';
+import { PhoneAuthClient } from '../../core/phone-auth';
+export function usePhoneAuth(config = {}) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [result, setResult] = useState(null);
+    const [currentStep, setCurrentStep] = useState('idle');
+    const lastRequestRef = useRef(null);
+    // Create client instance with callbacks
+    const client = useMemo(() => new PhoneAuthClient(Object.assign(Object.assign({}, config), { 
+        // Pass through callbacks if provided
+        onCrossDeviceDetected: config.onCrossDeviceDetected, onRetryAttempt: config.onRetryAttempt })), [JSON.stringify(config)]);
+    // Check browser support
+    const isSupported = useMemo(() => client.isSupported(), [client]);
+    // Verify method with silent retry support
+    const verify = useCallback((options) => __awaiter(this, void 0, void 0, function* () {
+        setIsLoading(true);
+        setError(null);
+        setResult(null);
+        setCurrentStep('requesting');
+        lastRequestRef.current = options;
+        try {
+            // Use the client's verify method which includes retry logic
+            const verificationResult = yield client.verify(options);
+            setResult(verificationResult);
+            setCurrentStep('complete');
+            return verificationResult;
+        }
+        catch (err) {
+            // Error is only set after all retries are exhausted
+            const authError = err;
+            setError(authError);
+            setCurrentStep('idle');
+            throw authError;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }), [client]);
+    // Manual retry method
+    const retryLastRequest = useCallback(() => __awaiter(this, void 0, void 0, function* () {
+        if (!lastRequestRef.current) {
+            throw new Error('No previous request to retry');
+        }
+        return verify(lastRequestRef.current);
+    }), [verify]);
+    // Convenience methods
+    const getPhoneNumber = useCallback((options) => verify(Object.assign({ use_case: 'GetPhoneNumber' }, options)), [verify]);
+    const verifyPhoneNumber = useCallback((phoneNumber, options) => verify(Object.assign({ use_case: 'VerifyPhoneNumber', phone_number: phoneNumber }, options)), [verify]);
+    // Reset state
+    const reset = useCallback(() => {
+        setIsLoading(false);
+        setError(null);
+        setResult(null);
+        setCurrentStep('idle');
+    }, []);
+    // Expose granular methods directly from client for better discoverability
+    const preparePhoneRequest = useCallback((options) => client.preparePhoneRequest(options), [client]);
+    const invokeSecurePrompt = useCallback((prepareResponse) => client.invokeSecurePrompt(prepareResponse), [client]);
+    const getPhoneNumberCredential = useCallback((credentialResponse, session) => client.getPhoneNumber(credentialResponse, session), [client]);
+    const verifyPhoneNumberCredential = useCallback((credentialResponse, session) => client.verifyPhoneNumber(credentialResponse, session), [client]);
+    return {
+        // State
+        isLoading,
+        error,
+        result,
+        currentStep,
+        isSupported,
+        // High-level methods
+        verify,
+        getPhoneNumber,
+        verifyPhoneNumber,
+        retryLastRequest,
+        reset,
+        // Granular methods (directly exposed for better discoverability)
+        preparePhoneRequest,
+        invokeSecurePrompt,
+        getPhoneNumberCredential,
+        verifyPhoneNumberCredential,
+        // Client instance (still available for advanced usage)
+        client
+    };
+}

package/dist/esm/adapters/vanilla/client.d.ts

@@ -0,0 +1,8 @@
+import type { ClientConfig, ClientResponse, RequestOptions } from '../../core/types';
+export declare class VanillaClient {
+    private client;
+    constructor(config: ClientConfig);
+    authenticate(authUrl: string, options?: any): Promise<void>;
+    setToken(token: string): void;
+    get<T>(path: string, options?: RequestOptions): Promise<ClientResponse<T>>;
+}

package/dist/esm/adapters/vanilla/client.js

@@ -0,0 +1,29 @@
+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());
+    });
+};
+import { SDKClient } from '../../core/client';
+export class VanillaClient {
+    constructor(config) {
+        this.client = new SDKClient(config);
+    }
+    authenticate(authUrl, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Legacy authentication removed - use setToken directly
+            throw new Error('authenticate method is deprecated. Use client.setToken() directly.');
+        });
+    }
+    setToken(token) {
+        this.client.setToken(token);
+    }
+    get(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.get(path, options);
+        });
+    }
+}

package/dist/esm/adapters/vanilla/index.d.ts

@@ -0,0 +1,3 @@
+export { VanillaClient as ClientManager } from './client';
+export { PhoneAuthManager } from './phone-auth';
+export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from '../../core/phone-auth';

package/dist/esm/adapters/vanilla/index.js

@@ -0,0 +1,4 @@
+export { VanillaClient as ClientManager } from './client';
+export { PhoneAuthManager } from './phone-auth';
+// Export error utilities
+export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from '../../core/phone-auth';

package/dist/esm/adapters/vanilla/phone-auth.d.ts

@@ -0,0 +1,46 @@
+import type { AuthConfig, PhoneAuthResult, AuthError, AuthStep, PhoneAuthOptions } from '../../core/phone-auth';
+export interface PhoneAuthState {
+    isLoading: boolean;
+    error: AuthError | null;
+    result: PhoneAuthResult | null;
+    currentStep: AuthStep;
+    isSupported: boolean;
+}
+export declare class PhoneAuthManager {
+    private client;
+    private state;
+    private listeners;
+    constructor(config?: AuthConfig);
+    /**
+     * Get current state
+     */
+    getState(): PhoneAuthState;
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(listener: (state: PhoneAuthState) => void): () => void;
+    /**
+     * Update state and notify listeners
+     */
+    private updateState;
+    /**
+     * Verify phone number
+     */
+    verify(options: PhoneAuthOptions): Promise<PhoneAuthResult>;
+    /**
+     * Get phone number
+     */
+    getPhoneNumber(options?: Omit<PhoneAuthOptions, 'use_case' | 'phone_number'>): Promise<PhoneAuthResult>;
+    /**
+     * Verify specific phone number
+     */
+    verifyPhoneNumber(phoneNumber: string, options?: Omit<PhoneAuthOptions, 'use_case' | 'phone_number'>): Promise<PhoneAuthResult>;
+    /**
+     * Reset state
+     */
+    reset(): void;
+    /**
+     * Check if browser supports secure phone authentication
+     */
+    isSupported(): boolean;
+}

package/dist/esm/adapters/vanilla/phone-auth.js

@@ -0,0 +1,134 @@
+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());
+    });
+};
+import { PhoneAuthClient } from '../../core/phone-auth';
+export class PhoneAuthManager {
+    constructor(config = {}) {
+        this.listeners = [];
+        this.client = new PhoneAuthClient(config);
+        this.state = {
+            isLoading: false,
+            error: null,
+            result: null,
+            currentStep: 'idle',
+            isSupported: this.client.isSupported()
+        };
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return Object.assign({}, this.state);
+    }
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(listener) {
+        this.listeners.push(listener);
+        // Return unsubscribe function
+        return () => {
+            const index = this.listeners.indexOf(listener);
+            if (index !== -1) {
+                this.listeners.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Update state and notify listeners
+     */
+    updateState(updates) {
+        this.state = Object.assign(Object.assign({}, this.state), updates);
+        this.listeners.forEach(listener => listener(this.getState()));
+    }
+    /**
+     * Verify phone number
+     */
+    verify(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.updateState({
+                isLoading: true,
+                error: null,
+                result: null,
+                currentStep: 'requesting'
+            });
+            try {
+                // Step 1: Prepare request
+                const preparedRequest = yield this.client.preparePhoneRequest(options);
+                // Step 2: Show authenticating state
+                this.updateState({ currentStep: 'authenticating' });
+                const credentialResponse = yield this.client.invokeSecurePrompt(preparedRequest);
+                // Step 3: Process response through appropriate endpoint
+                this.updateState({ currentStep: 'processing' });
+                // Cast to credential type - adapters never use headless mode
+                const credential = credentialResponse;
+                const processedResult = options.use_case === 'GetPhoneNumber'
+                    ? yield this.client.getPhoneNumber(credential, preparedRequest.session)
+                    : yield this.client.verifyPhoneNumber(credential, preparedRequest.session);
+                // Create final result
+                const isVerifyResponse = 'verified' in processedResult;
+                const result = processedResult;
+                this.updateState({
+                    result,
+                    currentStep: 'complete',
+                    isLoading: false
+                });
+                return result;
+            }
+            catch (error) {
+                // Enhance error with context
+                const authError = error;
+                const enhancedError = Object.assign(Object.assign({}, authError), { context: authError.context || {
+                        useCase: options.use_case,
+                        timestamp: new Date().toISOString(),
+                        userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : undefined,
+                        url: typeof window !== 'undefined' ? window.location.href : undefined
+                    } });
+                this.updateState({
+                    error: enhancedError,
+                    currentStep: 'idle',
+                    isLoading: false
+                });
+                throw enhancedError;
+            }
+        });
+    }
+    /**
+     * Get phone number
+     */
+    getPhoneNumber(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.verify(Object.assign({ use_case: 'GetPhoneNumber' }, options));
+        });
+    }
+    /**
+     * Verify specific phone number
+     */
+    verifyPhoneNumber(phoneNumber, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.verify(Object.assign({ use_case: 'VerifyPhoneNumber', phone_number: phoneNumber }, options));
+        });
+    }
+    /**
+     * Reset state
+     */
+    reset() {
+        this.updateState({
+            isLoading: false,
+            error: null,
+            result: null,
+            currentStep: 'idle'
+        });
+    }
+    /**
+     * Check if browser supports secure phone authentication
+     */
+    isSupported() {
+        return this.state.isSupported;
+    }
+}

package/dist/esm/adapters/vue/index.d.ts

@@ -0,0 +1,10 @@
+export { usePhoneAuth } from './usePhoneAuth';
+export { useClient } from './useClient';
+export { SDKClient } from '../../core/client';
+export { PhoneAuthClient } from '../../core/phone-auth';
+export type { ClientConfig, ClientResponse, RequestOptions } from '../../core/types';
+export type { AuthConfig as PhoneAuthConfig, PhoneAuthOptions, PhoneAuthResult, AuthError, AuthStep } from '../../core/phone-auth';
+export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from '../../core/phone-auth';
+export type { PhoneAuthCallbacks, PLMN, SessionInfo, PrepareRequest, PrepareResponse, GetPhoneNumberRequest, GetPhoneNumberResponse, VerifyPhoneNumberRequest, VerifyPhoneNumberResponse, SecureCredentialRequest, SecureCredentialResponse, DigitalCredential, TS43Data, LinkData, ClientInfo, ConsentData, BrowserErrorType, BrowserErrorCodeType, BrowserNameType } from '../../core/phone-auth/types';
+export { USE_CASE as UseCase, AUTHENTICATION_STRATEGY as AuthenticationStrategy, BrowserError, BrowserErrorCode, BrowserName } from '../../core/phone-auth/types';
+export { USE_CASE, ERROR_CODE, ERROR_MESSAGES, ERROR_STATUS_CODES } from '../../core/phone-auth/api-types';

package/dist/esm/adapters/vue/index.js

@@ -0,0 +1,11 @@
+export { usePhoneAuth } from './usePhoneAuth';
+export { useClient } from './useClient';
+export { SDKClient } from '../../core/client';
+export { PhoneAuthClient } from '../../core/phone-auth';
+// API response types are already exported via core/phone-auth/types
+// Export error utilities
+export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from '../../core/phone-auth';
+// Export constants for use case and strategy
+export { USE_CASE as UseCase, AUTHENTICATION_STRATEGY as AuthenticationStrategy, BrowserError, BrowserErrorCode, BrowserName } from '../../core/phone-auth/types';
+// Export API constants from api-types
+export { USE_CASE, ERROR_CODE, ERROR_MESSAGES, ERROR_STATUS_CODES } from '../../core/phone-auth/api-types';

package/dist/esm/adapters/vue/useClient.d.ts

@@ -0,0 +1,115 @@
+import { Ref } from 'vue';
+import type { ClientConfig, ClientResponse } from '../../core/types';
+import type { PhoneAuthResult, AuthError, PhoneAuthOptions } from '../../core/phone-auth';
+export declare function useClient<T>(config: ClientConfig): {
+    client: {
+        phoneAuth: {
+            isSupported: () => boolean;
+            getBrowserSupportInfo: () => {
+                supported: boolean;
+                browser: string;
+                message?: string;
+                helpUrl?: string;
+            };
+            verify: (options: PhoneAuthOptions) => Promise<PhoneAuthResult>;
+            getPhoneNumberComplete: (options?: Omit<PhoneAuthOptions, "use_case" | "phone_number">) => Promise<PhoneAuthResult>;
+            verifyPhoneNumberComplete: (phoneNumber: string, options?: Omit<PhoneAuthOptions, "use_case" | "phone_number">) => Promise<PhoneAuthResult>;
+            preparePhoneRequest: (options: PhoneAuthOptions) => Promise<import("../../core/phone-auth").PrepareResponse>;
+            invokeSecurePrompt: (prepareResponse: import("../../core/phone-auth").PrepareResponse, options?: import("../../core/phone-auth").InvokeOptions | import("../..").DesktopAuthOptions) => Promise<import("../../core/phone-auth").SecureCredentialResponse["vp_token"] | import("../../core/phone-auth").HeadlessResult>;
+            getPhoneNumber: (credentialResponse: import("../../core/phone-auth").SecureCredentialResponse["vp_token"] | string, session: import("../../core/phone-auth").SessionInfo) => Promise<import("../../core/phone-auth").GetPhoneNumberResponse>;
+            verifyPhoneNumber: (credentialResponse: import("../../core/phone-auth").SecureCredentialResponse["vp_token"] | string, session: import("../../core/phone-auth").SessionInfo) => Promise<import("../../core/phone-auth").VerifyPhoneNumberResponse>;
+        };
+        setToken: (token: string) => void;
+        clearToken: () => void;
+        get: <T_1 = any>(path: string, options?: import("../../core/types").RequestOptions) => Promise<ClientResponse<T_1>>;
+    };
+    useQuery: (path: string) => {
+        data: [T | null] extends [Ref<any, any>] ? import("@vue/shared").IfAny<Ref<any, any> & T, Ref<Ref<any, any> & T, Ref<any, any> & T>, Ref<any, any> & T> : Ref<import("vue").UnwrapRef<T> | null, T | import("vue").UnwrapRef<T> | null>;
+        loading: Ref<boolean, boolean>;
+        error: Ref<Error | null, Error | null>;
+        refetch: () => Promise<void>;
+    };
+    useAuth: (options?: any) => {
+        token: Ref<string | null, string | null>;
+        loading: Ref<boolean, boolean>;
+        error: Ref<Error | null, Error | null>;
+        authenticate: (authUrl: string) => Promise<never>;
+    };
+    usePhoneAuth: () => {
+        result: Ref<{
+            phone_number: import("../../core/phone-auth").PhoneNumber;
+            aud?: string | undefined;
+        } | {
+            phone_number: import("../../core/phone-auth").PhoneNumber;
+            verified: boolean;
+            aud?: string | undefined;
+        } | null, PhoneAuthResult | {
+            phone_number: import("../../core/phone-auth").PhoneNumber;
+            aud?: string | undefined;
+        } | {
+            phone_number: import("../../core/phone-auth").PhoneNumber;
+            verified: boolean;
+            aud?: string | undefined;
+        } | null>;
+        loading: Ref<boolean, boolean>;
+        error: Ref<{
+            code: import("../../core/phone-auth/types").PhoneAuthErrorCode;
+            message: string;
+            details?: any;
+            status?: number | undefined;
+            requestId?: string | undefined;
+            timestamp?: string | undefined;
+            traceId?: string | undefined;
+            spanId?: string | undefined;
+            service?: string | undefined;
+            retryAfter?: number | undefined;
+            browserError?: {
+                name: string;
+                message: string;
+                stack?: string;
+                code?: number;
+            } | undefined;
+            context?: {
+                [x: string]: any;
+                step?: "prepare" | "prompt" | "process" | "complete" | undefined;
+                useCase?: string | undefined;
+                timestamp: string;
+                userAgent?: string | undefined;
+                url?: string | undefined;
+            } | undefined;
+        } | null, AuthError | {
+            code: import("../../core/phone-auth/types").PhoneAuthErrorCode;
+            message: string;
+            details?: any;
+            status?: number | undefined;
+            requestId?: string | undefined;
+            timestamp?: string | undefined;
+            traceId?: string | undefined;
+            spanId?: string | undefined;
+            service?: string | undefined;
+            retryAfter?: number | undefined;
+            browserError?: {
+                name: string;
+                message: string;
+                stack?: string;
+                code?: number;
+            } | undefined;
+            context?: {
+                [x: string]: any;
+                step?: "prepare" | "prompt" | "process" | "complete" | undefined;
+                useCase?: string | undefined;
+                timestamp: string;
+                userAgent?: string | undefined;
+                url?: string | undefined;
+            } | undefined;
+        } | null>;
+        isSupported: Ref<boolean, boolean>;
+        getPhoneNumber: (options?: Omit<PhoneAuthOptions, "useCase" | "phoneNumber">) => Promise<PhoneAuthResult>;
+        verifyPhoneNumber: (phoneNumber: string, options?: Omit<PhoneAuthOptions, "useCase" | "phoneNumber">) => Promise<PhoneAuthResult>;
+        preparePhoneRequest: (options: Parameters<(options: PhoneAuthOptions) => Promise<import("../../core/phone-auth").PrepareResponse>>[0]) => Promise<import("../../core/phone-auth").PrepareResponse>;
+        invokeSecurePrompt: (request: Parameters<(prepareResponse: import("../../core/phone-auth").PrepareResponse, options?: import("../../core/phone-auth").InvokeOptions | import("../..").DesktopAuthOptions) => Promise<import("../../core/phone-auth").SecureCredentialResponse["vp_token"] | import("../../core/phone-auth").HeadlessResult>>[0]) => Promise<{
+            [aggregator_id: string]: string | string[];
+        } | import("../../core/phone-auth").HeadlessResult>;
+    };
+};
+export declare const useVueClient: typeof useClient;

package/dist/esm/adapters/vue/useClient.js

@@ -0,0 +1,127 @@
+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());
+    });
+};
+import { ref, onUnmounted } from 'vue';
+import { SDKClient } from '../../core/client';
+export function useClient(config) {
+    const client = ref(new SDKClient(config));
+    return {
+        client: client.value,
+        useQuery: (path) => {
+            const data = ref(null);
+            const loading = ref(true);
+            const error = ref(null);
+            const fetchData = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const response = yield client.value.get(path);
+                    data.value = response.data;
+                }
+                catch (err) {
+                    error.value = err;
+                }
+                finally {
+                    loading.value = false;
+                }
+            });
+            fetchData();
+            return { data, loading, error, refetch: fetchData };
+        },
+        useAuth: (options = {}) => {
+            const token = ref(null);
+            const loading = ref(false);
+            const error = ref(null);
+            let cleanup = null;
+            const authenticate = (authUrl) => __awaiter(this, void 0, void 0, function* () {
+                loading.value = true;
+                error.value = null;
+                // Clean up previous authentication if exists
+                if (cleanup) {
+                    cleanup();
+                    cleanup = null;
+                }
+                // Legacy authentication removed - use setToken directly
+                error.value = new Error('authenticate method is deprecated. Use client.setToken() directly.');
+                loading.value = false;
+                throw error.value;
+            });
+            // Cleanup on component unmount
+            onUnmounted(() => {
+                if (cleanup) {
+                    cleanup();
+                    cleanup = null;
+                }
+            });
+            return {
+                token,
+                loading,
+                error,
+                authenticate
+            };
+        },
+        usePhoneAuth: () => {
+            const result = ref(null);
+            const loading = ref(false);
+            const error = ref(null);
+            const isSupported = ref(client.value.phoneAuth.isSupported());
+            const getPhoneNumber = (options) => __awaiter(this, void 0, void 0, function* () {
+                loading.value = true;
+                error.value = null;
+                result.value = null;
+                try {
+                    const res = yield client.value.phoneAuth.getPhoneNumberComplete(options);
+                    result.value = res;
+                    return res;
+                }
+                catch (err) {
+                    error.value = err;
+                    throw err;
+                }
+                finally {
+                    loading.value = false;
+                }
+            });
+            const verifyPhoneNumber = (phoneNumber, options) => __awaiter(this, void 0, void 0, function* () {
+                loading.value = true;
+                error.value = null;
+                result.value = null;
+                try {
+                    const res = yield client.value.phoneAuth.verifyPhoneNumberComplete(phoneNumber, options);
+                    result.value = res;
+                    return res;
+                }
+                catch (err) {
+                    error.value = err;
+                    throw err;
+                }
+                finally {
+                    loading.value = false;
+                }
+            });
+            // Low-level methods for advanced control
+            const preparePhoneRequest = (options) => __awaiter(this, void 0, void 0, function* () {
+                return client.value.phoneAuth.preparePhoneRequest(options);
+            });
+            const invokeSecurePrompt = (request) => __awaiter(this, void 0, void 0, function* () {
+                return client.value.phoneAuth.invokeSecurePrompt(request);
+            });
+            return {
+                result,
+                loading,
+                error,
+                isSupported,
+                getPhoneNumber,
+                verifyPhoneNumber,
+                // Low-level API for advanced usage
+                preparePhoneRequest,
+                invokeSecurePrompt
+            };
+        }
+    };
+}
+export const useVueClient = useClient;