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

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

@@ -3,4 +3,6 @@ export * from './types';
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from './error-utils';
 export { validatePhoneNumber, validatePlmn, validateUseCaseRequirements, validateConsentData, validateNonce } from './validation-utils';
 export { MobileDebugConsole } from './ui/mobile-debug-console';
-export { isHeadlessResult, isCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, 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/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/esm/core/phone-auth/strategies/desktop.js

@@ -57,7 +57,20 @@ export 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;
@@ -84,33 +97,44 @@ export 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
@@ -125,9 +149,10 @@ export 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;
                         }
@@ -175,12 +200,19 @@ export 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: {
@@ -188,6 +220,7 @@ export 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
@@ -215,6 +248,7 @@ export 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,
@@ -339,10 +373,12 @@ export 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
@@ -374,15 +410,25 @@ export 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;
+        }
     }
 }
 /**

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

@@ -23,12 +23,21 @@ export 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
@@ -60,12 +69,19 @@ export 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
@@ -84,16 +100,54 @@ export 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: {
@@ -101,12 +155,16 @@ export 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) {
@@ -131,6 +189,7 @@ export 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',
@@ -138,9 +197,14 @@ export 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) {
@@ -156,8 +220,10 @@ export 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'
@@ -173,6 +239,7 @@ export 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({
@@ -184,16 +251,40 @@ export 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',
@@ -213,6 +304,7 @@ export class LinkHandler {
      * Stop polling
      */
     stopPolling() {
+        console.log('[Link Auth] 🏁 Stopping polling');
         this.isPolling = false;
         if (this.pollingInterval) {
             clearInterval(this.pollingInterval);

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