call-control-sdk 6.0.6 → 6.0.7

package/dist/index.d.mts

@@ -1,170 +1,447 @@
 import { SxProps } from '@mui/material';
-import * as react from 'react';
+import React from 'react';
 
-/**
- * 🚪 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>;
-    isLoading: boolean;
-    isSuccess: boolean;
-    isError: boolean;
-    error: null;
-    data: null;
-};
+/**
+ * 🚪 Logout Function Type
+ *
+ * @type LogoutFunction
+ * @description 🎯 Type definition for the logout function
+ *              Handles secure agent logout with comprehensive cleanup procedures
+ *
+ * @returns {Promise<any>} Promise that resolves with API response data or rejects with error
+ *
+ * @example
+ * ```typescript
+ * const logout: LogoutFunction = async () => {
+ *   // Logout logic
+ *   return await apiCall();
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+type LogoutFunction = () => Promise<any>;
+
+/**
+ * 📊 Hook State Management Types
+ *
+ * @type HookStateTypes
+ * @description 🎛️ Type definitions for all hook state variables
+ *              Provides type safety for loading, success, error, and data states
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+type HookStateTypes$2 = {
+  /**
+   * ⏳ Loading state indicator
+   * @description Boolean flag indicating if a logout operation is in progress
+   * @type {boolean}
+   */
+  isLoading: boolean;
+
+  /**
+   * ✅ Success state indicator
+   * @description Boolean flag indicating if the last logout was successful
+   * @type {boolean}
+   */
+  isSuccess: boolean;
+
+  /**
+   * ❌ Error state indicator
+   * @description Boolean flag indicating if the last logout encountered an error
+   * @type {boolean}
+   */
+  isError: boolean;
+
+  /**
+   * 🛡️ Error object
+   * @description Contains the error object when a logout fails
+   * @type {any}
+   */
+  error: any;
+
+  /**
+   * 📊 Response data
+   * @description Contains the response data from successful logout
+   * @type {any}
+   */
+  data: any;
+};
+
+/**
+ * 🚪 useLogout Hook Return Type
+ *
+ * @interface UseLogoutReturn
+ * @description 🎯 Complete return type for the useLogout hook
+ *              Contains all functions and state for logout functionality
+ *
+ * @properties
+ * - `logout: LogoutFunction` - 🚪 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
+ * const LogoutButton = () => {
+ *   const hookReturn: UseLogoutReturn = useLogout();
+ *   const {
+ *     logout,
+ *     isLoading,
+ *     isSuccess,
+ *     isError,
+ *     error
+ *   } = hookReturn;
+ *
+ *   // Use the hook functionality
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+interface UseLogoutReturn extends HookStateTypes$2 {
+  /**
+   * 🚪 Logout function
+   * @description Handles secure agent logout with comprehensive cleanup procedures
+   * @type {LogoutFunction}
+   */
+  logout: LogoutFunction;
+}
+
+/**
+ * 🚪 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 {UseLogoutReturn} Hook return object containing:
+ *   - `logout: LogoutFunction` - 🚪 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: () => UseLogoutReturn;
 
-/**
- * 📞 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: {
-        disposition?: string;
-        followUp?: string;
-        callbackDate?: string;
-        callbackHrs?: string;
-        callbackMins?: string;
-    }) => Promise<any>;
-    isLoading: boolean;
-    isSuccess: boolean;
-    isError: boolean;
-    error: null;
-    data: null;
-};
+/**
+ * 📅 End Call Data Interface
+ *
+ * @interface EndCallData
+ * @description 📊 Defines the structure for call termination input data
+ *              Contains disposition and callback information for ending calls
+ *
+ * @properties
+ * - `disposition?: string` - 📝 Call outcome classification (default: "RES")
+ * - `followUp?: string` - 📅 Follow-up requirement (default: "N")
+ * - `callbackDate?: string` - 📅 Scheduled callback date (default: "")
+ * - `callbackHrs?: string` - 🕐 Scheduled callback hour (default: "")
+ * - `callbackMins?: string` - 🕐 Scheduled callback minute (default: "")
+ *
+ * @example
+ * ```typescript
+ * // Basic end call data
+ * const endCallData: EndCallData = {
+ *   disposition: "RES",
+ *   followUp: "N"
+ * };
+ *
+ * // With callback scheduling
+ * const endCallWithCallback: EndCallData = {
+ *   disposition: "RES",
+ *   followUp: "Y",
+ *   callbackDate: "2024-01-15",
+ *   callbackHrs: "14",
+ *   callbackMins: "30"
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+interface EndCallData {
+  /**
+   * 📝 Call outcome classification
+   * @description How the call ended (default: "RES" for Resolved)
+   * @type {string | undefined}
+   */
+  disposition?: string;
+
+  /**
+   * 📅 Follow-up requirement
+   * @description Whether follow-up is required (default: "N" for No)
+   * @type {string | undefined}
+   */
+  followUp?: string;
+
+  /**
+   * 📅 Scheduled callback date
+   * @description Date for callback scheduling (YYYY-MM-DD format)
+   * @type {string | undefined}
+   */
+  callbackDate?: string;
+
+  /**
+   * 🕐 Scheduled callback hour
+   * @description Hour for callback scheduling (0-23)
+   * @type {string | undefined}
+   */
+  callbackHrs?: string;
+
+  /**
+   * 🕐 Scheduled callback minute
+   * @description Minute for callback scheduling (0-59)
+   * @type {string | undefined}
+   */
+  callbackMins?: string;
+}
+
+/**
+ * 📞 Call Termination Function Type
+ *
+ * @type CallTerminationFunction
+ * @description 🎯 Type definition for the call termination function
+ *              Handles call termination with disposition tracking and callback scheduling
+ *
+ * @param {EndCallData} data - 📊 Call termination data containing disposition and callback info
+ * @returns {Promise<any>} Promise that resolves with API response data or rejects with error
+ *
+ * @example
+ * ```typescript
+ * const handleEndCall: CallTerminationFunction = async (data) => {
+ *   // Call termination logic
+ *   return await apiCall(data);
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+type CallTerminationFunction = (data: EndCallData) => Promise<any>;
+
+/**
+ * 📊 Hook State Management Types
+ *
+ * @type HookStateTypes
+ * @description 🎛️ Type definitions for all hook state variables
+ *              Provides type safety for loading, success, error, and data states
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+type HookStateTypes$1 = {
+  /**
+   * ⏳ Loading state indicator
+   * @description Boolean flag indicating if a call termination operation is in progress
+   * @type {boolean}
+   */
+  isLoading: boolean;
+
+  /**
+   * ✅ Success state indicator
+   * @description Boolean flag indicating if the last call termination was successful
+   * @type {boolean}
+   */
+  isSuccess: boolean;
+
+  /**
+   * ❌ Error state indicator
+   * @description Boolean flag indicating if the last call termination encountered an error
+   * @type {boolean}
+   */
+  isError: boolean;
+
+  /**
+   * 🛡️ Error object
+   * @description Contains the error object when a call termination fails
+   * @type {any}
+   */
+  error: any;
+
+  /**
+   * 📊 Response data
+   * @description Contains the response data from successful call terminations
+   * @type {any}
+   */
+  data: any;
+};
+
+/**
+ * 📞 useEndCall Hook Return Type
+ *
+ * @interface UseEndCallReturn
+ * @description 🎯 Complete return type for the useEndCall hook
+ *              Contains all functions and state for call termination functionality
+ *
+ * @properties
+ * - `handleEndCall: CallTerminationFunction` - 📞 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
+ * const EndCallButton = () => {
+ *   const hookReturn: UseEndCallReturn = useEndCall();
+ *   const {
+ *     handleEndCall,
+ *     isLoading,
+ *     isSuccess,
+ *     isError,
+ *     error
+ *   } = hookReturn;
+ *
+ *   // Use the hook functionality
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+interface UseEndCallReturn extends HookStateTypes$1 {
+  /**
+   * 📞 Call termination function
+   * @description Handles call termination with disposition tracking and callback scheduling
+   * @type {CallTerminationFunction}
+   */
+  handleEndCall: CallTerminationFunction;
+}
+
+/**
+ * 📞 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 {UseEndCallReturn} Hook return object containing:
+ *   - `handleEndCall: CallTerminationFunction` - 📞 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: () => UseEndCallReturn;
 
 /**
  * @interface CallData
@@ -208,7 +485,7 @@ declare const useEndCall: () => {
  *
  * @conclusion Essential data structure for all call-related operations and state management.
  */
-interface CallData {
+interface CallData$1 {
     /** Mobile number of the caller or callee */
     mobileNumber?: string;
     /** Unique reference identifier for the call */
@@ -262,102 +539,10 @@ interface CallData {
  *
  * @conclusion Provides flexible configuration for the call control panel component.
  */
-interface CallControlPanelProps {
+interface CallControlPanelProps$1 {
     /** Optional callback function triggered when call data changes */
-    onDataChange?: (data: CallData) => void;
+    onDataChange?: (data: CallData$1) => void;
 }
-/**
- * @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.
@@ -418,270 +603,443 @@ interface SDKConfig {
     /** 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 6.1.0
- * @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;
-}
-/**
- * 📞 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
- * ```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>;
-    isLoading: boolean;
-    isSuccess: boolean;
-    isError: boolean;
-    error: null;
-    data: null;
-};
+/**
+ * @fileoverview 📞 TypeScript Declaration File for useClickToCall Hook
+ *
+ * This file contains TypeScript type definitions for the useClickToCall custom hook
+ * and its related interfaces. It provides comprehensive type safety and IntelliSense
+ * support for developers using the CTI SDK.
+ *
+ * 🎯 Key Type Definitions:
+ * - 📱 StartCallPayload interface for call initiation data
+ * - 📞 useClickToCall hook return type
+ * - 🔄 Call initiation function signature
+ * - 📊 State management types
+ *
+ * @author CTI SDK Team
+ * @version 6.1.0
+ * @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 {
+  /**
+   * 📱 Phone number to call
+   * @description The mobile number that will be called
+   * @type {string}
+   */
+  mobileNumber: string;
+}
+
+/**
+ * 📞 Call Initiation Function Type
+ *
+ * @type CallInitiationFunction
+ * @description 🎯 Type definition for the call initiation function
+ *              Handles both regular calls and conference calls based on agent state
+ *
+ * @param {StartCallPayload} data - 📊 Call initiation data containing mobile number
+ * @returns {Promise<any>} Promise that resolves with API response data or rejects with error
+ *
+ * @example
+ * ```typescript
+ * const handleStartCall: CallInitiationFunction = async (data) => {
+ *   // Call initiation logic
+ *   return await apiCall(data);
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+type CallInitiationFunction = (data: StartCallPayload) => Promise<any>;
+
+/**
+ * 📊 Hook State Management Types
+ *
+ * @type HookStateTypes
+ * @description 🎛️ Type definitions for all hook state variables
+ *              Provides type safety for loading, success, error, and data states
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+type HookStateTypes = {
+  /**
+   * ⏳ Loading state indicator
+   * @description Boolean flag indicating if a call operation is currently in progress
+   * @type {boolean}
+   */
+  isLoading: boolean;
+
+  /**
+   * ✅ Success state indicator
+   * @description Boolean flag indicating if the last call operation was successful
+   * @type {boolean}
+   */
+  isSuccess: boolean;
+
+  /**
+   * ❌ Error state indicator
+   * @description Boolean flag indicating if the last call operation encountered an error
+   * @type {boolean}
+   */
+  isError: boolean;
+
+  /**
+   * 🛡️ Error object
+   * @description Contains the error object when a call operation fails
+   * @type {any}
+   */
+  error: any;
+
+  /**
+   * 📊 Response data
+   * @description Contains the response data from successful call operations
+   * @type {any}
+   */
+  data: any;
+};
+
+/**
+ * 📞 useClickToCall Hook Return Type
+ *
+ * @interface UseClickToCallReturn
+ * @description 🎯 Complete return type for the useClickToCall hook
+ *              Contains all functions and state for call initiation functionality
+ *
+ * @properties
+ * - `handleStartCall: CallInitiationFunction` - 📞 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
+ * ```typescript
+ * const CallButton = () => {
+ *   const hookReturn: UseClickToCallReturn = useClickToCall();
+ *   const {
+ *     handleStartCall,
+ *     isLoading,
+ *     isSuccess,
+ *     isError,
+ *     error
+ *   } = hookReturn;
+ *
+ *   // Use the hook functionality
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+interface UseClickToCallReturn extends HookStateTypes {
+  /**
+   * 📞 Call initiation function
+   * @description Handles call initiation with intelligent routing based on agent state
+   * @type {CallInitiationFunction}
+   */
+  handleStartCall: CallInitiationFunction;
+}
+
+/**
+ * 📞 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 {UseClickToCallReturn} Hook return object containing:
+ *   - `handleStartCall: CallInitiationFunction` - 📞 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
+ * ```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: () => UseClickToCallReturn;
 
-/**
- * @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 📞 TypeScript Declaration File for CallControlPanel Component
+ *
+ * This file contains TypeScript type definitions for the CallControlPanel component
+ * and its related interfaces. It provides comprehensive type safety and IntelliSense
+ * support for developers using the CTI SDK main component.
+ *
+ * 🎯 Key Type Definitions:
+ * - 📞 CallControlPanelProps interface for component props
+ * - 📞 CallData interface for call data structure
+ * - 🔄 Data change callback types
+ * - 📊 Component return types
+ * - 🎯 Error handling types
+ *
+ * @author CTI SDK Team
+ * @version 6.1.0
+ * @since 1.0.0
+ */
+
+/**
+ * 📞 Call Data Interface
+ *
+ * @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.
+ *
+ * @properties
+ * - `mobileNumber?: string` - 📱 Mobile number of the caller or callee
+ * - `callReferenceId?: string` - 🔗 Unique reference identifier for the call
+ * - `convoxId?: string` - 🔗 Convox system identifier for the call
+ * - `type?: string` - 📞 Type of call (inbound, outbound, internal, etc.)
+ * - `status?: string` - 📊 Current status of the call (ONCALL, RINGING, WRAPUP, etc.)
+ * - `agent_id?: string` - 👤 Agent identifier associated with the call
+ * - `phone_number?: string` - 📱 Phone number involved in the call
+ * - `event_time?: string` - ⏰ Timestamp when the call event occurred
+ * - `convox_id?: string` - 🔗 Convox system call ID
+ * - `process_id?: string` - ⚙️ Process identifier for the call
+ * - `process_name?: string` - 📝 Name of the process handling the call
+ *
+ * @example
+ * ```typescript
+ * const callData: CallData = {
+ *   mobileNumber: "1234567890",
+ *   callReferenceId: "REF123456",
+ *   status: "ONCALL",
+ *   agent_id: "agent001",
+ *   process_id: "proc001",
+ *   process_name: "Sales Process"
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+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;
+}
+
+/**
+ * 🔄 Data Change Callback Type
+ *
+ * @type DataChangeCallback
+ * @description 🎯 Type definition for data change callback function
+ *              Called whenever call data changes in the component
+ *
+ * @param {CallData} data - Updated call data
+ * @returns {void} No return value
+ *
+ * @example
+ * ```typescript
+ * const onDataChange: DataChangeCallback = (data) => {
+ *   console.log('Call data updated:', data);
+ *   // Handle call data changes
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+type DataChangeCallback = (data: CallData) => void;
+
+/**
+ * 📞 Call Control Panel Props Interface
+ *
+ * @interface CallControlPanelProps
+ * @description 📊 Props interface for the main CallControlPanel component.
+ *              Defines the properties that can be passed to customize the call control interface behavior.
+ *
+ * @properties
+ * - `onDataChange?: DataChangeCallback` - 🔄 Optional callback function triggered when call data changes
+ *
+ * @example
+ * ```tsx
+ * <CallControlPanel
+ *   onDataChange={(callData) => {
+ *     console.log('Call status changed:', callData.status);
+ *     // Handle call data updates
+ *   }}
+ * />
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+interface CallControlPanelProps {
+	/** Optional callback function triggered when call data changes */
+	onDataChange?: DataChangeCallback;
+}
+
+/**
+ * 📞 Call Control Panel Component Type
+ *
+ * @type CallControlPanelComponent
+ * @description 🎯 Type definition for the CallControlPanel component
+ *              Memoized React component with proper prop types
+ *
+ * @param {CallControlPanelProps} props - Component props
+ * @returns {JSX.Element} React component element
+ *
+ * @example
+ * ```typescript
+ * const CallControlPanel: CallControlPanelComponent = memo(({ onDataChange }) => {
+ *   // Component implementation
+ * });
+ * ```
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+
+type CallControlPanelComponent = React.MemoExoticComponent<
+	(props: CallControlPanelProps) => React.ReactElement
+>;
+
+/**
+ * 📞 Call Control Panel Component
+ *
+ * @function CallControlPanel
+ * @description 🎯 Main wrapper component that provides the complete call control interface.
+ *              Wraps the CallControls component with necessary providers and context.
+ *
+ * @param {CallControlPanelProps} props - Component props including optional data change callback
+ * @returns {JSX.Element} React component providing complete call control interface
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <CallControlPanel />
+ *
+ * // With data change callback
+ * <CallControlPanel
+ *   onDataChange={(callData) => {
+ *     console.log('Call data updated:', callData);
+ *     // Handle call data changes
+ *   }}
+ * />
+ * ```
+ *
+ * @features
+ * - 📞 **Complete CTI Interface**: Provides full call control functionality
+ * - 🔄 **Data Change Handling**: Optional callback for call data updates
+ * - 🛡️ **Error Handling**: Comprehensive error handling for data changes
+ * - ⚡ **Performance Optimized**: Uses React.memo for optimal re-rendering
+ * - 🎯 **Type Safety**: Full TypeScript support with comprehensive types
+ * - 🔧 **Provider Integration**: Wraps components with necessary providers
+ * - 📊 **State Management**: Integrated with SDK state management
+ *
+ * @logic
+ * - 🔄 Creates internal data change handler with error handling
+ * - 🎯 Wraps CallControls component with SDKProvider
+ * - 📊 Passes data change handler to CallControls
+ * - 🛡️ Handles errors gracefully in data change callbacks
+ * - ⚡ Uses useCallback for performance optimization
+ *
+ * @since 1.0.0
+ * @author CTI SDK Team
+ */
+declare const CallControlPanel: CallControlPanelComponent;
 
 /**
  * @fileoverview Call Control SDK - Main Entry Point
@@ -842,4 +1200,4 @@ declare function getSDKVersion(): string;
  */
 declare function isSDKInitialized(): boolean;
 
-export { CallControlPanel, type CallControlPanelProps, type CallData, type CallStatus, type ConferenceLineTypes, type SDKConfig, type SDKState, getSDKVersion, initSDK, isSDKInitialized, useClickToCall, useEndCall, useLogout };
+export { CallControlPanel, type CallControlPanelProps$1 as CallControlPanelProps, type CallData$1 as CallData, type SDKConfig, getSDKVersion, initSDK, isSDKInitialized, useClickToCall, useEndCall, useLogout };