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

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

@@ -0,0 +1,138 @@
+"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.PhoneAuthManager = void 0;
+const phone_auth_1 = require("../../core/phone-auth");
+class PhoneAuthManager {
+    constructor(config = {}) {
+        this.listeners = [];
+        this.client = new phone_auth_1.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;
+    }
+}
+exports.PhoneAuthManager = PhoneAuthManager;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_STATUS_CODES = exports.ERROR_MESSAGES = exports.ERROR_CODE = exports.USE_CASE = 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.PhoneAuthClient = exports.SDKClient = 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; } });
+var client_1 = require("../../core/client");
+Object.defineProperty(exports, "SDKClient", { enumerable: true, get: function () { return client_1.SDKClient; } });
+var phone_auth_1 = require("../../core/phone-auth");
+Object.defineProperty(exports, "PhoneAuthClient", { enumerable: true, get: function () { return phone_auth_1.PhoneAuthClient; } });
+// API response types are already exported via core/phone-auth/types
+// 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; } });
+// 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 API constants from api-types
+var api_types_1 = require("../../core/phone-auth/api-types");
+Object.defineProperty(exports, "USE_CASE", { enumerable: true, get: function () { return api_types_1.USE_CASE; } });
+Object.defineProperty(exports, "ERROR_CODE", { enumerable: true, get: function () { return api_types_1.ERROR_CODE; } });
+Object.defineProperty(exports, "ERROR_MESSAGES", { enumerable: true, get: function () { return api_types_1.ERROR_MESSAGES; } });
+Object.defineProperty(exports, "ERROR_STATUS_CODES", { enumerable: true, get: function () { return api_types_1.ERROR_STATUS_CODES; } });

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

@@ -0,0 +1,131 @@
+"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.useVueClient = void 0;
+exports.useClient = useClient;
+const vue_1 = require("vue");
+const client_1 = require("../../core/client");
+function useClient(config) {
+    const client = (0, vue_1.ref)(new client_1.SDKClient(config));
+    return {
+        client: client.value,
+        useQuery: (path) => {
+            const data = (0, vue_1.ref)(null);
+            const loading = (0, vue_1.ref)(true);
+            const error = (0, vue_1.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 = (0, vue_1.ref)(null);
+            const loading = (0, vue_1.ref)(false);
+            const error = (0, vue_1.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
+            (0, vue_1.onUnmounted)(() => {
+                if (cleanup) {
+                    cleanup();
+                    cleanup = null;
+                }
+            });
+            return {
+                token,
+                loading,
+                error,
+                authenticate
+            };
+        },
+        usePhoneAuth: () => {
+            const result = (0, vue_1.ref)(null);
+            const loading = (0, vue_1.ref)(false);
+            const error = (0, vue_1.ref)(null);
+            const isSupported = (0, vue_1.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
+            };
+        }
+    };
+}
+exports.useVueClient = useClient;

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

@@ -0,0 +1,94 @@
+import { PhoneAuthClient } from '../../core/phone-auth';
+import type { AuthConfig, AuthStep, PhoneAuthOptions } from '../../core/phone-auth';
+import * as API from '../../core/phone-auth/api-types';
+export interface UsePhoneAuthOptions extends AuthConfig {
+}
+export declare function usePhoneAuth(config?: UsePhoneAuthOptions): {
+    isLoading: Readonly<import("vue").Ref<boolean, boolean>>;
+    error: Readonly<import("vue").Ref<{
+        readonly code: import("../../core/phone-auth/types").PhoneAuthErrorCode;
+        readonly message: string;
+        readonly details?: any;
+        readonly status?: number | undefined;
+        readonly requestId?: string | undefined;
+        readonly timestamp?: string | undefined;
+        readonly traceId?: string | undefined;
+        readonly spanId?: string | undefined;
+        readonly service?: string | undefined;
+        readonly retryAfter?: number | undefined;
+        readonly browserError?: {
+            name: string;
+            message: string;
+            stack?: string;
+            code?: number;
+        } | undefined;
+        readonly context?: {
+            readonly [x: string]: any;
+            readonly step?: "prepare" | "prompt" | "process" | "complete" | undefined;
+            readonly useCase?: string | undefined;
+            readonly timestamp: string;
+            readonly userAgent?: string | undefined;
+            readonly url?: string | undefined;
+        } | undefined;
+    } | null, {
+        readonly code: import("../../core/phone-auth/types").PhoneAuthErrorCode;
+        readonly message: string;
+        readonly details?: any;
+        readonly status?: number | undefined;
+        readonly requestId?: string | undefined;
+        readonly timestamp?: string | undefined;
+        readonly traceId?: string | undefined;
+        readonly spanId?: string | undefined;
+        readonly service?: string | undefined;
+        readonly retryAfter?: number | undefined;
+        readonly browserError?: {
+            name: string;
+            message: string;
+            stack?: string;
+            code?: number;
+        } | undefined;
+        readonly context?: {
+            readonly [x: string]: any;
+            readonly step?: "prepare" | "prompt" | "process" | "complete" | undefined;
+            readonly useCase?: string | undefined;
+            readonly timestamp: string;
+            readonly userAgent?: string | undefined;
+            readonly url?: string | undefined;
+        } | undefined;
+    } | null>>;
+    result: Readonly<import("vue").Ref<{
+        readonly phone_number: API.PhoneNumber;
+        readonly aud?: string | undefined;
+    } | {
+        readonly phone_number: API.PhoneNumber;
+        readonly verified: boolean;
+        readonly aud?: string | undefined;
+    } | null, {
+        readonly phone_number: API.PhoneNumber;
+        readonly aud?: string | undefined;
+    } | {
+        readonly phone_number: API.PhoneNumber;
+        readonly verified: boolean;
+        readonly aud?: string | undefined;
+    } | null>>;
+    currentStep: Readonly<import("vue").Ref<AuthStep, AuthStep>>;
+    isSupported: Readonly<import("vue").Ref<boolean, boolean>>;
+    verify: (options: PhoneAuthOptions) => Promise<{
+        phone_number: API.PhoneNumber;
+        aud?: string | undefined;
+    }>;
+    getPhoneNumber: (options?: Omit<PhoneAuthOptions, "use_case" | "phone_number">) => Promise<{
+        phone_number: API.PhoneNumber;
+        aud?: string | undefined;
+    }>;
+    verifyPhoneNumber: (phoneNumber: string, options?: Omit<PhoneAuthOptions, "use_case" | "phone_number">) => Promise<{
+        phone_number: API.PhoneNumber;
+        aud?: string | undefined;
+    }>;
+    reset: () => void;
+    preparePhoneRequest: (options: PhoneAuthOptions) => Promise<API.PrepareResponse>;
+    invokeSecurePrompt: (prepareResponse: API.PrepareResponse, options?: API.InvokeOptions | import("../..").DesktopAuthOptions) => Promise<API.SecureCredentialResponse["vp_token"] | API.HeadlessResult>;
+    getPhoneNumberCredential: (credentialResponse: API.SecureCredentialResponse["vp_token"] | string, session: API.SessionInfo) => Promise<API.GetPhoneNumberResponse>;
+    verifyPhoneNumberCredential: (credentialResponse: API.SecureCredentialResponse["vp_token"] | string, session: API.SessionInfo) => Promise<API.VerifyPhoneNumberResponse>;
+    client: PhoneAuthClient;
+};