@telnyx/react-voice-commons-sdk 1.0.0 → 1.1.0

package/lib/callkit/callkit.d.ts

@@ -7,6 +7,7 @@ export declare enum CallEndReason {
 }
 export interface CallKitEvent {
   callUUID: string;
+  isOnHold?: boolean;
   [key: string]: any;
 }
 declare class CallKitManager {
@@ -33,7 +34,11 @@ declare class CallKitManager {
   startOutgoingCall(callUUID: string, handle: string, displayName: string): Promise<boolean>;
   reportIncomingCall(callUUID: string, handle: string, displayName: string): Promise<boolean>;
   answerCall(callUUID: string): Promise<boolean>;
+  isCallRegistered(callUUID: string): Promise<boolean>;
   endCall(callUUID: string): Promise<boolean>;
+  completeHeldCallAction(callUUID: string, success: boolean): Promise<boolean>;
+  setCallHeld(callUUID: string, isOnHold: boolean): Promise<boolean>;
+  swapCalls(activeCallUUID: string, heldCallUUID: string): Promise<boolean>;
   reportCallConnected(callUUID: string): Promise<boolean>;
   reportCallEnded(callUUID: string, reason?: CallEndReason): Promise<boolean>;
   updateCall(callUUID: string, displayName: string, handle: string): Promise<boolean>;
@@ -41,7 +46,9 @@ declare class CallKitManager {
   onStartCall(listener: (event: CallKitEvent) => void): () => void;
   onAnswerCall(listener: (event: CallKitEvent) => void): () => void;
   onEndCall(listener: (event: CallKitEvent) => void): () => void;
+  onHeldCall(listener: (event: CallKitEvent) => void): () => void;
   onReceivePush(listener: (event: CallKitEvent) => void): () => void;
+  private addListener;
   generateCallUUID(): string;
   isAvailable(): boolean;
 }

package/lib/callkit/callkit.js

@@ -68,6 +68,11 @@ class CallKitManager {
       console.log('CallKit: Received end call action', normalizedEvent);
       this.notifyListeners('endCall', normalizedEvent);
     });
+    this.eventEmitter.addListener('CallKitDidPerformHeldCallAction', (event) => {
+      const normalizedEvent = this.normalizeEvent(event);
+      console.log('CallKit: Received held call action', normalizedEvent);
+      this.notifyListeners('heldCall', normalizedEvent);
+    });
     this.eventEmitter.addListener('CallKitDidReceivePush', (event) => {
       const normalizedEvent = this.normalizeEvent(event);
       console.log('CallKit: Received push notification event', normalizedEvent);
@@ -75,9 +80,11 @@ class CallKitManager {
     });
   }
   notifyListeners(eventType, event) {
-    const listener = this.listeners.get(eventType);
-    if (listener) {
-      listener(event);
+    const listeners = this.listeners.get(eventType);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(event);
+      }
     }
   }
   // Public API methods
@@ -140,6 +147,21 @@ class CallKitManager {
       return false;
     }
   }
+  async isCallRegistered(callUUID) {
+    if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+      return false;
+    }
+    try {
+      const result = await this.bridge.isCallRegistered(this.denormalizeUUID(callUUID));
+      return result.registered;
+    } catch (error) {
+      console.error('CallKit: Failed to check incoming call registration', {
+        callUUID,
+        error,
+      });
+      return false;
+    }
+  }
   async endCall(callUUID) {
     if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
       console.warn('CallKit: Not available on this platform');
@@ -157,6 +179,46 @@ class CallKitManager {
       return false;
     }
   }
+  async completeHeldCallAction(callUUID, success) {
+    if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+      return false;
+    }
+    try {
+      const uppercaseUUID = this.denormalizeUUID(callUUID);
+      const result = await this.bridge.completeHeldCallAction(uppercaseUUID, success);
+      return result.success;
+    } catch (error) {
+      console.error('CallKit: Failed to complete held call action', error);
+      return false;
+    }
+  }
+  async setCallHeld(callUUID, isOnHold) {
+    if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+      return false;
+    }
+    try {
+      const result = await this.bridge.setCallHeld(this.denormalizeUUID(callUUID), isOnHold);
+      return result.success;
+    } catch (error) {
+      console.error('CallKit: Failed to change held state', { callUUID, isOnHold, error });
+      return false;
+    }
+  }
+  async swapCalls(activeCallUUID, heldCallUUID) {
+    if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
+      return false;
+    }
+    try {
+      const result = await this.bridge.swapCalls(
+        this.denormalizeUUID(activeCallUUID),
+        this.denormalizeUUID(heldCallUUID)
+      );
+      return result.success;
+    } catch (error) {
+      console.error('CallKit: Failed to swap calls', error);
+      return false;
+    }
+  }
   async reportCallConnected(callUUID) {
     if (!this.bridge || react_native_1.Platform.OS !== 'ios') {
       return false;
@@ -220,20 +282,30 @@ class CallKitManager {
   }
   // Event listener management
   onStartCall(listener) {
-    this.listeners.set('startCall', listener);
-    return () => this.listeners.delete('startCall');
+    return this.addListener('startCall', listener);
   }
   onAnswerCall(listener) {
-    this.listeners.set('answerCall', listener);
-    return () => this.listeners.delete('answerCall');
+    return this.addListener('answerCall', listener);
   }
   onEndCall(listener) {
-    this.listeners.set('endCall', listener);
-    return () => this.listeners.delete('endCall');
+    return this.addListener('endCall', listener);
+  }
+  onHeldCall(listener) {
+    return this.addListener('heldCall', listener);
   }
   onReceivePush(listener) {
-    this.listeners.set('receivePush', listener);
-    return () => this.listeners.delete('receivePush');
+    return this.addListener('receivePush', listener);
+  }
+  addListener(eventType, listener) {
+    const listeners = this.listeners.get(eventType) ?? new Set();
+    listeners.add(listener);
+    this.listeners.set(eventType, listeners);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        this.listeners.delete(eventType);
+      }
+    };
   }
   // Utility methods
   generateCallUUID() {

package/lib/hooks/useAppStateHandler.js

@@ -30,8 +30,12 @@ const useAppStateHandler = ({
       if (appState.current.match(/active/) && nextAppState === 'background') {
         log('AppStateHandler: App went to background, checking for active calls...');
         const connectionState = voipClient.currentConnectionState;
-        if (connectionState !== connection_state_1.TelnyxConnectionState.CONNECTED) {
-          log('AppStateHandler: Not connected, skipping background handling');
+        const shouldHandleBackgroundConnection =
+          connectionState === connection_state_1.TelnyxConnectionState.CONNECTED ||
+          connectionState === connection_state_1.TelnyxConnectionState.CONNECTING ||
+          connectionState === connection_state_1.TelnyxConnectionState.RECONNECTING;
+        if (!shouldHandleBackgroundConnection) {
+          log('AppStateHandler: Not connected or connecting, skipping background handling');
           appState.current = nextAppState;
           return;
         }

package/lib/internal/CallKitHandler.d.ts

@@ -11,6 +11,9 @@ interface CallKitHandlerProps {
  * Internal CallKit handler for iOS push notifications
  * This component is automatically included in TelnyxVoiceApp
  *
+ * The active instance removes only its own DeviceEventEmitter subscriptions on
+ * unmount via each listener's `.remove()` method.
+ *
  * @internal - Users should not use this component directly
  */
 export declare const CallKitHandler: React.FC<CallKitHandlerProps>;

package/lib/internal/CallKitHandler.js

@@ -9,19 +9,68 @@ exports.CallKitHandler = void 0;
 const react_1 = require('react');
 const react_native_1 = require('react-native');
 const async_storage_1 = __importDefault(require('@react-native-async-storage/async-storage'));
-const TelnyxVoiceContext_1 = require('../context/TelnyxVoiceContext');
-// Global flag to ensure only one CallKitHandler is active
+// Global flag to ensure only one CallKitHandler is active.
 let isCallKitHandlerActive = false;
 /**
  * Internal CallKit handler for iOS push notifications
  * This component is automatically included in TelnyxVoiceApp
  *
+ * The active instance removes only its own DeviceEventEmitter subscriptions on
+ * unmount via each listener's `.remove()` method.
+ *
  * @internal - Users should not use this component directly
  */
 const CallKitHandler = ({ onLoginRequired, onNavigateToDialer, onNavigateBack }) => {
-  const { voipClient } = (0, TelnyxVoiceContext_1.useTelnyxVoice)();
   // Store active calls by CallKit UUID for coordination
   const activeCallsRef = (0, react_1.useRef)(new Map());
+  // DeviceEventEmitter listeners are registered once below, so read callbacks
+  // from refs that are updated during every render rather than stale closures.
+  const onLoginRequiredRef = (0, react_1.useRef)(onLoginRequired);
+  const onNavigateToDialerRef = (0, react_1.useRef)(onNavigateToDialer);
+  const onNavigateBackRef = (0, react_1.useRef)(onNavigateBack);
+  onLoginRequiredRef.current = onLoginRequired;
+  onNavigateToDialerRef.current = onNavigateToDialer;
+  onNavigateBackRef.current = onNavigateBack;
+  const handleIncomingCall = async (eventData) => {
+    console.log('CallKitHandler: Handling incoming call', {
+      callUUID: eventData.callUUID,
+    });
+    // Store the push notification payload
+    await async_storage_1.default.setItem(
+      '@push_notification_payload',
+      JSON.stringify(eventData.payload)
+    );
+    // Mark this call as being processed
+    activeCallsRef.current.set(eventData.callUUID, {
+      processing: true,
+      timestamp: Date.now(),
+    });
+    // Trigger login required callback if provided
+    if (onLoginRequiredRef.current) {
+      onLoginRequiredRef.current(eventData.payload);
+    }
+  };
+  const handleAnswerCall = async (eventData) => {
+    console.log('CallKitHandler: User answered call via CallKit', {
+      callUUID: eventData.callUUID,
+      isTrackedCall: activeCallsRef.current.has(eventData.callUUID),
+    });
+    if (onNavigateToDialerRef.current) {
+      onNavigateToDialerRef.current();
+    }
+  };
+  const handleEndCall = async (eventData) => {
+    console.log('CallKitHandler: User ended call via CallKit', {
+      callUUID: eventData.callUUID,
+      isTrackedCall: activeCallsRef.current.has(eventData.callUUID),
+    });
+    // Clean up our local tracking info
+    activeCallsRef.current.delete(eventData.callUUID);
+    await async_storage_1.default.removeItem('@push_notification_payload');
+    if (onNavigateBackRef.current) {
+      onNavigateBackRef.current();
+    }
+  };
   (0, react_1.useEffect)(() => {
     if (react_native_1.Platform.OS !== 'ios') return;
     if (isCallKitHandlerActive) {
@@ -30,8 +79,6 @@ const CallKitHandler = ({ onLoginRequired, onNavigateToDialer, onNavigateBack })
     }
     isCallKitHandlerActive = true;
     console.log('CallKitHandler: Setting up DeviceEventEmitter listeners (singleton instance)...');
-    react_native_1.DeviceEventEmitter.removeAllListeners('incomingVoIPCall');
-    react_native_1.DeviceEventEmitter.removeAllListeners('callKitAction');
     const incomingCallListener = react_native_1.DeviceEventEmitter.addListener(
       'incomingVoIPCall',
       async (eventData) => {
@@ -63,47 +110,6 @@ const CallKitHandler = ({ onLoginRequired, onNavigateToDialer, onNavigateBack })
       isCallKitHandlerActive = false;
     };
   }, []);
-  const handleIncomingCall = async (eventData) => {
-    console.log('CallKitHandler: Handling incoming call', {
-      callUUID: eventData.callUUID,
-      hasClient: !!voipClient,
-    });
-    // Store the push notification payload
-    await async_storage_1.default.setItem(
-      '@push_notification_payload',
-      JSON.stringify(eventData.payload)
-    );
-    // Mark this call as being processed
-    activeCallsRef.current.set(eventData.callUUID, {
-      processing: true,
-      timestamp: Date.now(),
-    });
-    // Trigger login required callback if provided
-    if (onLoginRequired) {
-      onLoginRequired(eventData.payload);
-    }
-  };
-  const handleAnswerCall = async (eventData) => {
-    console.log('CallKitHandler: User answered call via CallKit', {
-      callUUID: eventData.callUUID,
-      isTrackedCall: activeCallsRef.current.has(eventData.callUUID),
-    });
-    if (onNavigateToDialer) {
-      onNavigateToDialer();
-    }
-  };
-  const handleEndCall = async (eventData) => {
-    console.log('CallKitHandler: User ended call via CallKit', {
-      callUUID: eventData.callUUID,
-      isTrackedCall: activeCallsRef.current.has(eventData.callUUID),
-    });
-    // Clean up our local tracking info
-    activeCallsRef.current.delete(eventData.callUUID);
-    await async_storage_1.default.removeItem('@push_notification_payload');
-    if (onNavigateBack) {
-      onNavigateBack();
-    }
-  };
   // This component doesn't render anything, it just handles events
   return null;
 };

package/lib/internal/calls/call-state-controller.d.ts

@@ -1,6 +1,11 @@
 import { Observable } from 'rxjs';
 import { Call } from '../../models/call';
 import { SessionManager } from '../session/session-manager';
+export type CustomHeader = {
+  name: string;
+  value: string;
+};
+export type CustomHeaders = Record<string, string> | CustomHeader[];
 /**
  * Central state machine for call management.
  *
@@ -15,6 +20,7 @@ export declare class CallStateController {
   private _listenerClient?;
   private _isWaitingForInvite?;
   private _onInviteAutoAccepted?;
+  private _activeCallId;
   constructor(_sessionManager: SessionManager);
   /**
    * Observable stream of all current calls
@@ -46,11 +52,33 @@ export declare class CallStateController {
    * @param callId The ID of the call to set to connecting state
    */
   setCallConnecting(callId: string): void;
+  /**
+   * Explicitly set the active call for multi-call scenarios.
+   * When set, activeCall$ and currentActiveCall prefer this call over
+   * the first-match heuristic. The ID is cleared automatically when the
+   * call reaches a terminal state.
+   * @param callId The ID of the call to mark as active
+   */
+  setActiveCall(callId: string): void;
+  /**
+   * Clear the explicitly-tracked active call ID, reverting to the
+   * first-match heuristic for active call selection.
+   */
+  clearActiveCall(): void;
   /**
    * Find a call by its underlying Telnyx call ID
    * @param telnyxCall The Telnyx call object to find
    */
   findCallByTelnyxCall(telnyxCall: any): Call | null;
+  /**
+   * Select the active call, preferring the explicitly-tracked call ID
+   * over the first-match heuristic.
+   */
+  private _selectActiveCall;
+  /**
+   * Check if a call is in a non-terminal (active or connecting) state.
+   */
+  private _isNonTerminal;
   /**
    * Initialize client listeners when the Telnyx client becomes available
    * This should be called by the session manager after client creation
@@ -63,8 +91,12 @@ export declare class CallStateController {
     destination: string,
     callerName?: string,
     callerNumber?: string,
-    customHeaders?: Record<string, string>
+    customHeaders?: CustomHeaders
   ): Promise<Call>;
+  /**
+   * Normalize public custom headers into the format expected by the underlying SDK.
+   */
+  private _normalizeCustomHeaders;
   /**
    * Set callbacks for waiting for invite logic (used for push notifications)
    */

package/lib/internal/calls/call-state-controller.js

@@ -6,7 +6,6 @@ const operators_1 = require('rxjs/operators');
 const call_1 = require('../../models/call');
 const call_state_1 = require('../../models/call-state');
 const callkit_coordinator_1 = require('../../callkit/callkit-coordinator');
-const voice_pn_bridge_1 = require('../voice-pn-bridge');
 /**
  * Central state machine for call management.
  *
@@ -19,6 +18,11 @@ class CallStateController {
     this._calls = new rxjs_1.BehaviorSubject([]);
     this._callMap = new Map();
     this._disposed = false;
+    // Explicitly-tracked active call ID for multi-call scenarios.
+    // When set, activeCall$/currentActiveCall prefer this call over the
+    // first-match heuristic. Cleared automatically when the call reaches
+    // a terminal state, or manually via clearActiveCall().
+    this._activeCallId = null;
     this._handleTelnyxIncomingCall = (telnyxCall, msg) => {
       console.log('CallStateController: Incoming call received:', telnyxCall.callId);
       this._handleIncomingCall(telnyxCall, msg, false);
@@ -62,18 +66,18 @@ class CallStateController {
   get activeCall$() {
     return this.calls$.pipe(
       (0, operators_1.map)((calls) => {
-        // Find the first call that is not terminated (includes RINGING, CONNECTING, ACTIVE, HELD)
-        return (
-          calls.find(
-            (call) =>
-              call.currentState === call_state_1.TelnyxCallState.RINGING ||
-              call.currentState === call_state_1.TelnyxCallState.CONNECTING ||
-              call.currentState === call_state_1.TelnyxCallState.ACTIVE ||
-              call.currentState === call_state_1.TelnyxCallState.HELD
-          ) || null
-        );
+        const call = this._selectActiveCall(calls);
+        return {
+          call,
+          callId: call?.callId ?? null,
+          state: call?.currentState ?? null,
+        };
       }),
-      (0, operators_1.distinctUntilChanged)()
+      (0, operators_1.distinctUntilChanged)(
+        (previous, current) =>
+          previous.callId === current.callId && previous.state === current.state
+      ),
+      (0, operators_1.map)(({ call }) => call)
     );
   }
   /**
@@ -86,16 +90,7 @@ class CallStateController {
    * Current active call (synchronous access)
    */
   get currentActiveCall() {
-    const calls = this.currentCalls;
-    return (
-      calls.find(
-        (call) =>
-          call.currentState === call_state_1.TelnyxCallState.RINGING ||
-          call.currentState === call_state_1.TelnyxCallState.CONNECTING ||
-          call.currentState === call_state_1.TelnyxCallState.ACTIVE ||
-          call.currentState === call_state_1.TelnyxCallState.HELD
-      ) || null
-    );
+    return this._selectActiveCall(this.currentCalls);
   }
   /**
    * Access any active call tracked by the client.
@@ -121,6 +116,32 @@ class CallStateController {
       console.warn('CallStateController: Could not find call to set connecting:', callId);
     }
   }
+  /**
+   * Explicitly set the active call for multi-call scenarios.
+   * When set, activeCall$ and currentActiveCall prefer this call over
+   * the first-match heuristic. The ID is cleared automatically when the
+   * call reaches a terminal state.
+   * @param callId The ID of the call to mark as active
+   */
+  setActiveCall(callId) {
+    const call = this._callMap.get(callId);
+    if (call) {
+      this._activeCallId = callId;
+      this._calls.next([...this.currentCalls]);
+    } else {
+      console.warn('CallStateController: Cannot set active call - call not found:', callId);
+    }
+  }
+  /**
+   * Clear the explicitly-tracked active call ID, reverting to the
+   * first-match heuristic for active call selection.
+   */
+  clearActiveCall() {
+    if (this._activeCallId !== null) {
+      this._activeCallId = null;
+      this._calls.next([...this.currentCalls]);
+    }
+  }
   /**
    * Find a call by its underlying Telnyx call ID
    * @param telnyxCall The Telnyx call object to find
@@ -133,6 +154,31 @@ class CallStateController {
     }
     return null;
   }
+  /**
+   * Select the active call, preferring the explicitly-tracked call ID
+   * over the first-match heuristic.
+   */
+  _selectActiveCall(calls) {
+    if (this._activeCallId) {
+      const tracked = calls.find((c) => c.callId === this._activeCallId);
+      if (tracked && this._isNonTerminal(tracked)) {
+        return tracked;
+      }
+    }
+    // Fall back to first non-terminal call (backward compatible)
+    return calls.find((c) => this._isNonTerminal(c)) || null;
+  }
+  /**
+   * Check if a call is in a non-terminal (active or connecting) state.
+   */
+  _isNonTerminal(call) {
+    return (
+      call.currentState === call_state_1.TelnyxCallState.RINGING ||
+      call.currentState === call_state_1.TelnyxCallState.CONNECTING ||
+      call.currentState === call_state_1.TelnyxCallState.ACTIVE ||
+      call.currentState === call_state_1.TelnyxCallState.HELD
+    );
+  }
   /**
    * Initialize client listeners when the Telnyx client becomes available
    * This should be called by the session manager after client creation
@@ -160,7 +206,7 @@ class CallStateController {
         destinationNumber: destination,
         callerIdName: callerName,
         callerIdNumber: callerNumber,
-        customHeaders,
+        customHeaders: this._normalizeCustomHeaders(customHeaders),
         peerConnectionOptions: {
           useTrickleIce: this._sessionManager.useTrickleIce,
         },
@@ -184,6 +230,18 @@ class CallStateController {
       throw error;
     }
   }
+  /**
+   * Normalize public custom headers into the format expected by the underlying SDK.
+   */
+  _normalizeCustomHeaders(customHeaders) {
+    if (!customHeaders) {
+      return undefined;
+    }
+    if (Array.isArray(customHeaders)) {
+      return customHeaders;
+    }
+    return Object.entries(customHeaders).map(([name, value]) => ({ name, value }));
+  }
   /**
    * Set callbacks for waiting for invite logic (used for push notifications)
    */
@@ -212,6 +270,7 @@ class CallStateController {
       }
     }
     this._callMap.clear();
+    this._activeCallId = null;
     this._calls.next([]);
   }
   /**
@@ -226,6 +285,7 @@ class CallStateController {
     // Dispose of all calls
     this.currentCalls.forEach((call) => call.dispose());
     this._callMap.clear();
+    this._activeCallId = null;
     // CallKit cleanup is now handled by CallKitCoordinator automatically
     this._calls.complete();
   }
@@ -346,6 +406,10 @@ class CallStateController {
    */
   _addCall(call) {
     this._callMap.set(call.callId, call);
+    // Auto-track as active if no active call is currently set
+    if (this._activeCallId === null) {
+      this._activeCallId = call.callId;
+    }
     const currentCalls = this.currentCalls;
     currentCalls.push(call);
     this._calls.next([...currentCalls]);
@@ -358,7 +422,11 @@ class CallStateController {
         callkit_coordinator_1.callKitCoordinator.getCallKitUUID(telnyxCall);
       if (existingCallKitUUID) {
         console.log(
-          'CallStateController: Call already has CallKit integration, skipping duplicate report:',
+          'CallStateController: Linking push-created CallKit call to its signaling call:',
+          existingCallKitUUID
+        );
+        callkit_coordinator_1.callKitCoordinator.linkExistingCallKitCall(
+          telnyxCall,
           existingCallKitUUID
         );
       } else if (call.isIncoming) {
@@ -383,16 +451,20 @@ class CallStateController {
     call.callState$.subscribe((state) => {
       // CallKitCoordinator automatically updates CallKit via setupWebRTCCallListeners
       console.log('CallStateController: Call state changed to:', state);
+      // Re-emit the call list so calls$/activeCall$ subscribers see state changes.
+      // distinctUntilChanged uses reference equality; without a new array
+      // reference, non-terminal transitions leave activeCall$ stale.
+      this._calls.next([...this.currentCalls]);
       // Clean up when call ends - delay to next tick so external subscribers
       // receive the ENDED/FAILED state before the call is disposed
       if (
         state === call_state_1.TelnyxCallState.ENDED ||
         state === call_state_1.TelnyxCallState.FAILED
       ) {
-        // Clear pending push data so the next app launch isn't mistaken for a push launch
-        voice_pn_bridge_1.VoicePnBridge.clearPendingVoipPush().catch((e) =>
-          console.warn('CallStateController: Failed to clear pending voip push:', e)
-        );
+        // Clear active call ID if the ending call was the tracked active call
+        if (this._activeCallId === call.callId) {
+          this._activeCallId = null;
+        }
         setTimeout(() => this._removeCall(call.callId), 0);
       }
     });

package/lib/internal/session/session-manager.d.ts

@@ -14,6 +14,10 @@ export declare class SessionManager {
   private _currentConfig?;
   private _sessionId;
   private _disposed;
+  private _disposing;
+  private _connectionGeneration;
+  private _disposePromise?;
+  private _connectPromise?;
   private _onClientReady?;
   private _onDisconnect?;
   constructor();
@@ -76,14 +80,17 @@ export declare class SessionManager {
    * Handle push notification (async version)
    */
   handlePushNotification(payload: Record<string, any>): Promise<void>;
+  private _hasActiveOrHeldCall;
   /**
    * Dispose of the session manager and clean up resources
    */
-  dispose(): void;
+  dispose(): Promise<void>;
   /**
    * Internal method to establish connection with or without push notification handling
    */
   private _connect;
+  private _dispose;
+  private _runConnect;
   /**
    * Set up event listeners for the Telnyx client
    */
@@ -96,4 +103,11 @@ export declare class SessionManager {
    * Generate a unique session ID
    */
   private _generateSessionId;
+  private _assertCanStartConnection;
+  private _isTeardownActive;
+  private _isConnectCanceled;
+  private _throwIfConnectCanceled;
+  private _createConnectCanceledError;
+  private _disconnectClient;
+  private _disconnectAndForgetClient;
 }