@glideidentity/web-client-sdk 5.0.1 → 5.1.1-beta.3

package/dist/esm/core/phone-auth/error-utils.d.ts

@@ -65,14 +65,43 @@ export declare const PhoneAuthErrorCode: {
 };
 export type PhoneAuthErrorCode = typeof PhoneAuthErrorCode[keyof typeof PhoneAuthErrorCode];
 import type { AuthError } from './types';
+/**
+ * Type guard to check if an error is a PhoneAuthError
+ */
 export declare function isPhoneAuthError(error: any): error is AuthError;
+/**
+ * Check if error should be shown to user
+ */
 export declare function isUserError(error: AuthError): boolean;
+/**
+ * Get user-friendly error message
+ */
 export declare function getUserMessage(error: AuthError): string;
+/**
+ * Check if error matches a specific code
+ */
 export declare function isErrorCode(error: AuthError, code: PhoneAuthErrorCode): boolean;
+/**
+ * Get retry delay for rate-limited requests
+ */
 export declare function getRetryDelay(error: AuthError): number | null;
+/**
+ * Check if error is retryable
+ */
 export declare function isRetryableError(error: AuthError): boolean;
+/**
+ * Parse error response from backend API
+ */
 export declare function parseBackendError(response: any): AuthError;
+/**
+ * Serialize error for logging/observability tools like Sentry
+ * This ensures all error details are captured in a format that can be sent over the network
+ */
 export declare function serializeError(error: AuthError): Record<string, any>;
+/**
+ * Create a breadcrumb trail for error tracking
+ * Useful for understanding the sequence of events leading to an error
+ */
 export declare function createErrorBreadcrumb(error: AuthError): {
     category: string;
     message: string;

package/dist/esm/core/phone-auth/error-utils.js

@@ -1,29 +1,36 @@
 import { SDK_VERSION } from '../version';
+// Error constants matching the backend for consistency
 export const PhoneAuthErrorCode = {
+    // 400 Bad Request errors
     BAD_REQUEST: 'BAD_REQUEST',
     VALIDATION_ERROR: 'VALIDATION_ERROR',
     INVALID_PARAMETERS: 'INVALID_PARAMETERS',
     MISSING_PARAMETERS: 'MISSING_PARAMETERS',
     INVALID_PHONE_NUMBER: 'INVALID_PHONE_NUMBER',
     INVALID_MCC_MNC: 'INVALID_MCC_MNC',
+    // 401 Unauthorized errors
     UNAUTHORIZED: 'UNAUTHORIZED',
     INVALID_CREDENTIALS: 'INVALID_CREDENTIALS',
     EXPIRED_TOKEN: 'EXPIRED_TOKEN',
     TOKEN_ACQUISITION_FAILED: 'TOKEN_ACQUISITION_FAILED',
     INVALID_API_KEY: 'INVALID_API_KEY',
     MISSING_AUTH_HEADER: 'MISSING_AUTH_HEADER',
+    // 403 Forbidden errors
     FORBIDDEN: 'FORBIDDEN',
     INSUFFICIENT_PERMISSIONS: 'INSUFFICIENT_PERMISSIONS',
     ACCESS_DENIED: 'ACCESS_DENIED',
+    // 404 Not Found errors
     NOT_FOUND: 'NOT_FOUND',
     RESOURCE_NOT_FOUND: 'RESOURCE_NOT_FOUND',
     SESSION_NOT_FOUND: 'SESSION_NOT_FOUND',
     CARRIER_NOT_FOUND: 'CARRIER_NOT_FOUND',
     ENDPOINT_NOT_FOUND: 'ENDPOINT_NOT_FOUND',
+    // 409 Conflict errors
     CONFLICT: 'CONFLICT',
     RESOURCE_ALREADY_EXISTS: 'RESOURCE_ALREADY_EXISTS',
     DUPLICATE_SESSION: 'DUPLICATE_SESSION',
     CONCURRENT_MODIFICATION: 'CONCURRENT_MODIFICATION',
+    // 422 Unprocessable Entity errors
     UNPROCESSABLE_ENTITY: 'UNPROCESSABLE_ENTITY',
     UNSUPPORTED_VERIFICATION: 'UNSUPPORTED_VERIFICATION',
     INVALID_VERIFICATION: 'INVALID_VERIFICATION',
@@ -39,117 +46,160 @@ export const PhoneAuthErrorCode = {
     INVALID_SESSION_STATE: 'INVALID_SESSION_STATE',
     PHONE_NUMBER_MISMATCH: 'PHONE_NUMBER_MISMATCH',
     INVALID_CREDENTIAL_FORMAT: 'INVALID_CREDENTIAL_FORMAT',
+    // 429 Too Many Requests errors
     RATE_LIMIT_EXCEEDED: 'RATE_LIMIT_EXCEEDED',
     TOO_MANY_REQUESTS: 'TOO_MANY_REQUESTS',
     QUOTA_EXCEEDED: 'QUOTA_EXCEEDED',
+    // 500 Internal Server errors
     INTERNAL_SERVER_ERROR: 'INTERNAL_SERVER_ERROR',
     CIRCUIT_BREAKER_CONFIGURATION_ERROR: 'CIRCUIT_BREAKER_CONFIGURATION_ERROR',
     DATABASE_ERROR: 'DATABASE_ERROR',
     CACHE_ERROR: 'CACHE_ERROR',
     SERIALIZATION_ERROR: 'SERIALIZATION_ERROR',
     CRYPTO_ERROR: 'CRYPTO_ERROR',
+    // 502 Bad Gateway errors
     BAD_GATEWAY: 'BAD_GATEWAY',
     UPSTREAM_ERROR: 'UPSTREAM_ERROR',
     INVALID_RESPONSE: 'INVALID_RESPONSE',
+    // 503 Service Unavailable errors
     SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE',
     DOWNSTREAM_SERVICE_ERROR: 'DOWNSTREAM_SERVICE_ERROR',
     PROVIDER_ERROR: 'PROVIDER_ERROR',
     CIRCUIT_BREAKER_OPEN: 'CIRCUIT_BREAKER_OPEN',
     MAINTENANCE_MODE: 'MAINTENANCE_MODE',
+    // 504 Gateway Timeout errors
     GATEWAY_TIMEOUT: 'GATEWAY_TIMEOUT',
     REQUEST_TIMEOUT: 'REQUEST_TIMEOUT',
     UPSTREAM_TIMEOUT: 'UPSTREAM_TIMEOUT',
     DEADLINE_EXCEEDED: 'DEADLINE_EXCEEDED',
+    // Browser-specific errors (never thrown by backend)
     BROWSER_NOT_SUPPORTED: 'BROWSER_NOT_SUPPORTED',
     USER_DENIED: 'USER_DENIED',
     NETWORK_ERROR: 'NETWORK_ERROR',
 };
+// User-facing error messages - NEVER expose carrier names or phone numbers
 const USER_ERROR_MESSAGES = {
+    // Privacy-conscious messages - no carrier/phone info exposed
     CARRIER_NOT_ELIGIBLE: 'Your carrier is not eligible for this verification method.',
     CARRIER_IDENTIFICATION_FAILED: 'Unable to identify carrier for the provided phone number.',
     CARRIER_NOT_FOUND: 'Carrier information not available.',
     UNSUPPORTED_CARRIER: 'This carrier is not supported.',
+    // Rate limiting
     RATE_LIMIT_EXCEEDED: 'Too many attempts. Please wait a moment and try again.',
     TOO_MANY_REQUESTS: 'Too many requests. Please slow down and try again.',
     QUOTA_EXCEEDED: 'Usage limit reached. Please try again later.',
+    // Session errors
     SESSION_NOT_FOUND: 'Your session has expired. Please start over.',
     INVALID_SESSION_STATE: 'Invalid session state. Please start over.',
     DUPLICATE_SESSION: 'A session already exists. Please complete or cancel it first.',
+    // Browser/platform errors
     BROWSER_NOT_SUPPORTED: 'Digital Credentials API is not available. Please enable the #web-identity-digital-credentials flag in chrome://flags',
     UNSUPPORTED_PLATFORM: 'This platform is not supported for authentication.',
     UNSUPPORTED_STRATEGY: 'This authentication method is not available.',
     USER_DENIED: 'Authentication was cancelled. Please try again when you\'re ready.',
+    // Service availability
     SERVICE_UNAVAILABLE: 'The service is temporarily unavailable. Please try again later.',
     CIRCUIT_BREAKER_OPEN: 'Service is experiencing issues. Please try again later.',
     MAINTENANCE_MODE: 'Service is under maintenance. Please try again later.',
     DOWNSTREAM_SERVICE_ERROR: 'A required service is unavailable. Please try again later.',
+    // Authentication errors
     TOKEN_ACQUISITION_FAILED: 'Failed to acquire authentication token. Please try again.',
     EXPIRED_TOKEN: 'Your authentication has expired. Please start over.',
     INVALID_CREDENTIALS: 'Invalid credentials provided.',
+    // Validation errors
     INVALID_PHONE_NUMBER: 'Please enter a valid phone number.',
     PHONE_NUMBER_MISMATCH: 'Phone number mismatch. Please verify your number.',
     INVALID_PARAMETERS: 'Invalid parameters provided.',
     MISSING_PARAMETERS: 'Required information is missing.',
     VALIDATION_ERROR: 'Validation failed. Please check your input.',
+    // Network errors
     NETWORK_ERROR: 'Network connection failed. Please check your connection and try again.',
     GATEWAY_TIMEOUT: 'Request timed out. Please try again.',
     REQUEST_TIMEOUT: 'Request timed out. Please try again.',
     DEADLINE_EXCEEDED: 'Operation took too long. Please try again.',
+    // Verification errors
     VERIFICATION_FAILED: 'Verification failed. Please try again.',
     INVALID_VERIFICATION: 'Invalid verification response.',
     INVALID_CREDENTIAL_FORMAT: 'Invalid credential format.',
+    // Generic fallbacks
     BAD_REQUEST: 'Invalid request. Please try again.',
     UNAUTHORIZED: 'Authentication required.',
     FORBIDDEN: 'Access denied.',
     NOT_FOUND: 'Resource not found.',
     INTERNAL_SERVER_ERROR: 'An error occurred. Please try again later.',
 };
+// Errors that should be shown to users vs logged internally
 const USER_FACING_ERRORS = new Set([
+    // Carrier errors (privacy-safe messages)
     'CARRIER_NOT_ELIGIBLE',
     'CARRIER_IDENTIFICATION_FAILED',
     'CARRIER_NOT_FOUND',
     'UNSUPPORTED_CARRIER',
+    // Rate limiting
     'RATE_LIMIT_EXCEEDED',
     'TOO_MANY_REQUESTS',
     'QUOTA_EXCEEDED',
+    // Browser/platform
     'BROWSER_NOT_SUPPORTED',
     'UNSUPPORTED_PLATFORM',
     'UNSUPPORTED_STRATEGY',
     'USER_DENIED',
+    // Session
     'SESSION_NOT_FOUND',
     'INVALID_SESSION_STATE',
     'EXPIRED_TOKEN',
+    // Service availability
     'SERVICE_UNAVAILABLE',
     'CIRCUIT_BREAKER_OPEN',
     'MAINTENANCE_MODE',
+    // Network
     'NETWORK_ERROR',
     'GATEWAY_TIMEOUT',
     'REQUEST_TIMEOUT',
+    // Validation
     'INVALID_PHONE_NUMBER',
     'PHONE_NUMBER_MISMATCH',
     'MISSING_PARAMETERS',
     'VALIDATION_ERROR',
 ]);
+/**
+ * Type guard to check if an error is a PhoneAuthError
+ */
 export function isPhoneAuthError(error) {
     return error &&
         typeof error.code === 'string' &&
         typeof error.message === 'string';
 }
+/**
+ * Check if error should be shown to user
+ */
 export function isUserError(error) {
     return USER_FACING_ERRORS.has(error.code);
 }
+/**
+ * Get user-friendly error message
+ */
 export function getUserMessage(error) {
     return USER_ERROR_MESSAGES[error.code] || 'An unexpected error occurred. Please try again.';
 }
+/**
+ * Check if error matches a specific code
+ */
 export function isErrorCode(error, code) {
     return error.code === code;
 }
+/**
+ * Get retry delay for rate-limited requests
+ */
 export function getRetryDelay(error) {
     if (error.code === PhoneAuthErrorCode.RATE_LIMIT_EXCEEDED && error.retryAfter) {
-        return error.retryAfter * 1000;
+        return error.retryAfter * 1000; // Convert to milliseconds
     }
     return null;
 }
+/**
+ * Check if error is retryable
+ */
 export function isRetryableError(error) {
     const retryableCodes = [
         PhoneAuthErrorCode.NETWORK_ERROR,
@@ -159,8 +209,12 @@ export function isRetryableError(error) {
     ];
     return retryableCodes.includes(error.code);
 }
+/**
+ * Parse error response from backend API
+ */
 export function parseBackendError(response) {
     var _a, _b;
+    // Direct error structure from backend
     if (response && typeof response === 'object' && (response.code || response.error)) {
         const errorCode = response.code || response.error;
         const error = {
@@ -170,15 +224,18 @@ export function parseBackendError(response) {
             requestId: response.requestId || response.request_id,
             timestamp: response.timestamp,
             details: response.details,
+            // Include trace info for observability
             traceId: response.trace_id || response.traceId,
             spanId: response.span_id || response.spanId,
             service: response.service
         };
+        // Extract retryAfter from details if present
         if ((_a = response.details) === null || _a === void 0 ? void 0 : _a.retryAfter) {
             error.retryAfter = response.details.retryAfter;
         }
         return error;
     }
+    // Handle HTTP response with error
     if (response && response.status) {
         const code = mapStatusToErrorCode(response.status);
         return {
@@ -188,12 +245,16 @@ export function parseBackendError(response) {
             requestId: (_b = response.headers) === null || _b === void 0 ? void 0 : _b['x-request-id']
         };
     }
+    // Default to unexpected error
     return {
         code: PhoneAuthErrorCode.INTERNAL_SERVER_ERROR,
         message: 'An unexpected error occurred',
         status: 500
     };
 }
+/**
+ * Map HTTP status to error code
+ */
 function mapStatusToErrorCode(status) {
     switch (status) {
         case 400: return PhoneAuthErrorCode.BAD_REQUEST;
@@ -210,35 +271,56 @@ function mapStatusToErrorCode(status) {
         default: return PhoneAuthErrorCode.INTERNAL_SERVER_ERROR;
     }
 }
+/**
+ * Serialize error for logging/observability tools like Sentry
+ * This ensures all error details are captured in a format that can be sent over the network
+ */
 export function serializeError(error) {
     return {
+        // Core error info
         code: error.code,
         message: error.message,
+        // Backend error details
         status: error.status,
         requestId: error.requestId,
         timestamp: error.timestamp,
+        // Trace context for distributed tracing
         traceId: error.traceId,
         spanId: error.spanId,
         service: error.service,
+        // Specific error fields
         retryAfter: error.retryAfter,
+        // Browser error details
         browserError: error.browserError,
+        // Context
         context: error.context,
+        // Additional details (sanitized - no sensitive info)
         details: sanitizeDetails(error.details),
+        // SDK metadata
         sdkVersion: SDK_VERSION,
         errorCapturedAt: new Date().toISOString()
     };
 }
+/**
+ * Sanitize error details to remove sensitive information
+ */
 function sanitizeDetails(details) {
     if (!details || typeof details !== 'object') {
         return details;
     }
+    // Clone the object
     const sanitized = JSON.parse(JSON.stringify(details));
+    // Remove sensitive fields
     const sensitiveFields = ['carrier', 'phone_number', 'mnc', 'mcc', 'carrier_name'];
     for (const field of sensitiveFields) {
         delete sanitized[field];
     }
     return sanitized;
 }
+/**
+ * Create a breadcrumb trail for error tracking
+ * Useful for understanding the sequence of events leading to an error
+ */
 export function createErrorBreadcrumb(error) {
     var _a, _b, _c;
     return {

package/dist/esm/core/phone-auth/index.d.ts

@@ -2,6 +2,6 @@ export { PhoneAuthClient } from './client';
 export * from './types';
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from './error-utils';
 export type { PhoneAuthErrorCode as PhoneAuthErrorCodeType } from './error-utils';
-export { validatePhoneNumber, validatePlmn, validateUseCaseRequirements, validateNonce } from './validation-utils';
+export { validatePhoneNumber, validatePlmn, validateUseCaseRequirements } from './validation-utils';
 export { MobileDebugConsole } from './ui/mobile-debug-console';
 export { isExtendedResponse, isCredential, isAuthCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, hasPollingControls, hasTrigger, isHeadlessResult, requiresPolling, requiresUserAction } from './type-guards';

package/dist/esm/core/phone-auth/index.js

@@ -1,6 +1,8 @@
 export { PhoneAuthClient } from './client';
 export * from './types';
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from './error-utils';
-export { validatePhoneNumber, validatePlmn, validateUseCaseRequirements, validateNonce } from './validation-utils';
+export { validatePhoneNumber, validatePlmn, validateUseCaseRequirements } from './validation-utils';
 export { MobileDebugConsole } from './ui/mobile-debug-console';
-export { isExtendedResponse, isCredential, isAuthCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, hasPollingControls, hasTrigger, isHeadlessResult, requiresPolling, requiresUserAction } from './type-guards';
+export { isExtendedResponse, isCredential, isAuthCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, hasPollingControls, hasTrigger, 
+// Deprecated aliases
+isHeadlessResult, requiresPolling, requiresUserAction } from './type-guards';

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

@@ -1,12 +1,69 @@
+/**
+ * Status Types for Public Status Endpoint
+ *
+ * These types define the response format for the public status endpoint
+ * Used for polling authentication status without exposing sensitive data
+ */
+/**
+ * Status values returned by the public endpoint (HTTP 200 only)
+ */
 export type AuthenticationStatus = 'pending' | 'completed';
+/**
+ * Authentication protocol/strategy used
+ */
 export type AuthenticationProtocol = 'ts43' | 'link' | 'desktop';
+/**
+ * Public Status Response (HTTP 200 OK)
+ *
+ * This response is only returned with HTTP 200 status code
+ * Failed/expired sessions return HTTP 4xx with ErrorResponse
+ *
+ * @example
+ * ```typescript
+ * // Public endpoint (no auth required)
+ * const response = await fetch('/public/public/status/{sessionKey}');
+ *
+ * if (response.status === 200) {
+ *   const status: StatusResponse = await response.json();
+ *   if (status.status === 'completed') {
+ *     // Authentication successful - now call process endpoint
+ *     const result = await processAuthentication(sessionKey);
+ *   }
+ * } else if (response.status === 410) {
+ *   // Session expired
+ * } else if (response.status === 422) {
+ *   // Authentication failed (user cancelled, etc.)
+ * }
+ * ```
+ */
 export interface StatusResponse {
+    /**
+     * The session key/identifier
+     */
     session_key: string;
+    /**
+     * Current status of the authentication (only successful states)
+     */
     status: AuthenticationStatus;
+    /**
+     * Protocol/strategy used for authentication
+     * Optional - may not be present during pending state
+     */
     protocol?: AuthenticationProtocol;
+    /**
+     * ISO 8601 timestamp when session was created
+     */
     created_at: string;
+    /**
+     * ISO 8601 timestamp of last status update
+     */
     last_updated: string;
 }
+/**
+ * Error Response (HTTP 4xx)
+ *
+ * Returned when session is expired, failed, or not found
+ */
 export interface StatusErrorResponse {
     code: 'SESSION_EXPIRED' | 'USER_CANCELLED' | 'AUTHENTICATION_FAILED' | 'SESSION_NOT_FOUND' | 'INVALID_SESSION_KEY';
     message: string;
@@ -19,11 +76,32 @@ export interface StatusErrorResponse {
         duration_seconds?: number;
     };
 }
+/**
+ * Type guard to check if authentication was successful
+ */
 export declare function isSuccessStatus(status: AuthenticationStatus): boolean;
+/**
+ * Helper to determine if polling should continue based on HTTP status
+ */
 export declare function shouldContinuePolling(httpStatus: number, response?: StatusResponse): boolean;
+/**
+ * Helper to determine if session is terminated based on HTTP status
+ */
 export declare function isTerminalHttpStatus(httpStatus: number): boolean;
+/**
+ * Session binding types for parent-child relationships
+ */
 export interface SessionBinding {
+    /**
+     * Parent session ID (desktop QR code session)
+     */
     parent_session_id?: string;
+    /**
+     * Child session ID (mobile authentication session)
+     */
     child_session_id?: string;
+    /**
+     * Whether this is a parent or child session
+     */
     session_type?: 'parent' | 'child';
 }

package/dist/esm/core/phone-auth/status-types.js

@@ -1,9 +1,26 @@
+/**
+ * Status Types for Public Status Endpoint
+ *
+ * These types define the response format for the public status endpoint
+ * Used for polling authentication status without exposing sensitive data
+ */
+/**
+ * Type guard to check if authentication was successful
+ */
 export function isSuccessStatus(status) {
     return status === 'completed';
 }
+/**
+ * Helper to determine if polling should continue based on HTTP status
+ */
 export function shouldContinuePolling(httpStatus, response) {
+    // Only continue if HTTP 200 and status is pending
     return httpStatus === 200 && (response === null || response === void 0 ? void 0 : response.status) === 'pending';
 }
+/**
+ * Helper to determine if session is terminated based on HTTP status
+ */
 export function isTerminalHttpStatus(httpStatus) {
+    // 410 Gone (expired), 422 Unprocessable (failed), 404 Not Found
     return httpStatus === 410 || httpStatus === 422 || httpStatus === 404;
 }

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

@@ -1,5 +1,13 @@
+/**
+ * Desktop Strategy Handler
+ * Handles QR code-based authentication for desktop browsers
+ * Manages QR code display and polling for authentication status
+ */
 import type { StrategyHandler } from './types';
 import type { PrepareResponse } from '../types';
+/**
+ * QR code data structure for dual-platform support
+ */
 export interface QRCodeData {
     iosQRCode: string;
     androidQRCode?: string;
@@ -7,24 +15,41 @@ export interface QRCodeData {
     androidUrl?: string;
 }
 export interface DesktopAuthOptions {
+    /** Custom polling interval in milliseconds (overrides server-provided value) */
     pollingInterval?: number;
+    /** Maximum polling attempts before timeout (default: 30 = 1 minute with 2s interval) */
     maxPollingAttempts?: number;
+    /** Custom polling endpoint (overrides backend-provided or uses configured endpoint) */
     pollingEndpoint?: string;
+    /** Developer environment (adds 'developer' header to requests) */
+    devEnv?: string;
+    /** Callback when QR code is ready to display */
     onQRCodeReady?: (qrCodeData: string | QRCodeData) => void;
+    /** Callback for polling status updates */
     onStatusUpdate?: (status: PollingStatus) => void;
+    /** Callback when authentication expires */
     onExpired?: () => void;
+    /** Callback when authentication is cancelled by user */
     onCancel?: () => void;
+    /** Callback when polling times out (max attempts reached) */
     onTimeout?: () => void;
 }
 export interface PollingStatus {
+    /** Current status of the authentication */
     status: 'pending' | 'authenticated' | 'expired' | 'cancelled' | 'error';
+    /** Optional message */
     message?: string;
+    /** Authentication result data if status is 'authenticated' */
     data?: any;
 }
 export interface DesktopAuthResult {
+    /** Whether authentication was successful */
     authenticated: boolean;
+    /** Authentication credential if successful */
     credential?: string;
+    /** Session info for subsequent requests */
     session?: any;
+    /** Error message if authentication failed */
     error?: string;
 }
 export declare class DesktopHandler implements StrategyHandler {
@@ -34,22 +59,62 @@ export declare class DesktopHandler implements StrategyHandler {
     private onCancel?;
     private pollingReject?;
     private isPollingInProgress;
+    /**
+     * Maps backend HTTP status codes to client status
+     * @param httpStatus HTTP status code from backend
+     * @param bodyStatus Optional status from response body (for 200 OK responses)
+     * @returns Mapped status string for client use
+     */
     private mapBackendStatus;
+    /**
+     * Invoke desktop authentication with QR code
+     * Returns QR code data for display and starts polling if endpoint is provided
+     */
     invoke(data: PrepareResponse, options?: DesktopAuthOptions): Promise<DesktopAuthResult>;
+    /**
+     * Start polling for authentication status
+     */
     private startPolling;
+    /**
+     * Stop polling
+     */
     private stopPolling;
+    /**
+     * Check if polling is currently active
+     */
     isPolling(): boolean;
+    /**
+     * Format response for backend processing
+     * Desktop strategy typically returns the credential from mobile authentication
+     */
     formatResponse(response: DesktopAuthResult): any;
+    /**
+     * Check if desktop authentication is supported
+     * Desktop auth with QR codes works in any modern browser
+     */
     isSupported(): boolean;
+    /**
+     * Clean up resources (stop polling if active)
+     */
     cleanup(): void;
+    /**
+     * Cancel the ongoing authentication
+     */
     cancel(): void;
 }
+/**
+ * Helper function to display QR code in a modal or inline
+ */
 export declare function createQRCodeDisplay(qrCodeData: string | QRCodeData, options?: {
     container?: HTMLElement;
     size?: number;
     title?: string;
     description?: string;
 }): HTMLElement;
+/**
+ * Helper function to create a modal for QR code display
+ * Supports both string QR codes and QRCodeData objects for dual-platform support
+ */
 export declare function showQRCodeModal(qrCodeData: string | QRCodeData, options?: {
     title?: string;
     description?: string;