@telnyx/react-voice-commons-sdk 0.1.0

package/lib/callkit/use-callkit.js

@@ -0,0 +1,279 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCallKit = useCallKit;
+const react_1 = require("react");
+const callkit_1 = __importStar(require("./callkit"));
+function useCallKit(options = {}) {
+    const { onAnswerCall, onEndCall, onStartCall } = options;
+    const [activeCalls, setActiveCalls] = (0, react_1.useState)([]);
+    const [isAvailable, setIsAvailable] = (0, react_1.useState)(false);
+    // Use refs to store stable callback references and current state
+    const onAnswerCallRef = (0, react_1.useRef)(onAnswerCall);
+    const onEndCallRef = (0, react_1.useRef)(onEndCall);
+    const onStartCallRef = (0, react_1.useRef)(onStartCall);
+    const activeCallsRef = (0, react_1.useRef)(activeCalls);
+    // Update refs when callbacks change
+    (0, react_1.useEffect)(() => {
+        onAnswerCallRef.current = onAnswerCall;
+    }, [onAnswerCall]);
+    (0, react_1.useEffect)(() => {
+        onEndCallRef.current = onEndCall;
+    }, [onEndCall]);
+    (0, react_1.useEffect)(() => {
+        onStartCallRef.current = onStartCall;
+    }, [onStartCall]);
+    // Update active calls ref
+    (0, react_1.useEffect)(() => {
+        activeCallsRef.current = activeCalls;
+    }, [activeCalls]);
+    (0, react_1.useEffect)(() => {
+        setIsAvailable(callkit_1.default.isAvailable());
+        if (!callkit_1.default.isAvailable()) {
+            console.log('CallKit: Not available on this platform');
+            return;
+        }
+        // Load existing active calls only once
+        const loadActiveCalls = async () => {
+            const calls = await callkit_1.default.getActiveCalls();
+            setActiveCalls(calls.map((call) => ({
+                uuid: call.uuid,
+                handle: call.handle || call.caller || 'Unknown',
+                displayName: call.caller || call.displayName || 'Unknown Caller',
+                isActive: true,
+                direction: call.direction || 'incoming',
+            })));
+        };
+        loadActiveCalls();
+        // Set up event listeners using stable refs
+        const unsubscribeAnswer = callkit_1.default.onAnswerCall((event) => {
+            console.log('useCallKit: Call answered via CallKit', event);
+            onAnswerCallRef.current?.(event.callUUID);
+        });
+        const unsubscribeEnd = callkit_1.default.onEndCall((event) => {
+            console.log('useCallKit: Call ended via CallKit', event);
+            setActiveCalls((prev) => prev.filter((call) => call.uuid !== event.callUUID));
+            onEndCallRef.current?.(event.callUUID);
+        });
+        const unsubscribeStart = callkit_1.default.onStartCall((event) => {
+            console.log('useCallKit: Call started via CallKit', event);
+            onStartCallRef.current?.(event.callUUID);
+        });
+        return () => {
+            unsubscribeAnswer();
+            unsubscribeEnd();
+            unsubscribeStart();
+        };
+    }, []); // Empty dependency array - only run once
+    // Start an outgoing call
+    const startOutgoingCall = (0, react_1.useCallback)(async (call, handle, displayName) => {
+        if (!callkit_1.default.isAvailable()) {
+            console.warn('CallKit: Not available, cannot start outgoing call');
+            return null;
+        }
+        const callUUID = callkit_1.default.generateCallUUID();
+        const callHandle = handle || call.destinationNumber || 'Unknown';
+        const callDisplayName = displayName || callHandle;
+        console.log('useCallKit: Starting outgoing call', {
+            callUUID,
+            callHandle,
+            callDisplayName,
+            telnyxCallId: call.callId,
+        });
+        const success = await callkit_1.default.startOutgoingCall(callUUID, callHandle, callDisplayName);
+        if (success) {
+            const newCall = {
+                uuid: callUUID,
+                handle: callHandle,
+                displayName: callDisplayName,
+                isActive: false,
+                direction: 'outgoing',
+            };
+            setActiveCalls((prev) => [...prev, newCall]);
+            // Store mapping between CallKit UUID and Telnyx call for later reference
+            call._callKitUUID = callUUID;
+            return callUUID;
+        }
+        return null;
+    }, []);
+    // Report an incoming call
+    const reportIncomingCall = (0, react_1.useCallback)(async (call, handle, displayName) => {
+        if (!callkit_1.default.isAvailable()) {
+            console.warn('CallKit: Not available, cannot report incoming call');
+            return null;
+        }
+        const callUUID = callkit_1.default.generateCallUUID();
+        const callHandle = handle || call.destinationNumber || call.callId || 'Unknown';
+        const callDisplayName = displayName || callHandle;
+        console.log('useCallKit: Reporting incoming call', {
+            callUUID,
+            callHandle,
+            callDisplayName,
+            telnyxCallId: call.callId,
+        });
+        const success = await callkit_1.default.reportIncomingCall(callUUID, callHandle, callDisplayName);
+        if (success) {
+            const newCall = {
+                uuid: callUUID,
+                handle: callHandle,
+                displayName: callDisplayName,
+                isActive: false,
+                direction: 'incoming',
+            };
+            setActiveCalls((prev) => [...prev, newCall]);
+            // Store mapping between CallKit UUID and Telnyx call for later reference
+            call._callKitUUID = callUUID;
+            return callUUID;
+        }
+        return null;
+    }, []);
+    // End a call
+    const endCall = (0, react_1.useCallback)(async (callUUID, reason = callkit_1.CallEndReason.RemoteEnded) => {
+        if (!callkit_1.default.isAvailable()) {
+            return false;
+        }
+        console.log('useCallKit: Ending call', { callUUID, reason });
+        try {
+            // For incoming calls, we should use reportCallEnded (which dismisses the UI)
+            // For outgoing calls, we should use endCall (which sends the end request)
+            // Check if this is likely an incoming call by looking at our active calls
+            const activeCall = activeCallsRef.current.find((call) => call.uuid === callUUID);
+            const isIncomingCall = activeCall?.direction === 'incoming';
+            if (isIncomingCall) {
+                await callkit_1.default.reportCallEnded(callUUID, reason);
+            }
+            else {
+                await callkit_1.default.endCall(callUUID);
+            }
+            // Update our local state
+            setActiveCalls((prev) => prev.filter((call) => call.uuid !== callUUID));
+            return true;
+        }
+        catch (error) {
+            console.log('useCallKit: Error ending call (may already be ended):', error);
+            // Still remove from our local state even if CallKit operation failed
+            // This ensures our UI stays in sync
+            setActiveCalls((prev) => prev.filter((call) => call.uuid !== callUUID));
+            // Return true since the call is effectively ended from our perspective
+            return true;
+        }
+    }, []);
+    // Report call connected
+    const reportCallConnected = (0, react_1.useCallback)(async (callUUID) => {
+        if (!callkit_1.default.isAvailable()) {
+            return false;
+        }
+        console.log('useCallKit: Reporting call connected', { callUUID });
+        const success = await callkit_1.default.reportCallConnected(callUUID);
+        if (success) {
+            // Update our local state to mark the call as active
+            setActiveCalls((prev) => prev.map((call) => (call.uuid === callUUID ? { ...call, isActive: true } : call)));
+        }
+        return success;
+    }, []);
+    // Update call information
+    const updateCall = (0, react_1.useCallback)(async (callUUID, displayName, handle) => {
+        if (!callkit_1.default.isAvailable()) {
+            return false;
+        }
+        console.log('useCallKit: Updating call', { callUUID, displayName, handle });
+        const success = await callkit_1.default.updateCall(callUUID, displayName, handle);
+        if (success) {
+            // Update our local state
+            setActiveCalls((prev) => prev.map((call) => (call.uuid === callUUID ? { ...call, displayName, handle } : call)));
+        }
+        return success;
+    }, []);
+    // Answer a call
+    const answerCall = (0, react_1.useCallback)(async (callUUID) => {
+        if (!callkit_1.default.isAvailable()) {
+            return false;
+        }
+        console.log('useCallKit: Answering call', { callUUID });
+        const success = await callkit_1.default.answerCall(callUUID);
+        if (success) {
+            // Update our local state to mark call as active
+            setActiveCalls((prev) => prev.map((call) => (call.uuid === callUUID ? { ...call, isActive: true } : call)));
+        }
+        return success;
+    }, []);
+    // Get CallKit UUID for a Telnyx call
+    const getCallKitUUID = (0, react_1.useCallback)((call) => {
+        return call._callKitUUID || null;
+    }, []);
+    // Set up automatic CallKit integration for a Telnyx call
+    const integrateCall = (0, react_1.useCallback)(async (call, direction) => {
+        if (!callkit_1.default.isAvailable()) {
+            return null;
+        }
+        let callUUID = null;
+        if (direction === 'incoming') {
+            callUUID = await reportIncomingCall(call);
+        }
+        else {
+            callUUID = await startOutgoingCall(call);
+        }
+        if (callUUID) {
+            // Set up automatic state reporting
+            const handleStateChange = async (call, state) => {
+                if (state === 'active') {
+                    await reportCallConnected(callUUID);
+                }
+                else if (state === 'ended' || state === 'failed') {
+                    const reason = state === 'failed' ? callkit_1.CallEndReason.Failed : callkit_1.CallEndReason.RemoteEnded;
+                    await endCall(callUUID, reason);
+                }
+            };
+            call.on('telnyx.call.state', handleStateChange);
+        }
+        return callUUID;
+    }, [reportIncomingCall, startOutgoingCall, reportCallConnected, endCall]);
+    return {
+        // State
+        isAvailable,
+        activeCalls,
+        // Methods
+        startOutgoingCall,
+        reportIncomingCall,
+        answerCall,
+        endCall,
+        reportCallConnected,
+        updateCall,
+        getCallKitUUID,
+        integrateCall,
+        // Utility
+        generateCallUUID: callkit_1.default.generateCallUUID,
+    };
+}

package/lib/context/TelnyxVoiceContext.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { TelnyxVoipClient } from '../telnyx-voip-client';
+import { TelnyxConnectionState } from '../models/connection-state';
+interface TelnyxVoiceContextValue {
+    voipClient: TelnyxVoipClient;
+    connectionState?: TelnyxConnectionState;
+    setConnectionState?: (state: TelnyxConnectionState) => void;
+    connect?: (payload: any) => Promise<any>;
+    client?: any;
+    setClient?: (client: any) => void;
+    enableAutoReconnect?: (enabled: boolean) => void;
+}
+export declare const TelnyxVoiceProvider: React.FC<{
+    voipClient: TelnyxVoipClient;
+    children: React.ReactNode;
+}>;
+export declare const useTelnyxVoice: () => TelnyxVoiceContextValue;
+export {};

package/lib/context/TelnyxVoiceContext.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTelnyxVoice = exports.TelnyxVoiceProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const TelnyxVoiceContext = (0, react_1.createContext)(null);
+const TelnyxVoiceProvider = ({ voipClient, children }) => {
+    return ((0, jsx_runtime_1.jsx)(TelnyxVoiceContext.Provider, { value: { voipClient }, children: children }));
+};
+exports.TelnyxVoiceProvider = TelnyxVoiceProvider;
+const useTelnyxVoice = () => {
+    const context = (0, react_1.useContext)(TelnyxVoiceContext);
+    if (!context) {
+        throw new Error('useTelnyxVoice must be used within a TelnyxVoiceProvider');
+    }
+    return context;
+};
+exports.useTelnyxVoice = useTelnyxVoice;

package/lib/hooks/use-callkit-coordinator.d.ts

@@ -0,0 +1,13 @@
+import { Call } from '@telnyx/react-native-voice-sdk';
+import { TelnyxVoipClient } from '../telnyx-voip-client';
+export declare function useCallKitCoordinator(): {
+    reportIncomingCall: (call: Call, callerName: string, callerNumber: string) => Promise<string | null>;
+    startOutgoingCall: (call: Call, destinationNumber: string, displayName?: string) => Promise<string | null>;
+    answerCallFromUI: (call: Call) => Promise<boolean>;
+    endCallFromUI: (call: Call) => Promise<boolean>;
+    getCallKitUUID: (call: Call) => string | null;
+    getWebRTCCall: (callKitUUID: string) => Call | null;
+    linkExistingCallKitCall: (call: Call, callKitUUID: string) => void;
+    isAvailable: () => boolean;
+    setVoipClient: (voipClient: TelnyxVoipClient) => void;
+};

package/lib/hooks/use-callkit-coordinator.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCallKitCoordinator = useCallKitCoordinator;
+const react_1 = require("react");
+const callkit_coordinator_1 = __importDefault(require("../callkit/callkit-coordinator"));
+function useCallKitCoordinator() {
+    const reportIncomingCall = (0, react_1.useCallback)(async (call, callerName, callerNumber) => {
+        return callkit_coordinator_1.default.reportIncomingCall(call, callerName, callerNumber);
+    }, []);
+    const startOutgoingCall = (0, react_1.useCallback)(async (call, destinationNumber, displayName) => {
+        return callkit_coordinator_1.default.startOutgoingCall(call, destinationNumber, displayName);
+    }, []);
+    const answerCallFromUI = (0, react_1.useCallback)(async (call) => {
+        return callkit_coordinator_1.default.answerCallFromUI(call);
+    }, []);
+    const endCallFromUI = (0, react_1.useCallback)(async (call) => {
+        return callkit_coordinator_1.default.endCallFromUI(call);
+    }, []);
+    const getCallKitUUID = (0, react_1.useCallback)((call) => {
+        return callkit_coordinator_1.default.getCallKitUUID(call);
+    }, []);
+    const getWebRTCCall = (0, react_1.useCallback)((callKitUUID) => {
+        return callkit_coordinator_1.default.getWebRTCCall(callKitUUID);
+    }, []);
+    const linkExistingCallKitCall = (0, react_1.useCallback)((call, callKitUUID) => {
+        callkit_coordinator_1.default.linkExistingCallKitCall(call, callKitUUID);
+    }, []);
+    const isAvailable = (0, react_1.useCallback)(() => {
+        return callkit_coordinator_1.default.isAvailable();
+    }, []);
+    const setVoipClient = (0, react_1.useCallback)((voipClient) => {
+        callkit_coordinator_1.default.setVoipClient(voipClient);
+    }, []);
+    return {
+        reportIncomingCall,
+        startOutgoingCall,
+        answerCallFromUI,
+        endCallFromUI,
+        getCallKitUUID,
+        getWebRTCCall,
+        linkExistingCallKitCall,
+        isAvailable,
+        setVoipClient,
+    };
+}

package/lib/hooks/useAppReadyNotifier.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook to notify the native side when React Native is ready
+ * Call this hook when your main screen/login screen is visible and ready
+ * This is automatically called by TelnyxVoiceApp, but can be used manually if needed
+ *
+ * Note: With the native VoicePnManager integration, this notification is now
+ * handled automatically by the native Android services, so this hook is simplified.
+ */
+export declare const useAppReadyNotifier: () => void;

package/lib/hooks/useAppReadyNotifier.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppReadyNotifier = void 0;
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+/**
+ * Hook to notify the native side when React Native is ready
+ * Call this hook when your main screen/login screen is visible and ready
+ * This is automatically called by TelnyxVoiceApp, but can be used manually if needed
+ *
+ * Note: With the native VoicePnManager integration, this notification is now
+ * handled automatically by the native Android services, so this hook is simplified.
+ */
+const useAppReadyNotifier = () => {
+    (0, react_1.useEffect)(() => {
+        // Only notify on Android since this is Android-specific functionality
+        if (react_native_1.Platform.OS === 'android') {
+            console.log('useAppReadyNotifier: React Native is ready (native services handle FCM automatically)');
+            // Note: The VoicePnManager in the native Android code automatically handles
+            // push notification state when the Firebase messaging service receives notifications.
+            // No JavaScript module communication is needed anymore.
+        }
+    }, []);
+};
+exports.useAppReadyNotifier = useAppReadyNotifier;

package/lib/hooks/useAppStateHandler.d.ts

@@ -0,0 +1,16 @@
+import { AppStateStatus } from 'react-native';
+import { TelnyxVoipClient } from '../telnyx-voip-client';
+interface UseAppStateHandlerOptions {
+    voipClient: TelnyxVoipClient;
+    disconnectOnBackground?: boolean;
+    navigateToLoginOnDisconnect?: boolean;
+    debug?: boolean;
+}
+/**
+ * Hook to handle app state changes for VoIP behavior
+ * When app goes to background without an active call, disconnect socket and redirect to login
+ */
+export declare const useAppStateHandler: ({ voipClient, disconnectOnBackground, navigateToLoginOnDisconnect, debug, }: UseAppStateHandlerOptions) => {
+    currentAppState: AppStateStatus;
+};
+export {};

package/lib/hooks/useAppStateHandler.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppStateHandler = void 0;
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const expo_router_1 = require("expo-router");
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const connection_state_1 = require("../models/connection-state");
+const call_state_1 = require("../models/call-state");
+/**
+ * Hook to handle app state changes for VoIP behavior
+ * When app goes to background without an active call, disconnect socket and redirect to login
+ */
+const useAppStateHandler = ({ voipClient, disconnectOnBackground = true, navigateToLoginOnDisconnect = true, debug = false, }) => {
+    const appState = (0, react_1.useRef)(react_native_1.AppState.currentState);
+    const log = debug ? console.log : () => { };
+    (0, react_1.useEffect)(() => {
+        const handleAppStateChange = async (nextAppState) => {
+            log('AppStateHandler: App state changed from', appState.current, 'to', nextAppState);
+            // When app goes to background
+            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');
+                    appState.current = nextAppState;
+                    return;
+                }
+                // Check if there's an active call (including ringing calls)
+                const activeCalls = voipClient.currentCalls;
+                const hasActiveCall = activeCalls.length > 0 &&
+                    activeCalls.some((call) => call_state_1.CallStateHelpers.isActive(call.currentState) ||
+                        call.currentState === call_state_1.TelnyxCallState.RINGING);
+                log('AppStateHandler: Active call check:', {
+                    callCount: activeCalls.length,
+                    hasActiveCall,
+                    callStates: activeCalls.map((call) => ({
+                        callId: call.callId,
+                        currentState: call.currentState,
+                        destination: call.destination,
+                        isIncoming: call.isIncoming,
+                    })),
+                });
+                if (!hasActiveCall && disconnectOnBackground) {
+                    // Check if there's a push notification call in progress
+                    const isPushNotificationInProgress = await async_storage_1.default.getItem('@push_notification_payload');
+                    if (isPushNotificationInProgress) {
+                        log('AppStateHandler: Push notification call in progress, keeping socket connected');
+                        // Wait a bit longer before allowing disconnection to give time for WebRTC call to establish
+                        setTimeout(async () => {
+                            const stillInProgress = await async_storage_1.default.getItem('@push_notification_payload');
+                            if (!stillInProgress) {
+                                log('AppStateHandler: Push notification call completed, now disconnecting socket');
+                                await voipClient.logout();
+                                if (navigateToLoginOnDisconnect) {
+                                    expo_router_1.router.replace('/');
+                                }
+                            }
+                        }, 5000); // Wait 5 seconds
+                        appState.current = nextAppState;
+                        return;
+                    }
+                    log('AppStateHandler: No active call detected, disconnecting socket...');
+                    try {
+                        // Disconnect the socket with background reason
+                        await voipClient.logout();
+                        log('AppStateHandler: Socket disconnected successfully');
+                        // Navigate to login screen
+                        if (navigateToLoginOnDisconnect) {
+                            // Use a small delay to ensure the disconnect completes
+                            setTimeout(() => {
+                                log('AppStateHandler: Navigating to login screen');
+                                expo_router_1.router.replace('/');
+                            }, 100);
+                        }
+                    }
+                    catch (error) {
+                        console.error('AppStateHandler: Error during background disconnect:', error);
+                    }
+                }
+                else {
+                    log('AppStateHandler: Active call detected or disconnect disabled, keeping socket connected');
+                }
+            }
+            // When app comes to foreground
+            if (appState.current.match(/background/) && nextAppState === 'active') {
+                log('AppStateHandler: App came to foreground');
+                // User will need to manually login again when returning from background
+                // Auto-login only happens for push notification calls
+            }
+            appState.current = nextAppState;
+        };
+        const subscription = react_native_1.AppState.addEventListener('change', handleAppStateChange);
+        return () => {
+            subscription?.remove();
+        };
+    }, [voipClient, disconnectOnBackground, navigateToLoginOnDisconnect, log]);
+    return {
+        currentAppState: appState.current,
+    };
+};
+exports.useAppStateHandler = useAppStateHandler;

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @telnyx/react-voice-commons-sdk
+ *
+ * A high-level, state-agnostic, drop-in module for the Telnyx React Native SDK.
+ *
+ * This library provides a simplified interface for integrating Telnyx WebRTC
+ * capabilities into React Native applications. It handles session management,
+ * call state transitions, push notification processing, and native call UI
+ * integration.
+ */
+export { TelnyxVoipClient, createTelnyxVoipClient, createBackgroundTelnyxVoipClient, } from './telnyx-voip-client';
+export type { TelnyxVoipClientOptions } from './telnyx-voip-client';
+export { TelnyxVoiceApp } from './telnyx-voice-app';
+export type { TelnyxVoiceAppOptions, TelnyxVoiceAppProps } from './telnyx-voice-app';
+export { useAppStateHandler } from './hooks/useAppStateHandler';
+export { useTelnyxVoice } from './context/TelnyxVoiceContext';
+export { Call } from './models/call';
+export { TelnyxConnectionState, isTelnyxConnectionState, canMakeCalls, isConnected, isTransitioning, } from './models/connection-state';
+export { TelnyxCallState, isTelnyxCallState, CallStateHelpers } from './models/call-state';
+export { isCredentialConfig, isTokenConfig, validateConfig, validateCredentialConfig, validateTokenConfig, createCredentialConfig, createTokenConfig, } from './models/config';
+export type { Config, CredentialConfig, TokenConfig } from './models/config';
+export type { Call as TelnyxCall } from '@telnyx/react-native-voice-sdk';
+export * from './callkit';
+export { useAppReadyNotifier } from './hooks/useAppReadyNotifier';

package/lib/index.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * @telnyx/react-voice-commons-sdk
+ *
+ * A high-level, state-agnostic, drop-in module for the Telnyx React Native SDK.
+ *
+ * This library provides a simplified interface for integrating Telnyx WebRTC
+ * capabilities into React Native applications. It handles session management,
+ * call state transitions, push notification processing, and native call UI
+ * integration.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.useAppReadyNotifier = exports.createTokenConfig = exports.createCredentialConfig = exports.validateTokenConfig = exports.validateCredentialConfig = exports.validateConfig = exports.isTokenConfig = exports.isCredentialConfig = exports.CallStateHelpers = exports.isTelnyxCallState = exports.TelnyxCallState = exports.isTransitioning = exports.isConnected = exports.canMakeCalls = exports.isTelnyxConnectionState = exports.TelnyxConnectionState = exports.Call = exports.useTelnyxVoice = exports.useAppStateHandler = exports.TelnyxVoiceApp = exports.createBackgroundTelnyxVoipClient = exports.createTelnyxVoipClient = exports.TelnyxVoipClient = void 0;
+// Main client
+var telnyx_voip_client_1 = require("./telnyx-voip-client");
+Object.defineProperty(exports, "TelnyxVoipClient", { enumerable: true, get: function () { return telnyx_voip_client_1.TelnyxVoipClient; } });
+Object.defineProperty(exports, "createTelnyxVoipClient", { enumerable: true, get: function () { return telnyx_voip_client_1.createTelnyxVoipClient; } });
+Object.defineProperty(exports, "createBackgroundTelnyxVoipClient", { enumerable: true, get: function () { return telnyx_voip_client_1.createBackgroundTelnyxVoipClient; } });
+// TelnyxVoiceApp component
+var telnyx_voice_app_1 = require("./telnyx-voice-app");
+Object.defineProperty(exports, "TelnyxVoiceApp", { enumerable: true, get: function () { return telnyx_voice_app_1.TelnyxVoiceApp; } });
+// Hooks
+var useAppStateHandler_1 = require("./hooks/useAppStateHandler");
+Object.defineProperty(exports, "useAppStateHandler", { enumerable: true, get: function () { return useAppStateHandler_1.useAppStateHandler; } });
+var TelnyxVoiceContext_1 = require("./context/TelnyxVoiceContext");
+Object.defineProperty(exports, "useTelnyxVoice", { enumerable: true, get: function () { return TelnyxVoiceContext_1.useTelnyxVoice; } });
+// Models
+var call_1 = require("./models/call");
+Object.defineProperty(exports, "Call", { enumerable: true, get: function () { return call_1.Call; } });
+var connection_state_1 = require("./models/connection-state");
+Object.defineProperty(exports, "TelnyxConnectionState", { enumerable: true, get: function () { return connection_state_1.TelnyxConnectionState; } });
+Object.defineProperty(exports, "isTelnyxConnectionState", { enumerable: true, get: function () { return connection_state_1.isTelnyxConnectionState; } });
+Object.defineProperty(exports, "canMakeCalls", { enumerable: true, get: function () { return connection_state_1.canMakeCalls; } });
+Object.defineProperty(exports, "isConnected", { enumerable: true, get: function () { return connection_state_1.isConnected; } });
+Object.defineProperty(exports, "isTransitioning", { enumerable: true, get: function () { return connection_state_1.isTransitioning; } });
+var call_state_1 = require("./models/call-state");
+Object.defineProperty(exports, "TelnyxCallState", { enumerable: true, get: function () { return call_state_1.TelnyxCallState; } });
+Object.defineProperty(exports, "isTelnyxCallState", { enumerable: true, get: function () { return call_state_1.isTelnyxCallState; } });
+Object.defineProperty(exports, "CallStateHelpers", { enumerable: true, get: function () { return call_state_1.CallStateHelpers; } });
+var config_1 = require("./models/config");
+Object.defineProperty(exports, "isCredentialConfig", { enumerable: true, get: function () { return config_1.isCredentialConfig; } });
+Object.defineProperty(exports, "isTokenConfig", { enumerable: true, get: function () { return config_1.isTokenConfig; } });
+Object.defineProperty(exports, "validateConfig", { enumerable: true, get: function () { return config_1.validateConfig; } });
+Object.defineProperty(exports, "validateCredentialConfig", { enumerable: true, get: function () { return config_1.validateCredentialConfig; } });
+Object.defineProperty(exports, "validateTokenConfig", { enumerable: true, get: function () { return config_1.validateTokenConfig; } });
+Object.defineProperty(exports, "createCredentialConfig", { enumerable: true, get: function () { return config_1.createCredentialConfig; } });
+Object.defineProperty(exports, "createTokenConfig", { enumerable: true, get: function () { return config_1.createTokenConfig; } });
+// Export CallKit functionality
+__exportStar(require("./callkit"), exports);
+// Export hooks
+var useAppReadyNotifier_1 = require("./hooks/useAppReadyNotifier");
+Object.defineProperty(exports, "useAppReadyNotifier", { enumerable: true, get: function () { return useAppReadyNotifier_1.useAppReadyNotifier; } });

package/lib/internal/CallKitHandler.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+interface CallKitHandlerProps {
+    /** Callback when user needs to login from push notification */
+    onLoginRequired?: (pushPayload: any) => void;
+    /** Callback when call is answered and user should navigate to dialer */
+    onNavigateToDialer?: () => void;
+    /** Callback when call ends and user should navigate back */
+    onNavigateBack?: () => void;
+}
+/**
+ * Internal CallKit handler for iOS push notifications
+ * This component is automatically included in TelnyxVoiceApp
+ *
+ * @internal - Users should not use this component directly
+ */
+export declare const CallKitHandler: React.FC<CallKitHandlerProps>;
+export {};