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

package/dist/adapters/angular/client.service.d.ts

@@ -0,0 +1,7 @@
+import type { ClientConfig, ClientResponse } from '../../core/types';
+import { Observable } from 'rxjs';
+export declare class ClientService {
+    private client;
+    constructor(config: ClientConfig);
+    query<T>(path: string): Observable<ClientResponse<T>>;
+}

package/dist/adapters/angular/client.service.js

@@ -0,0 +1,30 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientService = void 0;
+const core_1 = require("@angular/core");
+const client_1 = require("../../core/client");
+const rxjs_1 = require("rxjs");
+let ClientService = class ClientService {
+    constructor(config) {
+        this.client = new client_1.SDKClient(config);
+    }
+    query(path) {
+        return (0, rxjs_1.from)(this.client.get(path));
+    }
+};
+exports.ClientService = ClientService;
+exports.ClientService = ClientService = __decorate([
+    (0, core_1.Injectable)({
+        providedIn: 'root',
+    }),
+    __metadata("design:paramtypes", [Object])
+], ClientService);

package/dist/adapters/angular/index.d.ts

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

package/dist/adapters/angular/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorBreadcrumb = exports.serializeError = exports.isRetryableError = exports.getRetryDelay = exports.isErrorCode = exports.getUserMessage = exports.isUserError = exports.isPhoneAuthError = exports.PhoneAuthErrorCode = exports.PhoneAuthService = exports.ClientService = void 0;
+var client_service_1 = require("./client.service");
+Object.defineProperty(exports, "ClientService", { enumerable: true, get: function () { return client_service_1.ClientService; } });
+var phone_auth_service_1 = require("./phone-auth.service");
+Object.defineProperty(exports, "PhoneAuthService", { enumerable: true, get: function () { return phone_auth_service_1.PhoneAuthService; } });
+// Export error utilities
+var phone_auth_1 = require("../../core/phone-auth");
+Object.defineProperty(exports, "PhoneAuthErrorCode", { enumerable: true, get: function () { return phone_auth_1.PhoneAuthErrorCode; } });
+Object.defineProperty(exports, "isPhoneAuthError", { enumerable: true, get: function () { return phone_auth_1.isPhoneAuthError; } });
+Object.defineProperty(exports, "isUserError", { enumerable: true, get: function () { return phone_auth_1.isUserError; } });
+Object.defineProperty(exports, "getUserMessage", { enumerable: true, get: function () { return phone_auth_1.getUserMessage; } });
+Object.defineProperty(exports, "isErrorCode", { enumerable: true, get: function () { return phone_auth_1.isErrorCode; } });
+Object.defineProperty(exports, "getRetryDelay", { enumerable: true, get: function () { return phone_auth_1.getRetryDelay; } });
+Object.defineProperty(exports, "isRetryableError", { enumerable: true, get: function () { return phone_auth_1.isRetryableError; } });
+Object.defineProperty(exports, "serializeError", { enumerable: true, get: function () { return phone_auth_1.serializeError; } });
+Object.defineProperty(exports, "createErrorBreadcrumb", { enumerable: true, get: function () { return phone_auth_1.createErrorBreadcrumb; } });

package/dist/adapters/angular/phone-auth.service.d.ts

@@ -0,0 +1,38 @@
+import type { AuthConfig, PhoneAuthResult, AuthError, AuthStep, PhoneAuthOptions } from '../../core/phone-auth';
+import { Observable } from 'rxjs';
+export declare class PhoneAuthService {
+    private client;
+    private isLoadingSubject;
+    private errorSubject;
+    private resultSubject;
+    private currentStepSubject;
+    isLoading$: Observable<boolean>;
+    error$: Observable<AuthError | null>;
+    result$: Observable<PhoneAuthResult | null>;
+    currentStep$: Observable<AuthStep>;
+    constructor();
+    /**
+     * Configure the phone auth client
+     */
+    configure(config: AuthConfig): void;
+    /**
+     * Check if browser supports secure phone authentication
+     */
+    isSupported(): boolean;
+    /**
+     * 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;
+}

package/dist/adapters/angular/phone-auth.service.js

@@ -0,0 +1,130 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhoneAuthService = void 0;
+const core_1 = require("@angular/core");
+const phone_auth_1 = require("../../core/phone-auth");
+const rxjs_1 = require("rxjs");
+let PhoneAuthService = class PhoneAuthService {
+    constructor() {
+        // State subjects
+        this.isLoadingSubject = new rxjs_1.BehaviorSubject(false);
+        this.errorSubject = new rxjs_1.BehaviorSubject(null);
+        this.resultSubject = new rxjs_1.BehaviorSubject(null);
+        this.currentStepSubject = new rxjs_1.BehaviorSubject('idle');
+        // Public observables
+        this.isLoading$ = this.isLoadingSubject.asObservable();
+        this.error$ = this.errorSubject.asObservable();
+        this.result$ = this.resultSubject.asObservable();
+        this.currentStep$ = this.currentStepSubject.asObservable();
+        this.client = new phone_auth_1.PhoneAuthClient();
+    }
+    /**
+     * Configure the phone auth client
+     */
+    configure(config) {
+        this.client = new phone_auth_1.PhoneAuthClient(config);
+    }
+    /**
+     * Check if browser supports secure phone authentication
+     */
+    isSupported() {
+        return this.client.isSupported();
+    }
+    /**
+     * Verify phone number
+     */
+    verify(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.isLoadingSubject.next(true);
+            this.errorSubject.next(null);
+            this.resultSubject.next(null);
+            this.currentStepSubject.next('requesting');
+            try {
+                // Step 1: Prepare request
+                const preparedRequest = yield this.client.preparePhoneRequest(options);
+                // Step 2: Show authenticating state
+                this.currentStepSubject.next('authenticating');
+                const credentialResponse = yield this.client.invokeSecurePrompt(preparedRequest);
+                // Step 3: Process response through appropriate endpoint
+                this.currentStepSubject.next('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.resultSubject.next(result);
+                this.currentStepSubject.next('complete');
+                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.errorSubject.next(enhancedError);
+                this.currentStepSubject.next('idle');
+                throw enhancedError;
+            }
+            finally {
+                this.isLoadingSubject.next(false);
+            }
+        });
+    }
+    /**
+     * 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.isLoadingSubject.next(false);
+        this.errorSubject.next(null);
+        this.resultSubject.next(null);
+        this.currentStepSubject.next('idle');
+    }
+};
+exports.PhoneAuthService = PhoneAuthService;
+exports.PhoneAuthService = PhoneAuthService = __decorate([
+    (0, core_1.Injectable)({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [])
+], PhoneAuthService);

package/dist/adapters/react/index.d.ts

@@ -0,0 +1,9 @@
+export { usePhoneAuth } from './usePhoneAuth';
+export { useClient } from './useClient';
+export type { UsePhoneAuthOptions } from './usePhoneAuth';
+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 { PhoneAuthClient } from '../../core/phone-auth';

package/dist/adapters/react/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhoneAuthClient = exports.BrowserName = exports.BrowserErrorCode = exports.BrowserError = exports.AuthenticationStrategy = exports.UseCase = exports.createErrorBreadcrumb = exports.serializeError = exports.isRetryableError = exports.getRetryDelay = exports.isErrorCode = exports.getUserMessage = exports.isUserError = exports.isPhoneAuthError = exports.PhoneAuthErrorCode = exports.useClient = exports.usePhoneAuth = void 0;
+var usePhoneAuth_1 = require("./usePhoneAuth");
+Object.defineProperty(exports, "usePhoneAuth", { enumerable: true, get: function () { return usePhoneAuth_1.usePhoneAuth; } });
+var useClient_1 = require("./useClient");
+Object.defineProperty(exports, "useClient", { enumerable: true, get: function () { return useClient_1.useClient; } });
+// Export error utilities
+var phone_auth_1 = require("../../core/phone-auth");
+Object.defineProperty(exports, "PhoneAuthErrorCode", { enumerable: true, get: function () { return phone_auth_1.PhoneAuthErrorCode; } });
+Object.defineProperty(exports, "isPhoneAuthError", { enumerable: true, get: function () { return phone_auth_1.isPhoneAuthError; } });
+Object.defineProperty(exports, "isUserError", { enumerable: true, get: function () { return phone_auth_1.isUserError; } });
+Object.defineProperty(exports, "getUserMessage", { enumerable: true, get: function () { return phone_auth_1.getUserMessage; } });
+Object.defineProperty(exports, "isErrorCode", { enumerable: true, get: function () { return phone_auth_1.isErrorCode; } });
+Object.defineProperty(exports, "getRetryDelay", { enumerable: true, get: function () { return phone_auth_1.getRetryDelay; } });
+Object.defineProperty(exports, "isRetryableError", { enumerable: true, get: function () { return phone_auth_1.isRetryableError; } });
+Object.defineProperty(exports, "serializeError", { enumerable: true, get: function () { return phone_auth_1.serializeError; } });
+Object.defineProperty(exports, "createErrorBreadcrumb", { enumerable: true, get: function () { return phone_auth_1.createErrorBreadcrumb; } });
+// Export constants for use case and strategy
+var types_1 = require("../../core/phone-auth/types");
+Object.defineProperty(exports, "UseCase", { enumerable: true, get: function () { return types_1.USE_CASE; } });
+Object.defineProperty(exports, "AuthenticationStrategy", { enumerable: true, get: function () { return types_1.AUTHENTICATION_STRATEGY; } });
+Object.defineProperty(exports, "BrowserError", { enumerable: true, get: function () { return types_1.BrowserError; } });
+Object.defineProperty(exports, "BrowserErrorCode", { enumerable: true, get: function () { return types_1.BrowserErrorCode; } });
+Object.defineProperty(exports, "BrowserName", { enumerable: true, get: function () { return types_1.BrowserName; } });
+// Export the PhoneAuthClient class for direct use
+var phone_auth_2 = require("../../core/phone-auth");
+Object.defineProperty(exports, "PhoneAuthClient", { enumerable: true, get: function () { return phone_auth_2.PhoneAuthClient; } });

package/dist/adapters/react/useClient.d.ts

@@ -0,0 +1,26 @@
+import { SDKClient } from '../../core/client';
+import type { ClientConfig } from '../../core/types';
+import type { PhoneAuthResult, AuthError, PhoneAuthOptions } from '../../core/phone-auth';
+export declare function useClient(config: ClientConfig): {
+    client: SDKClient;
+    isAuthenticated: boolean;
+    token: string | null;
+    loading: boolean;
+    error: Error | null;
+    authenticate: (authUrl: string, options?: any) => Promise<never>;
+    useQuery: <T>(path: string) => {
+        data: T | null;
+        loading: boolean;
+        error: Error | null;
+        refetch: () => Promise<void>;
+    };
+    usePhoneAuth: () => {
+        result: PhoneAuthResult | null;
+        loading: boolean;
+        error: AuthError | null;
+        isSupported: boolean;
+        getPhoneNumber: (options?: Omit<PhoneAuthOptions, "useCase" | "phoneNumber">) => Promise<PhoneAuthResult>;
+        verifyPhoneNumber: (phoneNumber: string, options?: Omit<PhoneAuthOptions, "useCase" | "phoneNumber">) => Promise<PhoneAuthResult>;
+    };
+};
+export { useClient as useReactClient } from './useClient';

package/dist/adapters/react/useClient.js

@@ -0,0 +1,121 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReactClient = void 0;
+exports.useClient = useClient;
+const react_1 = require("react");
+const client_1 = require("../../core/client");
+function useClient(config) {
+    const [client] = (0, react_1.useState)(() => new client_1.SDKClient(config));
+    const [isAuthenticated, setIsAuthenticated] = (0, react_1.useState)(false);
+    const [token, setToken] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        let cleanupFn;
+        const setCleanup = (fn) => {
+            cleanupFn = fn;
+        };
+        return () => {
+            if (cleanupFn) {
+                cleanupFn();
+            }
+        };
+    }, []);
+    const authenticate = (authUrl, options) => __awaiter(this, void 0, void 0, function* () {
+        // Legacy authentication removed - use setToken directly
+        const error = new Error('authenticate method is deprecated. Use client.setToken() directly.');
+        setError(error);
+        setLoading(false);
+        throw error;
+    });
+    const useQuery = (path) => {
+        const [data, setData] = (0, react_1.useState)(null);
+        const [queryLoading, setQueryLoading] = (0, react_1.useState)(true);
+        const [queryError, setQueryError] = (0, react_1.useState)(null);
+        const fetchData = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield client.get(path);
+                setData(response.data);
+            }
+            catch (err) {
+                setQueryError(err);
+            }
+            finally {
+                setQueryLoading(false);
+            }
+        }), [path]);
+        (0, react_1.useEffect)(() => {
+            fetchData();
+        }, [fetchData]);
+        return { data, loading: queryLoading, error: queryError, refetch: fetchData };
+    };
+    const usePhoneAuth = () => {
+        const [phoneAuthResult, setPhoneAuthResult] = (0, react_1.useState)(null);
+        const [phoneAuthLoading, setPhoneAuthLoading] = (0, react_1.useState)(false);
+        const [phoneAuthError, setPhoneAuthError] = (0, react_1.useState)(null);
+        const [isSupported] = (0, react_1.useState)(() => client.phoneAuth.isSupported());
+        const getPhoneNumber = (0, react_1.useCallback)((options) => __awaiter(this, void 0, void 0, function* () {
+            setPhoneAuthLoading(true);
+            setPhoneAuthError(null);
+            setPhoneAuthResult(null);
+            try {
+                const result = yield client.phoneAuth.getPhoneNumberComplete(options);
+                setPhoneAuthResult(result);
+                return result;
+            }
+            catch (err) {
+                setPhoneAuthError(err);
+                throw err;
+            }
+            finally {
+                setPhoneAuthLoading(false);
+            }
+        }), [client]);
+        const verifyPhoneNumber = (0, react_1.useCallback)((phoneNumber, options) => __awaiter(this, void 0, void 0, function* () {
+            setPhoneAuthLoading(true);
+            setPhoneAuthError(null);
+            setPhoneAuthResult(null);
+            try {
+                const result = yield client.phoneAuth.verifyPhoneNumberComplete(phoneNumber, options);
+                setPhoneAuthResult(result);
+                return result;
+            }
+            catch (err) {
+                setPhoneAuthError(err);
+                throw err;
+            }
+            finally {
+                setPhoneAuthLoading(false);
+            }
+        }), [client]);
+        return {
+            result: phoneAuthResult,
+            loading: phoneAuthLoading,
+            error: phoneAuthError,
+            isSupported,
+            getPhoneNumber,
+            verifyPhoneNumber
+        };
+    };
+    return {
+        client,
+        isAuthenticated,
+        token,
+        loading,
+        error,
+        authenticate,
+        useQuery,
+        usePhoneAuth,
+    };
+}
+var useClient_1 = require("./useClient");
+Object.defineProperty(exports, "useReactClient", { enumerable: true, get: function () { return useClient_1.useClient; } });

package/dist/adapters/react/usePhoneAuth.d.ts

@@ -0,0 +1,23 @@
+import { PhoneAuthClient } from '../../core/phone-auth';
+import type { AuthConfig, PhoneAuthResult, AuthError, AuthStep, PhoneAuthOptions } from '../../core/phone-auth';
+export interface UsePhoneAuthOptions extends AuthConfig {
+}
+export declare function usePhoneAuth(config?: UsePhoneAuthOptions): {
+    isLoading: boolean;
+    error: AuthError | null;
+    result: PhoneAuthResult | null;
+    currentStep: AuthStep;
+    isSupported: boolean;
+    verify: (options: PhoneAuthOptions) => Promise<PhoneAuthResult>;
+    getPhoneNumber: (options?: Omit<PhoneAuthOptions, "use_case">) => Promise<PhoneAuthResult>;
+    verifyPhoneNumber: (phoneNumber: string, options?: Omit<PhoneAuthOptions, "use_case" | "phone_number">) => Promise<PhoneAuthResult>;
+    retryLastRequest: () => Promise<PhoneAuthResult>;
+    reset: () => void;
+    preparePhoneRequest: (options: PhoneAuthOptions) => Promise<import("../../core/phone-auth").PrepareResponse>;
+    invokeSecurePrompt: (prepareResponse: any) => Promise<{
+        [aggregator_id: string]: string | string[];
+    } | import("../../core/phone-auth").HeadlessResult>;
+    getPhoneNumberCredential: (credentialResponse: any, session: any) => Promise<import("../../core/phone-auth").GetPhoneNumberResponse>;
+    verifyPhoneNumberCredential: (credentialResponse: any, session: any) => Promise<import("../../core/phone-auth").VerifyPhoneNumberResponse>;
+    client: PhoneAuthClient;
+};

package/dist/adapters/react/usePhoneAuth.js

@@ -0,0 +1,95 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePhoneAuth = usePhoneAuth;
+const react_1 = require("react");
+const phone_auth_1 = require("../../core/phone-auth");
+function usePhoneAuth(config = {}) {
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [result, setResult] = (0, react_1.useState)(null);
+    const [currentStep, setCurrentStep] = (0, react_1.useState)('idle');
+    const lastRequestRef = (0, react_1.useRef)(null);
+    // Create client instance with callbacks
+    const client = (0, react_1.useMemo)(() => new phone_auth_1.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 = (0, react_1.useMemo)(() => client.isSupported(), [client]);
+    // Verify method with silent retry support
+    const verify = (0, react_1.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 = (0, react_1.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 = (0, react_1.useCallback)((options) => verify(Object.assign({ use_case: 'GetPhoneNumber' }, options)), [verify]);
+    const verifyPhoneNumber = (0, react_1.useCallback)((phoneNumber, options) => verify(Object.assign({ use_case: 'VerifyPhoneNumber', phone_number: phoneNumber }, options)), [verify]);
+    // Reset state
+    const reset = (0, react_1.useCallback)(() => {
+        setIsLoading(false);
+        setError(null);
+        setResult(null);
+        setCurrentStep('idle');
+    }, []);
+    // Expose granular methods directly from client for better discoverability
+    const preparePhoneRequest = (0, react_1.useCallback)((options) => client.preparePhoneRequest(options), [client]);
+    const invokeSecurePrompt = (0, react_1.useCallback)((prepareResponse) => client.invokeSecurePrompt(prepareResponse), [client]);
+    const getPhoneNumberCredential = (0, react_1.useCallback)((credentialResponse, session) => client.getPhoneNumber(credentialResponse, session), [client]);
+    const verifyPhoneNumberCredential = (0, react_1.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/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/adapters/vanilla/client.js

@@ -0,0 +1,33 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VanillaClient = void 0;
+const client_1 = require("../../core/client");
+class VanillaClient {
+    constructor(config) {
+        this.client = new client_1.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);
+        });
+    }
+}
+exports.VanillaClient = VanillaClient;

package/dist/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/adapters/vanilla/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorBreadcrumb = exports.serializeError = exports.isRetryableError = exports.getRetryDelay = exports.isErrorCode = exports.getUserMessage = exports.isUserError = exports.isPhoneAuthError = exports.PhoneAuthErrorCode = exports.PhoneAuthManager = exports.ClientManager = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "ClientManager", { enumerable: true, get: function () { return client_1.VanillaClient; } });
+var phone_auth_1 = require("./phone-auth");
+Object.defineProperty(exports, "PhoneAuthManager", { enumerable: true, get: function () { return phone_auth_1.PhoneAuthManager; } });
+// Export error utilities
+var phone_auth_2 = require("../../core/phone-auth");
+Object.defineProperty(exports, "PhoneAuthErrorCode", { enumerable: true, get: function () { return phone_auth_2.PhoneAuthErrorCode; } });
+Object.defineProperty(exports, "isPhoneAuthError", { enumerable: true, get: function () { return phone_auth_2.isPhoneAuthError; } });
+Object.defineProperty(exports, "isUserError", { enumerable: true, get: function () { return phone_auth_2.isUserError; } });
+Object.defineProperty(exports, "getUserMessage", { enumerable: true, get: function () { return phone_auth_2.getUserMessage; } });
+Object.defineProperty(exports, "isErrorCode", { enumerable: true, get: function () { return phone_auth_2.isErrorCode; } });
+Object.defineProperty(exports, "getRetryDelay", { enumerable: true, get: function () { return phone_auth_2.getRetryDelay; } });
+Object.defineProperty(exports, "isRetryableError", { enumerable: true, get: function () { return phone_auth_2.isRetryableError; } });
+Object.defineProperty(exports, "serializeError", { enumerable: true, get: function () { return phone_auth_2.serializeError; } });
+Object.defineProperty(exports, "createErrorBreadcrumb", { enumerable: true, get: function () { return phone_auth_2.createErrorBreadcrumb; } });