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

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

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requiresUserAction = exports.requiresPolling = exports.getStrategy = exports.isDesktopStrategy = exports.isTS43Strategy = exports.isLinkStrategy = exports.isCredential = exports.isHeadlessResult = exports.MobileDebugConsole = exports.validateNonce = exports.validateConsentData = exports.validateUseCaseRequirements = exports.validatePlmn = exports.validatePhoneNumber = exports.createErrorBreadcrumb = exports.serializeError = exports.isRetryableError = exports.getRetryDelay = exports.isErrorCode = exports.getUserMessage = exports.isUserError = exports.isPhoneAuthError = exports.PhoneAuthErrorCode = exports.PhoneAuthClient = void 0;
+exports.requiresUserAction = exports.requiresPolling = exports.isHeadlessResult = exports.hasTrigger = exports.hasPollingControls = exports.getStrategy = exports.isDesktopStrategy = exports.isTS43Strategy = exports.isLinkStrategy = exports.isAuthCredential = exports.isCredential = exports.isExtendedResponse = exports.MobileDebugConsole = exports.validateNonce = exports.validateConsentData = exports.validateUseCaseRequirements = exports.validatePlmn = exports.validatePhoneNumber = exports.createErrorBreadcrumb = exports.serializeError = exports.isRetryableError = exports.getRetryDelay = exports.isErrorCode = exports.getUserMessage = exports.isUserError = exports.isPhoneAuthError = exports.PhoneAuthErrorCode = exports.PhoneAuthClient = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "PhoneAuthClient", { enumerable: true, get: function () { return client_1.PhoneAuthClient; } });
 __exportStar(require("./types"), exports);
@@ -37,11 +37,16 @@ Object.defineProperty(exports, "validateNonce", { enumerable: true, get: functio
 var mobile_debug_console_1 = require("./ui/mobile-debug-console");
 Object.defineProperty(exports, "MobileDebugConsole", { enumerable: true, get: function () { return mobile_debug_console_1.MobileDebugConsole; } });
 var type_guards_1 = require("./type-guards");
-Object.defineProperty(exports, "isHeadlessResult", { enumerable: true, get: function () { return type_guards_1.isHeadlessResult; } });
+Object.defineProperty(exports, "isExtendedResponse", { enumerable: true, get: function () { return type_guards_1.isExtendedResponse; } });
 Object.defineProperty(exports, "isCredential", { enumerable: true, get: function () { return type_guards_1.isCredential; } });
+Object.defineProperty(exports, "isAuthCredential", { enumerable: true, get: function () { return type_guards_1.isAuthCredential; } });
 Object.defineProperty(exports, "isLinkStrategy", { enumerable: true, get: function () { return type_guards_1.isLinkStrategy; } });
 Object.defineProperty(exports, "isTS43Strategy", { enumerable: true, get: function () { return type_guards_1.isTS43Strategy; } });
 Object.defineProperty(exports, "isDesktopStrategy", { enumerable: true, get: function () { return type_guards_1.isDesktopStrategy; } });
 Object.defineProperty(exports, "getStrategy", { enumerable: true, get: function () { return type_guards_1.getStrategy; } });
+Object.defineProperty(exports, "hasPollingControls", { enumerable: true, get: function () { return type_guards_1.hasPollingControls; } });
+Object.defineProperty(exports, "hasTrigger", { enumerable: true, get: function () { return type_guards_1.hasTrigger; } });
+// Deprecated aliases
+Object.defineProperty(exports, "isHeadlessResult", { enumerable: true, get: function () { return type_guards_1.isHeadlessResult; } });
 Object.defineProperty(exports, "requiresPolling", { enumerable: true, get: function () { return type_guards_1.requiresPolling; } });
 Object.defineProperty(exports, "requiresUserAction", { enumerable: true, get: function () { return type_guards_1.requiresUserAction; } });

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

@@ -55,6 +55,7 @@ export declare class DesktopHandler implements StrategyHandler {
     private pollingAttempts;
     private isCancelled;
     private onCancel?;
+    private pollingReject?;
     /**
      * Maps backend HTTP status codes to client status
      * @param httpStatus HTTP status code from backend

package/dist/core/phone-auth/strategies/desktop.js

@@ -62,7 +62,20 @@ class DesktopHandler {
             if (desktopData && desktopData.data && typeof desktopData.data === 'object') {
                 const innerData = desktopData.data;
                 // Try to extract from inner data
-                qrCode = innerData.qr_code_image || innerData.qr_code;
+                // Support both single QR (qr_code_image) and dual-platform QR (ios/android)
+                if (innerData.ios_qr_image || innerData.android_qr_image) {
+                    // Dual-platform QR format
+                    qrCode = {
+                        iosQRCode: innerData.ios_qr_image,
+                        androidQRCode: innerData.android_qr_image,
+                        iosUrl: innerData.ios_url,
+                        androidUrl: innerData.android_url
+                    };
+                }
+                else {
+                    // Single QR format (legacy)
+                    qrCode = innerData.qr_code_image || innerData.qr_code;
+                }
                 sessionId = innerData.session_id;
                 pollingEndpoint = innerData.status_url;
                 pollingInterval = innerData.polling_interval;
@@ -89,33 +102,44 @@ class DesktopHandler {
                 options.onQRCodeReady(qrCode);
             }
             // Use polling endpoint with this priority:
-            // 1. Developer-provided endpoint from options
+            // 1. Developer-provided endpoint from options (highest priority)
             // 2. Backend-provided endpoint
-            // 3. Error if none available
-            const finalPollingEndpoint = (options === null || options === void 0 ? void 0 : options.pollingEndpoint) || pollingEndpoint;
-            // If no polling endpoint available, return QR code data and let the app handle the rest
+            // 3. Hardcoded fallback
+            console.log('[Desktop QR] Polling endpoint selection:');
+            console.log('  - options?.pollingEndpoint:', options === null || options === void 0 ? void 0 : options.pollingEndpoint);
+            console.log('  - backend pollingEndpoint:', pollingEndpoint);
+            let finalPollingEndpoint = options === null || options === void 0 ? void 0 : options.pollingEndpoint;
+            let endpointSource = 'options';
             if (!finalPollingEndpoint) {
-                return {
-                    authenticated: false,
-                    session: data.session,
-                    error: 'No polling endpoint provided - configure endpoints.polling or ensure backend provides status_url'
-                };
+                finalPollingEndpoint = pollingEndpoint; // Backend-provided status_url
+                endpointSource = 'backend';
             }
+            if (!finalPollingEndpoint) {
+                // Use hardcoded fallback - this will be constructed in the polling function
+                console.log('[Desktop QR] No polling endpoint provided, will use hardcoded fallback');
+                endpointSource = 'fallback';
+            }
+            console.log('[Desktop QR] Selected endpoint:', finalPollingEndpoint, 'from source:', endpointSource);
             // Start polling for authentication status
             const finalPollingInterval = (options === null || options === void 0 ? void 0 : options.pollingInterval) || pollingInterval || 2000;
             const maxAttempts = (options === null || options === void 0 ? void 0 : options.maxPollingAttempts) || 150; // Default to 5 minutes
-            return this.startPolling(finalPollingEndpoint, sessionId, finalPollingInterval, maxAttempts, expiresIn || 300, // Default 5 minutes expiry
-            options);
+            console.log(`[Desktop QR] Starting polling - endpoint source: ${endpointSource}, interval: ${finalPollingInterval}ms, max attempts: ${maxAttempts}`);
+            return this.startPolling(finalPollingEndpoint || '', // Pass empty string if undefined, will use fallback
+            sessionId, finalPollingInterval, maxAttempts, expiresIn || 300, // Default 5 minutes expiry
+            options, endpointSource // Pass the endpoint source for logging
+            );
         });
     }
     /**
      * Start polling for authentication status
      */
-    startPolling(endpoint, sessionId, interval, maxAttempts, expiresIn, options) {
-        return __awaiter(this, void 0, void 0, function* () {
+    startPolling(endpoint_1, sessionId_1, interval_1, maxAttempts_1, expiresIn_1, options_1) {
+        return __awaiter(this, arguments, void 0, function* (endpoint, sessionId, interval, maxAttempts, expiresIn, options, endpointSource = 'unknown') {
             const startTime = Date.now();
             const expiryTime = startTime + (expiresIn * 1000);
             return new Promise((resolve, reject) => {
+                // Store the reject function so we can call it from cancel()
+                this.pollingReject = reject;
                 const poll = () => __awaiter(this, void 0, void 0, function* () {
                     try {
                         // Check if cancelled
@@ -130,9 +154,10 @@ class DesktopHandler {
                                     message: 'Authentication cancelled'
                                 });
                             }
-                            resolve({
-                                authenticated: false,
-                                error: 'Authentication cancelled'
+                            // Reject the promise with a cancellation error
+                            reject({
+                                code: 'USER_DENIED',
+                                message: 'Authentication cancelled by user'
                             });
                             return;
                         }
@@ -180,12 +205,19 @@ class DesktopHandler {
                             const url = new URL(endpoint);
                             statusUrl = `${url.protocol}//${url.host}/public/public/status/${sessionId}`;
                         }
+                        else if (endpoint && endpoint !== '') {
+                            // Relative path provided (e.g. '/api/phone-auth/status')
+                            // Append session ID to the provided endpoint
+                            statusUrl = `${endpoint}/${sessionId}`;
+                        }
                         else {
-                            // Use relative path that will be proxied through the app's server
+                            // No endpoint provided - use hardcoded fallback
                             // This ensures it goes through the same domain and uses the app's API configuration
                             statusUrl = `/api/phone-auth/status/${sessionId}`;
                         }
                         // Poll the public endpoint - no authentication required
+                        console.log(`[Desktop QR] Polling status (attempt ${this.pollingAttempts}/${maxAttempts})`);
+                        console.log(`[Desktop QR] Using ${endpointSource} endpoint: ${statusUrl}`);
                         const response = yield fetch(statusUrl, {
                             method: 'GET',
                             headers: {
@@ -193,6 +225,7 @@ class DesktopHandler {
                                 // No Authorization header needed for public endpoint
                             }
                         });
+                        console.log(`[Desktop QR] Status response: ${response.status} ${response.statusText}`);
                         // Backend Status Code Mapping:
                         // - 200 OK: Session exists (body has 'pending' or 'completed' status)
                         // - 410 Gone: Session expired after timeout
@@ -220,6 +253,7 @@ class DesktopHandler {
                                     });
                                 }
                                 // Return the session data for next steps
+                                this.pollingReject = undefined; // Clear the reject function on success
                                 resolve({
                                     authenticated: true,
                                     credential: result.credential || result.session_key || sessionId,
@@ -344,10 +378,12 @@ class DesktopHandler {
      */
     stopPolling() {
         if (this.pollingIntervalId) {
+            console.log('[Desktop QR] Stopping polling');
             clearInterval(this.pollingIntervalId);
             this.pollingIntervalId = undefined;
         }
         this.pollingAttempts = 0;
+        // Don't clear pollingReject here - it's needed by cancel()
     }
     /**
      * Format response for backend processing
@@ -379,15 +415,25 @@ class DesktopHandler {
         this.stopPolling();
         this.isCancelled = false;
         this.onCancel = undefined;
+        this.pollingReject = undefined;
     }
     /**
      * Cancel the ongoing authentication
      */
     cancel() {
         var _a;
+        console.log('[Desktop QR] Cancelling authentication');
         this.isCancelled = true;
         this.stopPolling();
         (_a = this.onCancel) === null || _a === void 0 ? void 0 : _a.call(this);
+        // Immediately reject the polling promise
+        if (this.pollingReject) {
+            this.pollingReject({
+                code: 'USER_DENIED',
+                message: 'Authentication cancelled by user'
+            });
+            this.pollingReject = undefined;
+        }
     }
 }
 exports.DesktopHandler = DesktopHandler;

package/dist/core/phone-auth/strategies/link.js

@@ -26,12 +26,21 @@ class LinkHandler {
      */
     invoke(data, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            console.log('[Link Auth] 🔗 SDK Version: 4.4.8-beta.2 (with enhanced error logging)');
+            console.log('[Link Auth] 🔗 invoke() called with data:', JSON.stringify(data, null, 2));
+            console.log('[Link Auth] Options:', options ? JSON.stringify({
+                pollingInterval: options.pollingInterval,
+                maxPollingAttempts: options.maxPollingAttempts,
+                pollingEndpoint: options.pollingEndpoint
+            }) : 'none');
             // Extract link data from prepare response
             const linkData = data.data;
             if (!linkData || !linkData.url) {
                 throw new Error('Invalid link data: missing URL');
             }
             const sessionKey = data.session.session_key;
+            console.log('[Link Auth] Session key:', sessionKey);
+            console.log('[Link Auth] Link URL:', linkData.url);
             // Open authentication app without navigating away from current page
             this.openAuthenticationLink(linkData.url);
             // Notify that link was opened
@@ -63,12 +72,19 @@ class LinkHandler {
             const interval = (options === null || options === void 0 ? void 0 : options.pollingInterval) || 2000; // Fixed 2 second interval
             const maxAttempts = (options === null || options === void 0 ? void 0 : options.maxPollingAttempts) || 150; // 5 minutes with 2s interval
             let attempts = 0;
+            console.log('[Link Auth] 🚀 Starting polling:', {
+                sessionKey,
+                interval: `${interval}ms`,
+                maxAttempts,
+                linkDataAvailable: !!linkData
+            });
             return new Promise((resolve, reject) => {
                 this.isPolling = true;
                 const poll = () => __awaiter(this, void 0, void 0, function* () {
                     if (!this.isPolling) {
                         return; // Polling was stopped
                     }
+                    let statusUrl = ''; // Declare at function scope for catch block access
                     try {
                         attempts++;
                         // Check max attempts
@@ -87,16 +103,54 @@ class LinkHandler {
                             return;
                         }
                         // Build public status endpoint URL
-                        let statusUrl;
-                        // First priority: use status_url from link data if provided
-                        if (linkData.status_url) {
-                            statusUrl = linkData.status_url;
-                            console.log('[Link Auth] Using status URL from link data:', statusUrl);
+                        // Use the same priority logic as Desktop strategy:
+                        // 1. options?.pollingEndpoint (already contains invoke options OR client config from client.ts)
+                        // 2. Backend-provided status_url from linkData
+                        // 3. Hardcoded fallback to API server
+                        let endpoint = options === null || options === void 0 ? void 0 : options.pollingEndpoint;
+                        let endpointSource = 'options';
+                        if (!endpoint && linkData.status_url) {
+                            endpoint = linkData.status_url;
+                            endpointSource = 'backend';
+                        }
+                        console.log('[Link Auth] Polling endpoint selection:');
+                        console.log('  - options?.pollingEndpoint:', options === null || options === void 0 ? void 0 : options.pollingEndpoint);
+                        console.log('  - linkData.status_url:', linkData.status_url);
+                        console.log('  - selected endpoint:', endpoint, 'from source:', endpointSource);
+                        // Build the status URL based on endpoint format (same as Desktop)
+                        if (endpoint && (endpoint.startsWith('http://') || endpoint.startsWith('https://'))) {
+                            // Full URL provided
+                            if (endpoint.includes('{{session_id}}')) {
+                                statusUrl = endpoint.replace('{{session_id}}', sessionKey);
+                            }
+                            else if (!endpoint.includes(sessionKey)) {
+                                // If it doesn't already contain the session ID, check if it's a base URL
+                                const url = new URL(endpoint);
+                                statusUrl = `${url.protocol}//${url.host}/public/public/status/${sessionKey}`;
+                            }
+                            else {
+                                statusUrl = endpoint;
+                            }
+                        }
+                        else if (endpoint && endpoint !== '') {
+                            // Relative path provided (e.g. '/api/phone-auth/status')
+                            const origin = typeof window !== 'undefined' ? window.location.origin : '';
+                            if (endpoint.includes('{{session_id}}')) {
+                                statusUrl = origin + endpoint.replace('{{session_id}}', sessionKey);
+                            }
+                            else {
+                                // Append session ID to the provided endpoint
+                                statusUrl = origin + endpoint + '/' + sessionKey;
+                            }
                         }
                         else {
+                            // No endpoint provided - use hardcoded fallback
                             statusUrl = `https://api.glideidentity.app/public/public/status/${sessionKey}`;
+                            endpointSource = 'fallback';
                         }
+                        console.log(`[Link Auth] Using ${endpointSource} endpoint: ${statusUrl}`);
                         // Poll public status endpoint - no authentication required
+                        console.log(`[Link Auth] Polling status (attempt ${attempts}/${maxAttempts}): ${statusUrl}`);
                         const response = yield fetch(statusUrl, {
                             method: 'GET',
                             headers: {
@@ -104,12 +158,16 @@ class LinkHandler {
                                 // No Authorization header needed for public endpoint
                             }
                         });
+                        console.log(`[Link Auth] Poll response - Status: ${response.status}, OK: ${response.ok}`);
                         // Handle based on HTTP status code
                         if (response.status === 200) {
                             // Session is active (pending or completed)
                             const result = yield response.json();
+                            console.log('[Link Auth] Poll response data:', JSON.stringify(result, null, 2));
                             if (result.status === 'completed') {
                                 // Authentication completed successfully
+                                console.log('[Link Auth] ✅ Authentication COMPLETED! Session:', sessionKey);
+                                console.log('[Link Auth] Full completion result:', JSON.stringify(result, null, 2));
                                 this.stopPolling();
                                 // Authentication completed successfully
                                 if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
@@ -134,6 +192,7 @@ class LinkHandler {
                             }
                             else if (result.status === 'pending') {
                                 // Continue polling
+                                console.log('[Link Auth] Status still pending, continuing to poll...');
                                 if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
                                     options.onStatusUpdate({
                                         status: 'pending',
@@ -141,9 +200,14 @@ class LinkHandler {
                                     });
                                 }
                             }
+                            else {
+                                // Unexpected status value
+                                console.log('[Link Auth] ⚠️ Unexpected status value:', result.status, 'Full result:', JSON.stringify(result, null, 2));
+                            }
                         }
                         else if (response.status === 410) {
                             // Session expired
+                            console.log('[Link Auth] ❌ Session expired (410)');
                             this.stopPolling();
                             const errorData = yield response.json().catch(() => ({ message: 'Session expired' }));
                             if (options === null || options === void 0 ? void 0 : options.onTimeout) {
@@ -159,8 +223,10 @@ class LinkHandler {
                         }
                         else if (response.status === 422) {
                             // Authentication failed
+                            console.log('[Link Auth] ❌ Authentication failed (422)');
                             this.stopPolling();
                             const errorData = yield response.json().catch(() => ({ message: 'Authentication failed' }));
+                            console.log('[Link Auth] Error data:', JSON.stringify(errorData, null, 2));
                             const isUserCancelled = errorData.code === 'USER_CANCELLED';
                             const errorMsg = isUserCancelled
                                 ? 'User cancelled authentication'
@@ -176,6 +242,7 @@ class LinkHandler {
                         }
                         else if (response.status === 404) {
                             // Session not found
+                            console.log('[Link Auth] ❌ Session not found (404)');
                             this.stopPolling();
                             if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
                                 options.onStatusUpdate({
@@ -187,16 +254,40 @@ class LinkHandler {
                         }
                         else if (response.status === 400) {
                             // Invalid session key
+                            console.log('[Link Auth] ❌ Invalid session key (400)');
                             this.stopPolling();
                             const errorData = yield response.json().catch(() => ({ message: 'Invalid session key' }));
+                            console.log('[Link Auth] Error data:', JSON.stringify(errorData, null, 2));
                             reject(new Error(errorData.message || 'Invalid session key'));
                         }
                         else {
                             // Unexpected status - continue polling
+                            console.log('[Link Auth] ⚠️ Unexpected HTTP status:', response.status, 'continuing to poll...');
+                            try {
+                                const body = yield response.text();
+                                console.log('[Link Auth] Response body:', body);
+                            }
+                            catch (e) {
+                                console.log('[Link Auth] Could not read response body');
+                            }
                         }
                     }
                     catch (error) {
                         // Network or other error - continue polling
+                        console.error('[Link Auth] 🔴 Polling error:', error.message || error);
+                        console.error('[Link Auth] Error details:', {
+                            name: error.name,
+                            message: error.message,
+                            stack: error.stack,
+                            statusUrl: statusUrl,
+                            attempt: attempts,
+                            error: error
+                        });
+                        // Check if it's a CORS error (common on mobile)
+                        if (error.message && error.message.toLowerCase().includes('failed')) {
+                            console.error('[Link Auth] ⚠️ Possible CORS issue. Status URL:', statusUrl);
+                            console.error('[Link Auth] Make sure the API endpoint allows CORS from your ngrok domain');
+                        }
                         if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
                             options.onStatusUpdate({
                                 status: 'pending',
@@ -216,6 +307,7 @@ class LinkHandler {
      * Stop polling
      */
     stopPolling() {
+        console.log('[Link Auth] 🏁 Stopping polling');
         this.isPolling = false;
         if (this.pollingInterval) {
             clearInterval(this.pollingInterval);

package/dist/core/phone-auth/type-guards.d.ts

@@ -4,29 +4,29 @@
  * These utilities help developers work with the SDK responses in a type-safe way
  * without having to write their own type checking logic.
  */
-import type { HeadlessResult } from './api-types';
+import type { AnyExtendedResponse, DesktopExtendedResponse, LinkExtendedResponse, TS43ExtendedResponse, AuthCredential } from './api-types';
 /**
- * Type guard to check if the result is a HeadlessResult (headless mode)
- * or a Credential (UI mode).
+ * Type guard to check if the result is an ExtendedResponse (extended mode)
+ * or a Credential (standard mode).
  *
  * @example
  * ```typescript
- * const result = await invokeSecurePrompt(sdkRequest);
+ * const result = await invokeSecurePrompt(sdkRequest, { executionMode: 'extended' });
  *
- * if (isHeadlessResult(result)) {
- *   // TypeScript knows this is HeadlessResult
+ * if (isExtendedResponse(result)) {
+ *   // TypeScript knows this is ExtendedResponse
  *   console.log(result.strategy);
- *   await result.trigger();
+ *   await result.cancel();
  * } else {
  *   // TypeScript knows this is a Credential
  *   const processedResult = await verifyPhoneNumberCredential(result, session);
  * }
  * ```
  */
-export declare function isHeadlessResult(result: any): result is HeadlessResult;
+export declare function isExtendedResponse(result: any): result is AnyExtendedResponse;
 /**
- * Type guard to check if the result is a Credential (UI mode response).
- * A credential is either a string token or an object without HeadlessResult properties.
+ * Type guard to check if the result is a Credential (standard mode response).
+ * A credential is either a string token or an object without ExtendedResponse properties.
  *
  * @example
  * ```typescript
@@ -40,55 +40,61 @@ export declare function isCredential(result: any): result is string | {
     [aggregator_id: string]: string | string[];
 };
 /**
- * Type guard to check if a HeadlessResult is using the Link strategy.
+ * Type guard to check if the result is an AuthCredential object.
+ *
+ * @example
+ * ```typescript
+ * if (isAuthCredential(result)) {
+ *   console.log(result.credential);
+ *   console.log(result.authenticated);
+ * }
+ * ```
+ */
+export declare function isAuthCredential(result: any): result is AuthCredential;
+/**
+ * Type guard to check if an ExtendedResponse is using the Link strategy.
  * Link strategy involves opening an app link (App Clip on iOS, app on Android).
  *
  * @example
  * ```typescript
- * if (isHeadlessResult(result) && isLinkStrategy(result)) {
- *   // Show custom button for opening app
- *   myButton.onclick = () => result.trigger();
- *   await result.pollingPromise;
+ * if (isExtendedResponse(result) && isLinkStrategy(result)) {
+ *   // Re-trigger app opening if needed
+ *   result.trigger();
+ *   await result.credential;
  * }
  * ```
  */
-export declare function isLinkStrategy(result: HeadlessResult): result is HeadlessResult & {
-    strategy: 'link';
-};
+export declare function isLinkStrategy(result: AnyExtendedResponse): result is LinkExtendedResponse;
 /**
- * Type guard to check if a HeadlessResult is using the TS43 strategy.
+ * Type guard to check if an ExtendedResponse is using the TS43 strategy.
  * TS43 strategy uses the browser's Digital Credentials API.
  *
  * @example
  * ```typescript
- * if (isHeadlessResult(result) && isTS43Strategy(result)) {
- *   // Invoke credential API immediately or on button click
- *   const credential = await result.trigger();
+ * if (isExtendedResponse(result) && isTS43Strategy(result)) {
+ *   // Re-trigger credential request if needed
+ *   await result.trigger();
  * }
  * ```
  */
-export declare function isTS43Strategy(result: HeadlessResult): result is HeadlessResult & {
-    strategy: 'ts43';
-};
+export declare function isTS43Strategy(result: AnyExtendedResponse): result is TS43ExtendedResponse;
 /**
- * Type guard to check if a HeadlessResult is using the Desktop strategy.
+ * Type guard to check if an ExtendedResponse is using the Desktop strategy.
  * Desktop strategy involves QR codes for cross-device authentication.
  *
  * @example
  * ```typescript
- * if (isHeadlessResult(result) && isDesktopStrategy(result)) {
+ * if (isExtendedResponse(result) && isDesktopStrategy(result)) {
  *   // Show custom QR code UI
- *   displayQRCode(result.qrCodeUrl);
- *   await result.pollingPromise;
+ *   displayQRCode(result.qr_code_data);
+ *   await result.start_polling();
  * }
  * ```
  */
-export declare function isDesktopStrategy(result: HeadlessResult): result is HeadlessResult & {
-    strategy: 'desktop';
-};
+export declare function isDesktopStrategy(result: AnyExtendedResponse): result is DesktopExtendedResponse;
 /**
  * Helper function to safely get the authentication strategy from any result.
- * Returns undefined if the result is not a HeadlessResult.
+ * Returns undefined if the result is not an ExtendedResponse.
  *
  * @example
  * ```typescript
@@ -100,26 +106,38 @@ export declare function isDesktopStrategy(result: HeadlessResult): result is Hea
  */
 export declare function getStrategy(result: any): 'link' | 'ts43' | 'desktop' | undefined;
 /**
- * Helper function to determine if a result requires polling.
- * Link and Desktop strategies require polling, TS43 does not.
+ * Helper function to determine if a result has polling controls.
+ * Link and Desktop strategies have polling controls in extended mode.
  *
  * @example
  * ```typescript
- * if (requiresPolling(result)) {
- *   await result.pollingPromise;
+ * if (hasPollingControls(result)) {
+ *   await result.start_polling();
  * }
  * ```
  */
-export declare function requiresPolling(result: any): boolean;
+export declare function hasPollingControls(result: any): boolean;
 /**
- * Helper function to determine if a result requires user interaction.
- * All headless strategies require some form of user interaction.
+ * Helper function to determine if a result has a trigger method.
+ * Link and TS43 strategies have trigger methods in extended mode.
  *
  * @example
  * ```typescript
- * if (requiresUserAction(result)) {
- *   showActionButton();
+ * if (hasTrigger(result)) {
+ *   result.trigger();
  * }
  * ```
  */
-export declare function requiresUserAction(result: any): boolean;
+export declare function hasTrigger(result: any): boolean;
+/**
+ * @deprecated Use isExtendedResponse instead
+ */
+export declare const isHeadlessResult: typeof isExtendedResponse;
+/**
+ * @deprecated Use hasPollingControls instead
+ */
+export declare const requiresPolling: typeof hasPollingControls;
+/**
+ * @deprecated This function is no longer needed as extended mode handles user actions differently
+ */
+export declare const requiresUserAction: (result: any) => boolean;