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

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/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;

package/dist/esm/core/phone-auth/type-guards.js

@@ -5,33 +5,34 @@
  * without having to write their own type checking logic.
  */
 /**
- * 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 function isHeadlessResult(result) {
+export function isExtendedResponse(result) {
     return result &&
         typeof result === 'object' &&
         'strategy' in result &&
-        'trigger' in result &&
-        typeof result.trigger === 'function';
+        'credential' in result &&
+        'cancel' in result &&
+        typeof result.cancel === 'function';
 }
 /**
- * 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
@@ -47,22 +48,40 @@ export function isCredential(result) {
     // String credentials are valid
     if (typeof result === 'string')
         return true;
-    // Object credentials should NOT have HeadlessResult properties
+    // Object credentials should NOT have ExtendedResponse properties
     if (typeof result === 'object') {
-        return !('strategy' in result) && !('trigger' in result);
+        return !('strategy' in result) && !('credential' in result) && !('cancel' in result);
     }
     return false;
 }
 /**
- * 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 function isAuthCredential(result) {
+    return result &&
+        typeof result === 'object' &&
+        'credential' in result &&
+        'authenticated' in result &&
+        'session' in result;
+}
+/**
+ * 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;
  * }
  * ```
  */
@@ -70,14 +89,14 @@ export function isLinkStrategy(result) {
     return result.strategy === 'link';
 }
 /**
- * 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();
  * }
  * ```
  */
@@ -85,15 +104,15 @@ export function isTS43Strategy(result) {
     return result.strategy === 'ts43';
 }
 /**
- * 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();
  * }
  * ```
  */
@@ -102,7 +121,7 @@ export function isDesktopStrategy(result) {
 }
 /**
  * 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
@@ -113,38 +132,54 @@ export function isDesktopStrategy(result) {
  * ```
  */
 export function getStrategy(result) {
-    if (isHeadlessResult(result)) {
+    if (isExtendedResponse(result)) {
         return result.strategy;
     }
     return 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 function requiresPolling(result) {
-    if (!isHeadlessResult(result))
+export function hasPollingControls(result) {
+    if (!isExtendedResponse(result))
         return false;
-    return result.strategy === 'link' || result.strategy === 'desktop';
+    return (result.strategy === 'link' && 'start_polling' in result) ||
+        (result.strategy === 'desktop' && 'start_polling' in result);
 }
 /**
- * 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 function requiresUserAction(result) {
-    return isHeadlessResult(result);
+export function hasTrigger(result) {
+    if (!isExtendedResponse(result))
+        return false;
+    return 'trigger' in result && typeof result.trigger === 'function';
 }
+// Export legacy function names as deprecated aliases for backward compatibility
+/**
+ * @deprecated Use isExtendedResponse instead
+ */
+export const isHeadlessResult = isExtendedResponse;
+/**
+ * @deprecated Use hasPollingControls instead
+ */
+export const requiresPolling = hasPollingControls;
+/**
+ * @deprecated This function is no longer needed as extended mode handles user actions differently
+ */
+export const requiresUserAction = (result) => false;

package/dist/esm/core/phone-auth/ui/modal.js

@@ -50,6 +50,11 @@ export class AuthModal {
      */
     showQRCode(qrCodeData, statusMessage = 'Scan QR code with your phone') {
         console.log('[Modal] showQRCode called with:', qrCodeData);
+        // If modal is already open, don't recreate it
+        if (this.isOpen) {
+            console.log('[Modal] Modal already open, skipping recreation');
+            return;
+        }
         // Check if it's the new dual-platform format with VALID Android QR code
         if (typeof qrCodeData === 'object' && qrCodeData.iosQRCode) {
             const hasValidAndroidQR = qrCodeData.androidQRCode &&
@@ -59,6 +64,8 @@ export class AuthModal {
             if (hasValidAndroidQR) {
                 console.log('[Modal] Using dual-platform modal');
                 this.createDualPlatformQRModal(qrCodeData, statusMessage);
+                // Note: createDualPlatformQRModal calls show() internally
+                return;
             }
             else {
                 console.log('[Modal] Android QR missing/empty, using single iOS QR');
@@ -119,6 +126,8 @@ export class AuthModal {
         <p class="glide-auth-status" id="glide-platform-message">Scan with your iPhone to authenticate</p>
       </div>
     `);
+        // IMPORTANT: Call show() to actually display the modal!
+        this.show();
     }
     /**
      * Sets a callback to be called when the modal is cancelled/closed
@@ -292,7 +301,11 @@ export class AuthModal {
         // Add close button handler
         const closeBtn = this.container.querySelector('.glide-auth-close');
         if (closeBtn) {
-            closeBtn.addEventListener('click', () => this.close());
+            closeBtn.addEventListener('click', () => {
+                var _a;
+                (_a = this.closeCallback) === null || _a === void 0 ? void 0 : _a.call(this); // Call cancellation callback if set
+                this.close();
+            });
         }
         // Add backdrop click handler
         this.backdrop.addEventListener('click', (e) => {

package/dist/esm/core/version.js

@@ -1,2 +1,2 @@
 // SDK version - injected at build time
-export const SDK_VERSION = '4.4.8-beta.1';
+export const SDK_VERSION = '4.4.8-beta.2';

package/dist/esm/index.d.ts

@@ -1,8 +1,8 @@
 export { PhoneAuthClient } from './core/phone-auth';
 export type { AuthConfig as PhoneAuthConfig, PhoneAuthOptions, PhoneAuthResult, AuthError as PhoneAuthError, AuthStep as PhoneAuthStep } from './core/phone-auth';
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from './core/phone-auth';
-export { isHeadlessResult, isCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, requiresPolling, requiresUserAction } from './core/phone-auth';
-export type { PhoneAuthCallbacks, PLMN, SessionInfo, HeadlessResult, InvokeOptions, PrepareRequest, PrepareResponse, GetPhoneNumberRequest, GetPhoneNumberResponse, VerifyPhoneNumberRequest, VerifyPhoneNumberResponse, SecureCredentialRequest, SecureCredentialResponse, DigitalCredential, TS43Data, LinkData, DesktopData, ClientInfo, ConsentData, BrowserErrorType, BrowserErrorCodeType, BrowserNameType } from './core/phone-auth/types';
+export { isExtendedResponse, isCredential, isAuthCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, hasPollingControls, hasTrigger, isHeadlessResult, requiresPolling, requiresUserAction } from './core/phone-auth';
+export type { PhoneAuthCallbacks, PLMN, SessionInfo, InvokeOptions, ExecutionMode, AuthCredential, AnyExtendedResponse, DesktopExtendedResponse, LinkExtendedResponse, TS43ExtendedResponse, PrepareRequest, PrepareResponse, GetPhoneNumberRequest, GetPhoneNumberResponse, VerifyPhoneNumberRequest, VerifyPhoneNumberResponse, SecureCredentialRequest, SecureCredentialResponse, DigitalCredential, TS43Data, LinkData, DesktopData, 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 { DesktopHandler, showQRCodeModal, createQRCodeDisplay } from './core/phone-auth/strategies/desktop';
 export type { DesktopAuthOptions, DesktopAuthResult, PollingStatus, QRCodeData } from './core/phone-auth/strategies/desktop';

package/dist/esm/index.js

@@ -3,7 +3,9 @@ export { PhoneAuthClient } from './core/phone-auth';
 // Phone Auth Error Utilities
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from './core/phone-auth';
 // Phone Auth Type Guards and Helpers
-export { isHeadlessResult, isCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, requiresPolling, requiresUserAction } from './core/phone-auth';
+export { isExtendedResponse, isCredential, isAuthCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, hasPollingControls, hasTrigger, 
+// Deprecated aliases
+isHeadlessResult, requiresPolling, requiresUserAction } from './core/phone-auth';
 // Export constants for use case and strategy
 export { USE_CASE as UseCase, AUTHENTICATION_STRATEGY as AuthenticationStrategy, BrowserError, BrowserErrorCode, BrowserName } from './core/phone-auth/types';
 // Desktop Strategy Exports