call-control-sdk 5.4.7 → 6.0.3

package/dist/index.d.mts

@@ -1,10 +1,75 @@
 import { SxProps } from '@mui/material';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
 
 /**
- * Custom hook for handling agent logout functionality
- * @param options - Optional callbacks for success, error, and completion
- * @returns Object containing logout function and loading state
+ * 🚪 Logout Custom Hook
+ *
+ * @function useLogout
+ * @description 🎯 Custom React hook that provides comprehensive agent logout functionality
+ *              for the CTI SDK. It handles secure logout procedures, complete state cleanup,
+ *              and storage management with intelligent error handling and proper cleanup.
+ *
+ * @returns {Object} Hook return object containing:
+ *   - `logout: () => Promise<any>` - 🚪 Logout function
+ *   - `isLoading: boolean` - ⏳ Loading state indicator
+ *   - `isSuccess: boolean` - ✅ Success state indicator
+ *   - `isError: boolean` - ❌ Error state indicator
+ *   - `error: any` - 🛡️ Error object when logout fails
+ *   - `data: any` - 📊 Response data from successful logout
+ *
+ * @example
+ * ```typescript
+ * // Basic usage in a component
+ * const LogoutButton = () => {
+ *   const {
+ *     logout,
+ *     isLoading,
+ *     isSuccess,
+ *     isError,
+ *     error
+ *   } = useLogout();
+ *
+ *   const handleLogout = async () => {
+ *     try {
+ *       const result = await logout();
+ *       console.log('🚪 Logout successful:', result);
+ *       // Redirect to login page or handle success
+ *     } catch (err) {
+ *       console.error('❌ Logout failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button
+ *       onClick={handleLogout}
+ *       disabled={isLoading}
+ *     >
+ *       {isLoading ? 'Logging out...' : 'Logout'}
+ *     </button>
+ *   );
+ * };
+ * ```
+ *
+ * @features
+ * - 🚪 Secure agent logout with API validation
+ * - 🗑️ Complete state cleanup and reset
+ * - 💾 Storage management (localStorage & sessionStorage)
+ * - ⏳ Comprehensive loading state management
+ * - 🛡️ Robust error handling and recovery
+ * - 📊 Real-time state updates via SDK manager
+ * - 🔄 Automatic storage cleanup
+ *
+ * @logic
+ * - 🔍 Retrieves agent state from localStorage
+ * - 📦 Constructs logout API payload
+ * - 📡 Makes API call to logout agent
+ * - 🗑️ Clears SDK state manager
+ * - 💾 Clears all storage (localStorage & sessionStorage)
+ * - 📊 Handles success/error states
+ * - ⏳ Manages loading states
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
  */
 declare const useLogout: () => {
     logout: () => Promise<any>;
@@ -16,9 +81,75 @@ declare const useLogout: () => {
 };
 
 /**
- * Custom hook for handling end call functionality
- * @param options - Optional callbacks for success, error, and completion
- * @returns Object containing logout function and loading state
+ * 📞 End Call Custom Hook
+ *
+ * @function useEndCall
+ * @description 🎯 Custom React hook that provides comprehensive call termination functionality
+ *              for the CTI SDK. It handles call disposition capture, callback scheduling,
+ *              and proper call cleanup with intelligent state management and error handling.
+ *
+ * @returns {Object} Hook return object containing:
+ *   - `handleEndCall: (data: EndCallData) => Promise<any>` - 📞 Call termination function
+ *   - `isLoading: boolean` - ⏳ Loading state indicator
+ *   - `isSuccess: boolean` - ✅ Success state indicator
+ *   - `isError: boolean` - ❌ Error state indicator
+ *   - `error: any` - 🛡️ Error object when call fails
+ *   - `data: any` - 📊 Response data from successful calls
+ *
+ * @example
+ * ```typescript
+ * // Basic usage in a component
+ * const EndCallButton = () => {
+ *   const {
+ *     handleEndCall,
+ *     isLoading,
+ *     isSuccess,
+ *     isError,
+ *     error
+ *   } = useEndCall();
+ *
+ *   const endCall = async () => {
+ *     try {
+ *       const result = await handleEndCall({
+ *         disposition: "RES",
+ *         followUp: "N"
+ *       });
+ *       console.log('📞 Call ended:', result);
+ *     } catch (err) {
+ *       console.error('❌ End call failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button
+ *       onClick={endCall}
+ *       disabled={isLoading}
+ *     >
+ *       {isLoading ? 'Ending...' : 'End Call'}
+ *     </button>
+ *   );
+ * };
+ * ```
+ *
+ * @features
+ * - 🎯 Comprehensive call termination with disposition tracking
+ * - 📅 Callback scheduling and follow-up management
+ * - 🔄 Intelligent state cleanup and reset
+ * - ⏳ Comprehensive loading state management
+ * - 🛡️ Robust error handling and recovery
+ * - 📊 Real-time state updates via SDK manager
+ * - 🔄 Automatic call state management
+ *
+ * @logic
+ * - 🔍 Retrieves agent state from localStorage
+ * - 📦 Constructs comprehensive API payload
+ * - 📡 Makes API call to end call
+ * - 🔄 Updates SDK state manager
+ * - 📊 Handles success/error states
+ * - ⏳ Manages loading states
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
  */
 declare const useEndCall: () => {
     handleEndCall: (data: {
@@ -35,44 +166,478 @@ declare const useEndCall: () => {
     data: null;
 };
 
+/**
+ * @interface CallData
+ * @description Comprehensive interface defining call-related data structure for CTI operations.
+ * Contains all necessary information about active calls, including metadata, status, and references.
+ *
+ * @declaration
+ * ```typescript
+ * interface CallData {
+ *   mobileNumber?: string;
+ *   callReferenceId?: string;
+ *   convoxId?: string;
+ *   type?: string;
+ *   status?: string;
+ *   agent_id?: string;
+ *   phone_number?: string;
+ *   event_time?: string;
+ *   convox_id?: string;
+ *   process_id?: string;
+ *   process_name?: string;
+ * }
+ * ```
+ *
+ * @requiredParams None (all fields are optional for flexibility)
+ *
+ * @returnType Interface definition
+ *
+ * @example
+ * ```typescript
+ * const callData: CallData = {
+ *   mobileNumber: "1234567890",
+ *   callReferenceId: "REF123456",
+ *   status: "ONCALL",
+ *   agent_id: "agent001",
+ *   process_id: "proc001",
+ *   process_name: "Sales Process"
+ * };
+ * ```
+ *
+ * @return Interface definition for call data structure
+ *
+ * @conclusion Essential data structure for all call-related operations and state management.
+ */
 interface CallData {
+    /** Mobile number of the caller or callee */
     mobileNumber?: string;
+    /** Unique reference identifier for the call */
     callReferenceId?: string;
+    /** Convox system identifier for the call */
     convoxId?: string;
+    /** Type of call (inbound, outbound, internal, etc.) */
     type?: string;
+    /** Current status of the call (ONCALL, RINGING, WRAPUP, etc.) */
     status?: string;
+    /** Agent identifier associated with the call */
     agent_id?: string;
+    /** Phone number involved in the call */
     phone_number?: string;
+    /** Timestamp when the call event occurred */
     event_time?: string;
+    /** Convox system call ID */
     convox_id?: string;
+    /** Process identifier for the call */
     process_id?: string;
+    /** Name of the process handling the call */
     process_name?: string;
 }
+/**
+ * @interface CallControlPanelProps
+ * @description Props interface for the main CallControlPanel component.
+ * Defines the properties that can be passed to customize the call control interface behavior.
+ *
+ * @declaration
+ * ```typescript
+ * interface CallControlPanelProps {
+ *   onDataChange?: (data: CallData) => void;
+ * }
+ * ```
+ *
+ * @requiredParams None (all props are optional)
+ *
+ * @returnType Interface definition
+ *
+ * @example
+ * ```tsx
+ * <CallControlPanel
+ *   onDataChange={(callData) => {
+ *     console.log('Call status changed:', callData.status);
+ *     // Handle call data updates
+ *   }}
+ * />
+ * ```
+ *
+ * @return Interface definition for component props
+ *
+ * @conclusion Provides flexible configuration for the call control panel component.
+ */
 interface CallControlPanelProps {
-    onDataChange?: (data: any) => void;
+    /** Optional callback function triggered when call data changes */
+    onDataChange?: (data: CallData) => void;
 }
-type CallStatus = "idle" | "ready" | "break" | "on call" | "wrap up" | "dial" | "hold" | "mute";
+/**
+ * @type CallStatus
+ * @description Union type defining all possible call statuses in the CTI system.
+ * Represents the various states a call can be in during its lifecycle.
+ *
+ * @declaration
+ * ```typescript
+ * type CallStatus =
+ *   | "idle"
+ *   | "ready"
+ *   | "break"
+ *   | "on call"
+ *   | "wrap up"
+ *   | "dial"
+ *   | "hold"
+ *   | "mute";
+ * ```
+ *
+ * @requiredParams None (type definition)
+ *
+ * @returnType Union type definition
+ *
+ * @example
+ * ```typescript
+ * const currentStatus: CallStatus = "on call";
+ * const agentStatus: CallStatus = "ready";
+ * ```
+ *
+ * @return Union type with all possible call status values
+ *
+ * @conclusion Essential type for call state management and UI updates.
+ */
+type CallStatus = "idle" /** Agent is idle and available */ | "ready" /** Agent is ready to receive calls */ | "break" /** Agent is on break */ | "on call" /** Agent is currently on a call */ | "wrap up" /** Agent is in wrap-up phase after call */ | "dial" /** Agent is dialing a number */ | "hold" /** Call is on hold */ | "mute"; /** Call is muted */
+/**
+ * @type ConferenceLineTypes
+ * @description Type definition for individual conference line data structure.
+ * Represents a single line in a conference call with its state and controls.
+ *
+ * @declaration
+ * ```typescript
+ * type ConferenceLineTypes = {
+ *   line: number;
+ *   status: string;
+ *   type: "external" | "internal" | "";
+ *   phone: string;
+ *   isMute: boolean;
+ *   isHold: boolean;
+ *   isCallStart: boolean;
+ *   isMergeCall: boolean;
+ * };
+ * ```
+ *
+ * @requiredParams None (type definition)
+ *
+ * @returnType Type definition
+ *
+ * @example
+ * ```typescript
+ * const conferenceLine: ConferenceLineTypes = {
+ *   line: 1,
+ *   status: "ONCALL",
+ *   type: "internal",
+ *   phone: "1234567890",
+ *   isMute: false,
+ *   isHold: false,
+ *   isCallStart: true,
+ *   isMergeCall: false
+ * };
+ * ```
+ *
+ * @return Type definition for conference line data
+ *
+ * @conclusion Essential type for conference call management and line state tracking.
+ */
+type ConferenceLineTypes = {
+    /** Line number identifier (1, 2, 3, etc.) */
+    line: number;
+    /** Current status of the line (ONCALL, IDLE, LINE USED, etc.) */
+    status: string;
+    /** Type of line (internal for agent, external for third party) */
+    type: "external" | "internal" | "";
+    /** Phone number associated with this line */
+    phone: string;
+    /** Whether the line is currently muted */
+    isMute: boolean;
+    /** Whether the line is currently on hold */
+    isHold: boolean;
+    /** Whether a call has been started on this line */
+    isCallStart: boolean;
+    /** Whether this line is merged into a conference */
+    isMergeCall: boolean;
+};
+/**
+ * @interface SDKConfig
+ * @description Configuration interface for customizing the Call Control SDK behavior.
+ * Allows disabling specific features and customizing the visual appearance of components.
+ *
+ * @declaration
+ * ```typescript
+ * interface SDKConfig {
+ *   disableEndCallButton?: boolean;
+ *   disabledDialButton?: boolean;
+ *   disableCallTransferButton?: boolean;
+ *   isDraggable?: boolean;
+ *   disableSoftPhone?: boolean;
+ *   disableConferenceButton?: boolean;
+ *   disabled?: SxProps;
+ *   enabled?: SxProps;
+ *   outlined?: SxProps;
+ * }
+ * ```
+ *
+ * @requiredParams None (all configuration options are optional)
+ *
+ * @returnType Interface definition
+ *
+ * @example
+ * ```typescript
+ * const sdkConfig: SDKConfig = {
+ *   disableEndCallButton: false,
+ *   disabledDialButton: true,
+ *   isDraggable: true,
+ *   disableSoftPhone: false,
+ *   enabled: { backgroundColor: 'green' },
+ *   disabled: { backgroundColor: 'gray' }
+ * };
+ * ```
+ *
+ * @return Interface definition for SDK configuration
+ *
+ * @conclusion Provides comprehensive customization options for the CTI interface.
+ */
 interface SDKConfig {
+    /** Whether to disable the end call button */
     disableEndCallButton?: boolean;
+    /** Whether to disable the dial button */
     disabledDialButton?: boolean;
+    /** Whether to disable the call transfer button */
     disableCallTransferButton?: boolean;
+    /** Whether the control panel should be draggable */
     isDraggable?: boolean;
+    /** Whether to disable the soft phone iframe */
     disableSoftPhone?: boolean;
+    /** Whether to disable the conference button */
     disableConferenceButton?: boolean;
+    /** Custom styles for disabled button states */
     disabled?: SxProps;
+    /** Custom styles for enabled button states */
     enabled?: SxProps;
+    /** Custom styles for outlined button states */
     outlined?: SxProps;
 }
+/**
+ * @interface SDKState
+ * @description Comprehensive state interface for the Call Control SDK.
+ * Contains all necessary state information for managing CTI operations, UI state, and call data.
+ *
+ * @declaration
+ * ```typescript
+ * interface SDKState {
+ *   openConferenceDialog: boolean;
+ *   openCallTransferDialog: boolean;
+ *   process?: { process_id: number; process_name: string } | null;
+ *   agentId: string;
+ *   sdkConfig: SDKConfig | null;
+ *   isInitialized: boolean;
+ *   isHolding: boolean;
+ *   isMuted: boolean;
+ *   status: CallStatus;
+ *   convox_id?: string;
+ *   process_id?: number;
+ *   callStartTime: number | null;
+ *   position?: { x: number; y: number };
+ *   controlPanelPosition: { x: number; y: number };
+ *   iframePosition: { x: number; y: number };
+ *   callData: CallData;
+ *   conferenceLine: ConferenceLineTypes[];
+ * }
+ * ```
+ *
+ * @requiredParams None (interface definition)
+ *
+ * @returnType Interface definition
+ *
+ * @example
+ * ```typescript
+ * const sdkState: SDKState = {
+ *   openConferenceDialog: false,
+ *   openCallTransferDialog: false,
+ *   agentId: "agent001",
+ *   sdkConfig: { isDraggable: true },
+ *   isInitialized: true,
+ *   isHolding: false,
+ *   isMuted: false,
+ *   status: "idle",
+ *   callStartTime: null,
+ *   controlPanelPosition: { x: 10, y: 10 },
+ *   iframePosition: { x: 10, y: 80 },
+ *   callData: {},
+ *   conferenceLine: []
+ * };
+ * ```
+ *
+ * @return Interface definition for SDK state management
+ *
+ * @conclusion Central state interface that manages all aspects of the CTI system.
+ */
+interface SDKState {
+    /** Whether the conference dialog is currently open */
+    openConferenceDialog: boolean;
+    /** Whether the call transfer dialog is currently open */
+    openCallTransferDialog: boolean;
+    /** Currently selected process information */
+    process?: {
+        process_id: number;
+        process_name: string;
+    } | null;
+    /** Unique identifier for the agent */
+    agentId: string;
+    /** SDK configuration settings */
+    sdkConfig: SDKConfig | null;
+    /** Whether the SDK has been successfully initialized */
+    isInitialized: boolean;
+    /** Whether the current call is on hold */
+    isHolding: boolean;
+    /** Whether the current call is muted */
+    isMuted: boolean;
+    /** Current agent/call status */
+    status: CallStatus;
+    /** Convox system call identifier */
+    convox_id?: string;
+    /** Process identifier for the current call */
+    process_id?: number;
+    /** Timestamp when the current call started */
+    callStartTime: number | null;
+    /** Current position of draggable elements */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Position of the main control panel */
+    controlPanelPosition: {
+        x: number;
+        y: number;
+    };
+    /** Position of the soft phone iframe */
+    iframePosition: {
+        x: number;
+        y: number;
+    };
+    /** Current call data and metadata */
+    callData: CallData;
+    /** Array of conference lines and their states */
+    conferenceLine: ConferenceLineTypes[];
+}
 
+/**
+ * @fileoverview 📞 Click-to-Call Hook for CTI SDK
+ *
+ * This file contains the useClickToCall custom hook that provides comprehensive call initiation
+ * functionality for the CTI SDK. It handles both regular calls and conference calls with
+ * intelligent state management and error handling.
+ *
+ * 🎯 Key Features:
+ * - 📱 Regular call initiation for idle agents
+ * - 👥 Conference call initiation for agents on calls
+ * - 🔄 Intelligent state detection and routing
+ * - ⏳ Loading states and error handling
+ * - 📊 Real-time state updates
+ * - 🛡️ Comprehensive error management
+ *
+ * @author CTI SDK Team
+ * @version 5.4.8
+ * @since 1.0.0
+ */
+/**
+ * 📱 Start Call Payload Interface
+ *
+ * @interface StartCallPayload
+ * @description 📊 Defines the structure for call initiation payload data
+ *              Contains the mobile number required to initiate a call
+ *
+ * @properties
+ * - `mobileNumber: string` - 📱 The phone number to call (required)
+ *
+ * @example
+ * ```typescript
+ * // Basic call initiation payload
+ * const callPayload: StartCallPayload = {
+ *   mobileNumber: "1234567890"
+ * };
+ *
+ * // Usage in component
+ * const { handleStartCall } = useClickToCall();
+ * await handleStartCall({ mobileNumber: "9876543210" });
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
 interface StartCallPayload {
     mobileNumber: string;
 }
 /**
- * Custom hook for handling end call functionality
- * @param options - Optional callbacks for success, error, and completion
- * @returns Object containing logout function and loading state
+ * 📞 Click-to-Call Custom Hook
+ *
+ * @function useClickToCall
+ * @description 🎯 Custom React hook that provides comprehensive call initiation functionality
+ *              for the CTI SDK. It intelligently handles both regular calls and conference calls
+ *              based on the current agent state, with proper loading states and error handling.
+ *
+ * @returns {Object} Hook return object containing:
+ *   - `handleStartCall: (data: StartCallPayload) => Promise<any>` - 📞 Call initiation function
+ *   - `isLoading: boolean` - ⏳ Loading state indicator
+ *   - `isSuccess: boolean` - ✅ Success state indicator
+ *   - `isError: boolean` - ❌ Error state indicator
+ *   - `error: any` - 🛡️ Error object when call fails
+ *   - `data: any` - 📊 Response data from successful calls
+ *
  * @example
- * handleStartCall({ mobileNumber: "1111111111" });
+ * ```typescript
+ * // Basic usage in a component
+ * const CallButton = () => {
+ *   const {
+ *     handleStartCall,
+ *     isLoading,
+ *     isSuccess,
+ *     isError,
+ *     error
+ *   } = useClickToCall();
+ *
+ *   const makeCall = async () => {
+ *     try {
+ *       const result = await handleStartCall({
+ *         mobileNumber: "1234567890"
+ *       });
+ *       console.log('📞 Call initiated:', result);
+ *     } catch (err) {
+ *       console.error('❌ Call failed:', err);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button
+ *       onClick={makeCall}
+ *       disabled={isLoading}
+ *     >
+ *       {isLoading ? 'Calling...' : 'Make Call'}
+ *     </button>
+ *   );
+ * };
+ * ```
+ *
+ * @features
+ * - 🎯 Intelligent call routing based on agent state
+ * - 📱 Regular call initiation for idle agents
+ * - 👥 Conference call initiation for busy agents
+ * - ⏳ Comprehensive loading state management
+ * - 🛡️ Robust error handling and recovery
+ * - 📊 Real-time state updates via SDK manager
+ * - 🔄 Automatic conference dialog management
+ *
+ * @logic
+ * - 🔍 Checks agent status from localStorage state
+ * - 📞 Initiates regular call if agent is IDLE
+ * - 👥 Initiates conference call if agent is ONCALL
+ * - ⚠️ Shows alert if agent is not ready
+ * - 🔄 Updates conference line state for conference calls
+ * - 🎭 Opens conference dialog for conference calls
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
  */
 declare const useClickToCall: () => {
     handleStartCall: (data: StartCallPayload) => Promise<any>;
@@ -83,19 +648,198 @@ declare const useClickToCall: () => {
     data: null;
 };
 
-declare function CallControlPanel({ onDataChange }: CallControlPanelProps): react_jsx_runtime.JSX.Element;
+/**
+ * @function CallControlPanel
+ * @description Main wrapper component that provides the complete call control interface.
+ * Wraps the CallControls component with necessary providers and context.
+ *
+ * @declaration
+ * ```typescript
+ * function CallControlPanel(props: CallControlPanelProps): JSX.Element
+ * ```
+ *
+ * @requiredParams
+ * - `props: CallControlPanelProps` - Component props including optional data change callback
+ *
+ * @returnType `JSX.Element`
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <CallControlPanel />
+ *
+ * // With data change callback
+ * <CallControlPanel
+ *   onDataChange={(callData) => {
+ *     console.log('Call data updated:', callData);
+ *     // Handle call data changes
+ *   }}
+ * />
+ * ```
+ *
+ * @return React component providing complete call control interface
+ *
+ * @conclusion Primary component for integrating CTI functionality into React applications.
+ */
+declare const CallControlPanel: react.NamedExoticComponent<CallControlPanelProps>;
+
+/**
+ * @fileoverview Call Control SDK - Main Entry Point
+ * @description Comprehensive CTI (Computer Telephony Integration) SDK for React applications.
+ * Provides complete call control functionality including dialing, conferencing, transferring,
+ * and real-time call management with WebSocket integration.
+ *
+ * @author Achala IT Solutions
+ * @version 1.0.0
+ * @since 2024
+ */
 
 /**
- * Initialize the Call Control SDK with an API key
- * @param sdkApiKey - The API key for SDK authentication
- * @throws {Error} When API key is missing or invalid
+ * @interface InitSDKParams
+ * @description Parameters required for SDK initialization
+ *
+ * @declaration
+ * ```typescript
+ * interface InitSDKParams {
+ *   apiKey: string;
+ *   tenantId: string;
+ *   agentId: string;
+ *   sdkConfig?: SDKConfig;
+ * }
+ * ```
+ *
+ * @requiredParams
+ * - `apiKey: string` - Authentication key for SDK access
+ * - `tenantId: string` - Tenant identifier for multi-tenancy support
+ * - `agentId: string` - Agent identifier for call management
+ *
+ * @returnType Interface definition
+ *
+ * @example
+ * ```typescript
+ * const initParams: InitSDKParams = {
+ *   apiKey: "your-api-key",
+ *   tenantId: "tenant-123",
+ *   agentId: "agent-456",
+ *   sdkConfig: {
+ *     isDraggable: true,
+ *     disableSoftPhone: false
+ *   }
+ * };
+ * ```
+ *
+ * @return Interface definition for SDK initialization parameters
+ *
+ * @conclusion Essential interface for proper SDK initialization with all required parameters.
  */
-type intiSDKParams = {
+interface InitSDKParams {
+    /** Authentication key for SDK access */
     apiKey: string;
+    /** Tenant identifier for multi-tenancy support */
     tenantId: string;
+    /** Agent identifier for call management */
     agentId: string;
+    /** Optional SDK configuration for customizing behavior */
     sdkConfig?: SDKConfig;
-};
-declare function initSDK({ apiKey, tenantId, agentId, sdkConfig, }: intiSDKParams): void;
+}
+/**
+ * @function initSDK
+ * @description Initializes the Call Control SDK with authentication credentials and configuration.
+ * Sets up event tracking, state management, and establishes connection to the CTI system.
+ *
+ * @declaration
+ * ```typescript
+ * function initSDK(params: InitSDKParams): Promise<void>
+ * ```
+ *
+ * @requiredParams
+ * - `params: InitSDKParams` - Object containing API key, tenant ID, agent ID, and optional config
+ *
+ * @returnType `Promise<void>`
+ *
+ * @example
+ * ```typescript
+ * // Basic initialization
+ * await initSDK({
+ *   apiKey: "your-api-key",
+ *   tenantId: "tenant-123",
+ *   agentId: "agent-456"
+ * });
+ *
+ * // With custom configuration
+ * await initSDK({
+ *   apiKey: "your-api-key",
+ *   tenantId: "tenant-123",
+ *   agentId: "agent-456",
+ *   sdkConfig: {
+ *     isDraggable: true,
+ *     disableSoftPhone: false,
+ *     disableEndCallButton: false
+ *   }
+ * });
+ * ```
+ *
+ * @return Promise that resolves when initialization is complete
+ *
+ * @throws {Error} When API key is missing or invalid
+ * @throws {Error} When tenant ID is missing or invalid
+ * @throws {Error} When agent ID is missing or invalid
+ * @throws {Error} When initialization fails due to network or authentication issues
+ *
+ * @conclusion Critical function that must be called before using any SDK functionality.
+ */
+declare function initSDK({ apiKey, tenantId, agentId, sdkConfig, }: InitSDKParams): Promise<void>;
+/**
+ * @function getSDKVersion
+ * @description Returns the current version of the Call Control SDK
+ *
+ * @declaration
+ * ```typescript
+ * function getSDKVersion(): string
+ * ```
+ *
+ * @requiredParams None
+ *
+ * @returnType `string`
+ *
+ * @example
+ * ```typescript
+ * const version = getSDKVersion();
+ * console.log(`Using Call Control SDK version: ${version}`);
+ * ```
+ *
+ * @return Current SDK version string
+ *
+ * @conclusion Utility function for version checking and debugging purposes.
+ */
+declare function getSDKVersion(): string;
+/**
+ * @function isSDKInitialized
+ * @description Checks if the SDK has been successfully initialized
+ *
+ * @declaration
+ * ```typescript
+ * function isSDKInitialized(): boolean
+ * ```
+ *
+ * @requiredParams None
+ *
+ * @returnType `boolean`
+ *
+ * @example
+ * ```typescript
+ * if (isSDKInitialized()) {
+ *   // SDK is ready to use
+ *   console.log("SDK is initialized and ready");
+ * } else {
+ *   console.log("SDK needs to be initialized first");
+ * }
+ * ```
+ *
+ * @return True if SDK is initialized, false otherwise
+ *
+ * @conclusion Utility function for checking SDK initialization status before using features.
+ */
+declare function isSDKInitialized(): boolean;
 
-export { CallControlPanel, type CallControlPanelProps, type CallData, type CallStatus, initSDK, useClickToCall, useEndCall, useLogout };
+export { CallControlPanel, type CallControlPanelProps, type CallData, type CallStatus, type ConferenceLineTypes, type SDKConfig, type SDKState, getSDKVersion, initSDK, isSDKInitialized, useClickToCall, useEndCall, useLogout };