call-control-sdk 5.4.7 → 5.4.8

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 import { SxProps } from '@mui/material';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import { AxiosResponse, AxiosError, AxiosRequestConfig } from 'axios';
+import * as react from 'react';
 
 /**
  * Custom hook for handling agent logout functionality
@@ -35,34 +36,715 @@ 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[];
+}
+/**
+ * @interface RequestOptions
+ * @description Interface defining optional success and error callback functions for API requests.
+ * Provides a standardized way to handle request lifecycle events with proper error handling.
+ *
+ * @declaration
+ * ```typescript
+ * interface RequestOptions {
+ *   onSuccess?: (response: AxiosResponse, request: any) => void;
+ *   onError?: (error: any, request: any) => void;
+ * }
+ * ```
+ *
+ * @requiredParams None (all callbacks are optional)
+ *
+ * @returnType Interface definition
+ *
+ * @example
+ * ```typescript
+ * const requestOptions: RequestOptions = {
+ *   onSuccess: (response, request) => {
+ *     console.log('Request successful:', response.data);
+ *     // Handle successful response
+ *   },
+ *   onError: (error, request) => {
+ *     console.error('Request failed:', error.message);
+ *     // Handle error
+ *   }
+ * };
+ * ```
+ *
+ * @return Interface definition for request callback options
+ *
+ * @conclusion Essential interface for implementing robust error handling and success callbacks in API operations.
+ */
+interface RequestOptions {
+    /**
+     * Callback function triggered when the request succeeds.
+     * @param response - The successful Axios response object
+     * @param request - The original request configuration
+     */
+    onSuccess?: (response: AxiosResponse, request: any) => void;
+    /**
+     * Callback function triggered when the request fails.
+     * @param error - The error object containing failure details
+     * @param request - The original request configuration
+     */
+    onError?: (error: any, request: any) => void;
+    disabledSuccessToast?: boolean;
+}
+/**
+ * @interface RequestResult
+ * @description Interface defining the return type of API hook state management.
+ * Provides comprehensive state tracking for HTTP requests including loading, success, error states, and data.
+ *
+ * @declaration
+ * ```typescript
+ * interface RequestResult<T> {
+ *   isLoading: boolean;
+ *   isSuccess: boolean;
+ *   isError: boolean;
+ *   error: AxiosError | null;
+ *   data: AxiosResponse<T> | null;
+ * }
+ * ```
+ *
+ * @requiredParams None (interface definition)
+ *
+ * @returnType Interface definition
+ *
+ * @example
+ * ```typescript
+ * const [makeRequest, requestState] = usePostRequest<User>();
+ *
+ * // requestState has type RequestResult<User>
+ * if (requestState.isLoading) {
+ *   return <LoadingSpinner />;
+ * }
+ *
+ * if (requestState.isError) {
+ *   return <ErrorMessage error={requestState.error} />;
+ * }
+ *
+ * if (requestState.isSuccess) {
+ *   return <UserData user={requestState.data?.data} />;
+ * }
+ * ```
+ *
+ * @return Interface definition for request state management
+ *
+ * @conclusion Essential interface for consistent state management across all API operations.
+ */
+interface RequestResult<T> {
+    /** Boolean flag indicating if the request is currently in progress */
+    isLoading: boolean;
+    /** Boolean flag indicating the request completed successfully */
+    isSuccess: boolean;
+    /** Boolean flag indicating an error occurred during the request */
+    isError: boolean;
+    /** Holds the Axios error object if an error occurred, null otherwise */
+    error: AxiosError | null;
+    /** Holds the successful Axios response data, null if no successful request yet */
+    data: AxiosResponse<T> | null;
+}
+/**
+ * @interface UseApiRequest
+ * @description Generic interface for custom API hooks that perform HTTP operations with comprehensive state tracking.
+ * Provides a standardized pattern for API request functions with built-in state management.
+ *
+ * @declaration
+ * ```typescript
+ * interface UseApiRequest<T = {}, P = void> {
+ *   (url: string, payloadOrConfig?: P, config?: AxiosRequestConfig): void;
+ *   state: RequestResult<T>;
+ * }
+ * ```
+ *
+ * @requiredParams None (interface definition)
+ *
+ * @returnType Interface definition
+ *
+ * @example
+ * ```typescript
+ * const fetchUser: UseApiRequest<User, { id: number }> = useApi({
+ *   onSuccess: (response) => console.log('User fetched:', response.data),
+ *   onError: (error) => console.error('Failed to fetch user:', error)
+ * });
+ *
+ * // Usage
+ * fetchUser('/api/users', { id: 123 });
+ *
+ * // Access state
+ * if (fetchUser.state.isLoading) {
+ *   return <LoadingSpinner />;
+ * }
+ * ```
+ *
+ * @return Interface definition for API request hooks
+ *
+ * @conclusion Provides a consistent pattern for all API operations with built-in state management and error handling.
+ */
+interface UseApiRequest<T = {}, P = void> {
+    /**
+     * Executes the API request with the provided parameters
+     * @param url - The API endpoint URL
+     * @param payloadOrConfig - Request payload or configuration object
+     * @param config - Additional Axios configuration options
+     */
+    (url: string, payloadOrConfig?: P, config?: AxiosRequestConfig): void;
+    /** Current state of the request including loading, success, error, and data */
+    state: RequestResult<T>;
+}
+/**
+ * @type UseGetRequest
+ * @description Tuple type for HTTP GET request hooks with comprehensive state management.
+ * Provides a clean API for making GET requests with built-in loading, success, and error states.
+ *
+ * @declaration
+ * ```typescript
+ * type UseGetRequest<T = {}> = [
+ *   (url: string, config?: AxiosRequestConfig) => void,
+ *   RequestResult<T>
+ * ];
+ * ```
+ *
+ * @requiredParams None (type definition)
+ *
+ * @returnType Tuple type definition
+ *
+ * @example
+ * ```typescript
+ * const [getUser, userState] = useGetRequest<User>();
+ *
+ * // Execute request
+ * getUser("/api/users/123");
+ *
+ * // Access state
+ * if (userState.isLoading) return <LoadingSpinner />;
+ * if (userState.isError) return <ErrorMessage error={userState.error} />;
+ * if (userState.isSuccess) return <UserProfile user={userState.data?.data} />;
+ * ```
+ *
+ * @return Tuple type: [request function, state object]
+ *
+ * @conclusion Provides a consistent pattern for GET requests with comprehensive state management.
+ */
+type UseGetRequest<T = {}> = [
+    (url: string, config?: AxiosRequestConfig) => void,
+    RequestResult<T>
+];
+/**
+ * @type UsePostRequest
+ * @description Tuple type for HTTP POST request hooks with typed payload and state management.
+ * Ideal for creating new resources with comprehensive error handling and state tracking.
+ *
+ * @declaration
+ * ```typescript
+ * type UsePostRequest<T = {}> = [
+ *   (url: string, payload: T, config?: AxiosRequestConfig) => void,
+ *   RequestResult<T>
+ * ];
+ * ```
+ *
+ * @requiredParams None (type definition)
+ *
+ * @returnType Tuple type definition
+ *
+ * @example
+ * ```typescript
+ * const [createUser, createState] = usePostRequest<User>();
+ *
+ * // Execute request
+ * createUser("/api/users", {
+ *   name: "John Doe",
+ *   email: "john@example.com"
+ * });
+ *
+ * // Access state
+ * if (createState.isLoading) return <LoadingSpinner />;
+ * if (createState.isSuccess) {
+ *   console.log("User created:", createState.data?.data);
+ * }
+ * ```
+ *
+ * @return Tuple type: [request function, state object]
+ *
+ * @conclusion Essential type for POST operations with robust state management and error handling.
+ */
+type UsePostRequest<T = {}> = [
+    (url: string, payload: T, config?: AxiosRequestConfig) => void,
+    RequestResult<T>
+];
+/**
+ * @type UsePutRequest
+ * @description Tuple type for HTTP PUT request hooks with typed payload and comprehensive state tracking.
+ * Perfect for updating existing resources with full state management capabilities.
+ *
+ * @declaration
+ * ```typescript
+ * type UsePutRequest<T = {}> = [
+ *   (url: string, payload: T, config?: AxiosRequestConfig) => void,
+ *   RequestResult<T>
+ * ];
+ * ```
+ *
+ * @requiredParams None (type definition)
+ *
+ * @returnType Tuple type definition
+ *
+ * @example
+ * ```typescript
+ * const [updateUser, updateState] = usePutRequest<User>();
+ *
+ * // Execute request
+ * updateUser("/api/users/123", {
+ *   name: "Jane Doe",
+ *   email: "jane@example.com"
+ * });
+ *
+ * // Access state
+ * if (updateState.isLoading) return <LoadingSpinner />;
+ * if (updateState.isSuccess) {
+ *   console.log("User updated:", updateState.data?.data);
+ * }
+ * ```
+ *
+ * @return Tuple type: [request function, state object]
+ *
+ * @conclusion Provides consistent pattern for PUT operations with comprehensive state management.
+ */
+type UsePutRequest<T = {}> = [
+    (url: string, payload: T, config?: AxiosRequestConfig) => void,
+    RequestResult<T>
+];
+/**
+ * @type UseDeleteRequest
+ * @description Tuple type for HTTP DELETE request hooks with optional configuration and state management.
+ * Provides clean API for resource deletion with comprehensive error handling.
+ *
+ * @declaration
+ * ```typescript
+ * type UseDeleteRequest<T = {}> = [
+ *   (url: string, config?: AxiosRequestConfig) => void,
+ *   RequestResult<T>
+ * ];
+ * ```
+ *
+ * @requiredParams None (type definition)
+ *
+ * @returnType Tuple type definition
+ *
+ * @example
+ * ```typescript
+ * const [deleteUser, deleteState] = useDeleteRequest<void>();
+ *
+ * // Execute request
+ * deleteUser("/api/users/123");
+ *
+ * // Access state
+ * if (deleteState.isLoading) return <LoadingSpinner />;
+ * if (deleteState.isSuccess) {
+ *   console.log("User deleted successfully");
+ * }
+ * ```
+ *
+ * @return Tuple type: [request function, state object]
+ *
+ * @conclusion Essential type for DELETE operations with robust state management.
+ */
+type UseDeleteRequest<T = {}> = [
+    (url: string, config?: AxiosRequestConfig) => void,
+    RequestResult<T>
+];
+/**
+ * @type UsePatchRequest
+ * @description Tuple type for HTTP PATCH request hooks with typed payload and comprehensive state tracking.
+ * Ideal for partial updates with built-in state management and error handling.
+ *
+ * @declaration
+ * ```typescript
+ * type UsePatchRequest<T = {}> = [
+ *   (url: string, payload: T, config?: AxiosRequestConfig) => void,
+ *   RequestResult<T>
+ * ];
+ * ```
+ *
+ * @requiredParams None (type definition)
+ *
+ * @returnType Tuple type definition
+ *
+ * @example
+ * ```typescript
+ * const [patchUser, patchState] = usePatchRequest<Partial<User>>();
+ *
+ * // Execute request
+ * patchUser("/api/users/123", {
+ *   email: "newemail@example.com"
+ * });
+ *
+ * // Access state
+ * if (patchState.isLoading) return <LoadingSpinner />;
+ * if (patchState.isSuccess) {
+ *   console.log("User patched:", patchState.data?.data);
+ * }
+ * ```
+ *
+ * @return Tuple type: [request function, state object]
+ *
+ * @conclusion Provides consistent pattern for PATCH operations with comprehensive state management.
+ */
+type UsePatchRequest<T = {}> = [
+    (url: string, payload: T, config?: AxiosRequestConfig) => void,
+    RequestResult<T>
+];
 
 interface StartCallPayload {
     mobileNumber: string;
@@ -83,19 +765,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 RequestOptions, type RequestResult, type SDKConfig, type SDKState, type UseApiRequest, type UseDeleteRequest, type UseGetRequest, type UsePatchRequest, type UsePostRequest, type UsePutRequest, getSDKVersion, initSDK, isSDKInitialized, useClickToCall, useEndCall, useLogout };