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

package/dist/core/phone-auth/validation-utils.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Validation utilities for phone authentication
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePhoneNumber = validatePhoneNumber;
+exports.validatePlmn = validatePlmn;
+exports.validateUseCaseRequirements = validateUseCaseRequirements;
+exports.validateConsentData = validateConsentData;
+exports.createValidationError = createValidationError;
+exports.validateNonce = validateNonce;
+const api_types_1 = require("./api-types");
+/**
+ * Validates E.164 phone number format
+ * @param phoneNumber - Phone number to validate
+ * @returns Validation result with error if invalid
+ */
+function validatePhoneNumber(phoneNumber) {
+    if (!phoneNumber) {
+        return { valid: true }; // Phone number is optional for GetPhoneNumber
+    }
+    // E.164 format validation - strict, no cleaning
+    const e164Regex = /^\+[1-9]\d{1,14}$/;
+    if (!phoneNumber.startsWith('+')) {
+        return {
+            valid: false,
+            error: 'Phone number must be in E.164 format (start with +)'
+        };
+    }
+    if (phoneNumber.length < 8) {
+        return {
+            valid: false,
+            error: 'Phone number too short for E.164 format (minimum 8 characters including +)'
+        };
+    }
+    if (phoneNumber.length > 16) {
+        return {
+            valid: false,
+            error: 'Phone number too long for E.164 format (maximum 15 digits after +)'
+        };
+    }
+    // Check for any invalid characters (spaces, dashes, parentheses, etc.)
+    if (!/^\+\d+$/.test(phoneNumber)) {
+        return {
+            valid: false,
+            error: 'Phone number contains invalid characters. E.164 format only allows + followed by digits'
+        };
+    }
+    if (!e164Regex.test(phoneNumber)) {
+        return {
+            valid: false,
+            error: 'Invalid E.164 phone number format'
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Validates PLMN (MCC/MNC) values
+ * @param plmn - PLMN object with MCC and MNC
+ * @returns Validation result
+ */
+function validatePlmn(plmn) {
+    if (!plmn) {
+        return { valid: true }; // PLMN is optional
+    }
+    const { mcc, mnc } = plmn;
+    // MCC validation (3 digits) - no range check for telco labs
+    if (!mcc || !/^\d{3}$/.test(mcc)) {
+        return {
+            valid: false,
+            error: 'MCC must be exactly 3 digits'
+        };
+    }
+    // MNC validation (2 or 3 digits)
+    if (!mnc || !/^\d{2,3}$/.test(mnc)) {
+        return {
+            valid: false,
+            error: 'MNC must be 2 or 3 digits'
+        };
+    }
+    // No range validation - allowing unofficial MCCs for telco labs
+    return { valid: true };
+}
+/**
+ * Validates use case and phone number combination
+ * @param useCase - The use case
+ * @param phoneNumber - The phone number (required for VerifyPhoneNumber)
+ * @param hasParentSessionId - Whether parent_session_id is provided (allows skipping normal validation)
+ * @returns Validation result
+ */
+function validateUseCaseRequirements(useCase, phoneNumber, hasParentSessionId) {
+    // VerifyPhoneNumber requires a phone number (unless parent_session_id is provided)
+    if (useCase === api_types_1.USE_CASE.VERIFY_PHONE_NUMBER && !phoneNumber && !hasParentSessionId) {
+        return {
+            valid: false,
+            error: 'Phone number is required for VerifyPhoneNumber use case'
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Validates consent data
+ * @param consentData - Consent data object
+ * @returns Validation result
+ */
+function validateConsentData(consentData) {
+    if (!consentData) {
+        return { valid: true }; // Consent data is optional
+    }
+    const { consent_text: consentText, policy_link: policyLink, policy_text: policyText } = consentData;
+    if (!consentText || consentText.trim().length === 0) {
+        return {
+            valid: false,
+            error: 'Consent text is required when consent data is provided'
+        };
+    }
+    if (!policyLink || policyLink.trim().length === 0) {
+        return {
+            valid: false,
+            error: 'Policy link is required when consent data is provided'
+        };
+    }
+    // Validate URL format for policy link
+    try {
+        new URL(policyLink);
+    }
+    catch (_a) {
+        return {
+            valid: false,
+            error: 'Policy link must be a valid URL'
+        };
+    }
+    if (!policyText || policyText.trim().length === 0) {
+        return {
+            valid: false,
+            error: 'Policy text is required when consent data is provided'
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Creates a validation error
+ * @param code - Error code
+ * @param message - Error message
+ * @param field - Field that failed validation
+ */
+function createValidationError(code, message, field) {
+    const error = new Error(message);
+    error.code = code;
+    if (field) {
+        error.field = field;
+    }
+    return error;
+}
+/**
+ * Validates nonce format
+ * @param nonce - Nonce string to validate
+ * @returns Validation result
+ */
+function validateNonce(nonce) {
+    // Nonce should be base64url encoded and have reasonable length
+    const base64urlRegex = /^[A-Za-z0-9_-]+$/;
+    if (!nonce || nonce.length === 0) {
+        return {
+            valid: false,
+            error: 'Nonce is required'
+        };
+    }
+    if (!base64urlRegex.test(nonce)) {
+        return {
+            valid: false,
+            error: 'Nonce must be base64url encoded'
+        };
+    }
+    if (nonce.length < 32 || nonce.length > 128) {
+        return {
+            valid: false,
+            error: 'Nonce must be between 32 and 128 characters'
+        };
+    }
+    return { valid: true };
+}

package/dist/core/types.d.ts

@@ -0,0 +1,62 @@
+import { LogLevel, Logger } from './logger';
+export interface ClientConfig {
+    /**
+     * Base URL for API requests
+     * Required only if using useQuery() or client.get() methods
+     * Not required for phone authentication
+     */
+    baseURL?: string;
+    /**
+     * API key for authentication
+     * Currently not used in the SDK but kept for backward compatibility
+     */
+    apiKey?: string;
+    /**
+     * Request timeout in milliseconds
+     * @default 10000
+     */
+    timeout?: number;
+    /**
+     * Target origin for authentication
+     * Used for cross-origin authentication flows
+     * If not provided, uses baseURL or current origin
+     */
+    authTargetOrigin?: string;
+    /**
+     * Phone authentication endpoints
+     * If not provided, uses default endpoints relative to baseURL
+     */
+    phoneAuthEndpoints?: {
+        prepareRequest: string;
+        processResponse: string;
+    };
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Set specific log level
+     */
+    logLevel?: LogLevel;
+    /**
+     * Custom logger implementation
+     */
+    logger?: Logger;
+    /**
+     * Remote logging configuration
+     */
+    remoteLogging?: {
+        endpoint: string;
+        apiKey: string;
+    };
+}
+export interface RequestOptions {
+    headers?: Record<string, string>;
+    params?: Record<string, any>;
+}
+export interface ClientResponse<T = any> {
+    data: T;
+    status: number;
+    headers: Record<string, string>;
+}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "__SDK_VERSION__";

package/dist/core/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+// SDK version - injected at build time
+exports.SDK_VERSION = '4.4.8-beta.1';

package/dist/esm/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/esm/adapters/angular/client.service.js

@@ -0,0 +1,27 @@
+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);
+};
+import { Injectable } from '@angular/core';
+import { SDKClient } from '../../core/client';
+import { from } from 'rxjs';
+let ClientService = class ClientService {
+    constructor(config) {
+        this.client = new SDKClient(config);
+    }
+    query(path) {
+        return from(this.client.get(path));
+    }
+};
+ClientService = __decorate([
+    Injectable({
+        providedIn: 'root',
+    }),
+    __metadata("design:paramtypes", [Object])
+], ClientService);
+export { ClientService };

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

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

package/dist/esm/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/esm/adapters/angular/phone-auth.service.js

@@ -0,0 +1,127 @@
+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());
+    });
+};
+import { Injectable } from '@angular/core';
+import { PhoneAuthClient } from '../../core/phone-auth';
+import { BehaviorSubject } from 'rxjs';
+let PhoneAuthService = class PhoneAuthService {
+    constructor() {
+        // State subjects
+        this.isLoadingSubject = new BehaviorSubject(false);
+        this.errorSubject = new BehaviorSubject(null);
+        this.resultSubject = new BehaviorSubject(null);
+        this.currentStepSubject = new 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 PhoneAuthClient();
+    }
+    /**
+     * Configure the phone auth client
+     */
+    configure(config) {
+        this.client = new 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');
+    }
+};
+PhoneAuthService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    }),
+    __metadata("design:paramtypes", [])
+], PhoneAuthService);
+export { PhoneAuthService };

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

@@ -0,0 +1,8 @@
+export { usePhoneAuth } from './usePhoneAuth';
+export { useClient } from './useClient';
+// 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 the PhoneAuthClient class for direct use
+export { PhoneAuthClient } from '../../core/phone-auth';

package/dist/esm/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/esm/adapters/react/useClient.js

@@ -0,0 +1,116 @@
+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, useEffect, useCallback } from 'react';
+import { SDKClient } from '../../core/client';
+export function useClient(config) {
+    const [client] = useState(() => new SDKClient(config));
+    const [isAuthenticated, setIsAuthenticated] = useState(false);
+    const [token, setToken] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    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] = useState(null);
+        const [queryLoading, setQueryLoading] = useState(true);
+        const [queryError, setQueryError] = useState(null);
+        const fetchData = 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]);
+        useEffect(() => {
+            fetchData();
+        }, [fetchData]);
+        return { data, loading: queryLoading, error: queryError, refetch: fetchData };
+    };
+    const usePhoneAuth = () => {
+        const [phoneAuthResult, setPhoneAuthResult] = useState(null);
+        const [phoneAuthLoading, setPhoneAuthLoading] = useState(false);
+        const [phoneAuthError, setPhoneAuthError] = useState(null);
+        const [isSupported] = useState(() => client.phoneAuth.isSupported());
+        const getPhoneNumber = 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 = 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,
+    };
+}
+export { useClient as useReactClient } from './useClient';

package/dist/esm/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;
+};