import React from 'react';

/**
 * @fileoverview TypeScript Declaration File for SDK State Manager
 * @description Type declarations for the SDK state management system.
 * Provides type definitions for centralized state management in the Call Control SDK.
 *
 * @author CTI SDK Team
 * @version 6.x.x
 * @since 2024
 */

/**
 * Inline type definitions to avoid Rollup DTS bundler resolution issues
 * with relative imports from handwritten .d.ts files.
 */
type SDKConfig$1 = {
	disableEndCallButton?: boolean;
	disableEndConference?: boolean;
	enableSmsServices?: boolean;
	enableQueueName?: boolean;
	enableRingtone?: boolean;
	disabledMoreOptionsButton?: boolean;
	disabledDialButton?: boolean;
	disableCallTransferButton?: boolean;
	disableBlindTransfer?: boolean;
	disableAttendedTransfer?: boolean;
	disableWarmTransfer?: boolean;
	isDraggable?: boolean;
	disableSoftPhone?: boolean;
	disableConferenceButton?: boolean;
	disableHoldButton?: boolean;
	disableMuteButton?: boolean;
	disableCallDisposition?: boolean;
	disabled?: any;
	enabled?: any;
	outlined?: any;
	auto_wrapup_time?: number;
	break_time?: number;
	breakDetailsVisible?: boolean;
	break_details_visible?: boolean;
	sdkPosition?: "horizontal" | "vertical";
};

type CallStatus =
	| "IDLE"
	| "READY"
	| "BREAK"
	| "ONCALL"
	| "WRAPUP"
	| "RINGING"
	| "DIALING"
	| "MISSED"
	| "HOLD"
	| "UNHOLD"
	| "MUTE"
	| "UNMUTE"
	| "DISCONNECTED"
	| "CONFERENCE"
	| string;

type CallData$1 = {
	mode?: string;
	queue_name?: string;
	mobileNumber?: string;
	callReferenceId?: string;
	callId?: string;
	type?: string;
	status: string;
	agent_id: number;
	phone_number?: string;
	event_time?: string;
	call_id?: string;
	process_id?: string;
	process_name?: string;
	mute?: number;
	hold?: number;
	auto_wrapup_time?: number | null;
};

type ConferenceLineTypes = {
	line: number;
	status: string;
	type: "external" | "internal" | "";
	phone: string;
	isMute: boolean;
	isHold: boolean;
	isCallStart: boolean;
	isMergeCall: boolean;
};

type SDKState$1 = {
	authorization: any;
	openConferenceDialog: boolean;
	openCallTransferDialog: boolean;
	process?: { process_id: number; process_name: string } | null;
	agentId: string;
	sessionId?: string;
	sdkConfig: SDKConfig$1 | null;
	urlConfig: any | null;
	isInitialized: boolean;
	call_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$1;
	conferenceLine: ConferenceLineTypes[];
	hold: number;
	mute: number;
	agentStatus: string;
	sdk: any | null;
	isPermissionsLoaded: boolean;
	userPermissions: string[] | null;
	menuEntitlements: Array<{ code: string; name: string; enabled: boolean }> | null;
	consultInfo: any | null;
};

/**
 * @interface SDKStateManager
 * @description Interface for the SDK state manager class
 */
interface SDKStateManager {
	/**
	 * Initialize the SDK with API key, tenant ID, agent ID, and optional configuration
	 * @param apiKey - API key for authentication
	 * @param tenantId - Tenant identifier
	 * @param agentId - Agent identifier
	 * @param urlConfig - Optional URL configuration
	 * @param res - Optional initialization response
	 * @param callControlConfig - Optional call control configuration
	 */
	initialize(apiKey: string, tenantId: string, agentId: string, urlConfig?: any, res?: any, callControlConfig?: SDKConfig$1): void;

	/**
	 * Get the current state
	 * @returns Current SDK state
	 */
	getState(): SDKState$1;

	/**
	 * Tenant this session authenticated against, from the login response's
	 * `tenantInfo`. Read from persisted state, so it resolves on any mount.
	 * @returns Tenant id as a string, or undefined when not initialized
	 */
	getTenantId(): string | undefined;

	/**
	 * Subscribe to state changes
	 * @param listener - Callback function to be called on state changes
	 * @returns Unsubscribe function
	 */
	subscribe(listener: () => void): () => void;

	/**
	 * Set holding state
	 * @param isHolding - Whether call is on hold
	 */
	setHolding(isHolding: boolean): void;

	/**
	 * Set muted state
	 * @param isMuted - Whether call is muted
	 */
	setMuted(isMuted: boolean): void;

	/**
	 * Set call status
	 * @param status - Current call status
	 */
	setStatus(status: CallStatus): void;

	/**
	 * Set process information
	 * @param process - Process data with ID and name
	 */
	setProcess(process: { process_id: number; process_name: string }): void;

	/**
	 * Set control panel position
	 * @param position - X and Y coordinates
	 */
	setControlPanelPosition(position: { x: number; y: number }): void;

	/**
	 * Set iframe position
	 * @param position - X and Y coordinates
	 */
	setIframePosition(position: { x: number; y: number }): void;

	/**
	 * Start a call (set start time and status)
	 */
	startCall(): void;

	/**
	 * End a call (reset call state)
	 */
	endCall(): void;

	/**
	 * Set initialization check flag
	 */
	setInitCheck(): void;

	/**
	 * Set conference dialog open state
	 * @param open - Whether conference dialog is open
	 */
	setOpenConferenceDialog(open: boolean): void;

	/**
	 * Set call transfer dialog open state
	 * @param open - Whether call transfer dialog is open
	 */
	setOpenCallTransferDialog(open: boolean): void;

	/**
	 * Update call data
	 * @param data - Partial call data to update
	 */
	updateCallData(data: Partial<CallData$1>): void;

	/**
	 * Update conference data
	 * @param data - Array of conference line data
	 */
	updateConferenceData(data: ConferenceLineTypes[]): void;

	/**
	 * Set specific conference line
	 * @param line - Conference line data
	 */
	setConferenceLine(line: ConferenceLineTypes): void;

	/**
	 * Reset conference lines to initial state
	 */
	resetConferenceLines(): void;

	/**
	 * Clear storage and reset to initial state
	 */
	clearStorageAndReset(): void;

	/**
	 * Debug storage data
	 */
	debugStorage(): void;

	/**
	 * Get conference lines
	 * @returns Array of conference line data
	 */
	getConferenceLines(): ConferenceLineTypes[];

	/**
	 * Set SDK permissions from user info
	 * @param userInfo - User info object from init response
	 */
	setSDKPermissions(userInfo: any): void;

	/**
	 * Get entitlement-based controls configuration
	 * @returns Controls configuration derived from permissions
	 */
	getControlsConfig(): Partial<SDKConfig$1>;
}

/**
 * @class SDKStateManager
 * @description Centralized state management class for the Call Control SDK.
 * Handles state persistence, subscriptions, and provides methods for state updates.
 */
declare class SDKStateManager implements SDKStateManager {
	/**
	 * Initialize the SDK with API key, tenant ID, agent ID, and optional configuration
	 * @param apiKey - API key for authentication
	 * @param tenantId - Tenant identifier
	 * @param agentId - Agent identifier
	 * @param urlConfig - Optional URL configuration
	 * @param res - Optional initialization response
	 * @param callControlConfig - Optional call control configuration
	 */
	public initialize(apiKey: string, tenantId: string, agentId: string, urlConfig?: any, res?: any, callControlConfig?: SDKConfig$1): void;

	/**
	 * Get the current state
	 * @returns Current SDK state
	 */
	public getState(): SDKState$1;

	/**
	 * Subscribe to state changes
	 * @param listener - Callback function to be called on state changes
	 * @returns Unsubscribe function
	 */
	public subscribe(listener: () => void): () => void;

	/**
	 * Store lead data to be attached as lead_data in the transfer API payload.
	 * Call this whenever lead details change in the host application.
	 */
	public setTransferLeadData(data: any): void;

	/**
	 * Get the currently stored lead data.
	 */
	public getTransferLeadData(): any;

	/**
	 * Clear stored lead data (called automatically when call goes IDLE).
	 */
	public clearTransferLeadData(): void;

	/**
	 * Set holding state
	 * @param isHolding - Whether call is on hold
	 */
	public setHolding(isHolding: boolean): void;

	/**
	 * Set muted state
	 * @param isMuted - Whether call is muted
	 */
	public setMuted(isMuted: boolean): void;

	/**
	 * Set call status
	 * @param status - Current call status
	 */
	public setStatus(status: CallStatus): void;

	/**
	 * Set process information
	 * @param process - Process data with ID and name
	 */
	public setProcess(process: { process_id: number; process_name: string }): void;

	/**
	 * Set control panel position
	 * @param position - X and Y coordinates
	 */
	public setControlPanelPosition(position: { x: number; y: number }): void;

	/**
	 * Set iframe position
	 * @param position - X and Y coordinates
	 */
	public setIframePosition(position: { x: number; y: number }): void;

	/**
	 * Start a call (set start time and status)
	 */
	public startCall(): void;

	/**
	 * End a call (reset call state)
	 */
	public endCall(): void;

	/**
	 * Set initialization check flag
	 */
	public setInitCheck(): void;

	/**
	 * Set conference dialog open state
	 * @param open - Whether conference dialog is open
	 */
	public setOpenConferenceDialog(open: boolean): void;

	/**
	 * Set call transfer dialog open state
	 * @param open - Whether call transfer dialog is open
	 */
	public setOpenCallTransferDialog(open: boolean): void;

	/**
	 * Update call data
	 * @param data - Partial call data to update
	 */
	public updateCallData(data: Partial<CallData$1>): void;

	/**
	 * Update conference data
	 * @param data - Array of conference line data
	 */
	public updateConferenceData(data: ConferenceLineTypes[]): void;

	/**
	 * Set specific conference line
	 * @param line - Conference line data
	 */
	public setConferenceLine(line: ConferenceLineTypes): void;

	/**
	 * Reset conference lines to initial state
	 */
	public resetConferenceLines(): void;

	/**
	 * Clear storage and reset to initial state
	 */
	public clearStorageAndReset(): void;

	/**
	 * Debug storage data
	 */
	public debugStorage(): void;

	/**
	 * Get conference lines
	 * @returns Array of conference line data
	 */
	public getConferenceLines(): ConferenceLineTypes[];

	/**
	 * Set SDK permissions from user info
	 * @param userInfo - User info object from init response
	 */
	public setSDKPermissions(userInfo: any): void;

	/**
	 * Get entitlement-based controls configuration
	 * @returns Controls configuration derived from permissions
	 */
	public getControlsConfig(): Partial<SDKConfig$1>;
}

/**
 * @constant sdkStateManager
 * @description Singleton instance of the SDK state manager
 * @type {SDKStateManager}
 */
declare const sdkStateManager: SDKStateManager;

/**
 * @fileoverview 📦 TypeScript Declaration File for Call Control SDK
 * @description Comprehensive CTI (Computer Telephony Integration) SDK for agent platform applications.
 * Provides complete call control functionality including dialing, conferencing, transferring,
 * and real-time call management with WebSocket integration.
 *
 * @author CTI SDK Team
 * @version 6.x.x
 * @since 2024
 */

// =============================================================================
// 🎯 MAIN SDK FUNCTIONS
// =============================================================================

/**
 * 🚀 SDK Initialization Parameters Interface
 *
 * @interface InitSDKParams
 * @description Parameters required for SDK initialization
 *
 * @properties
 * - `apiKey: string` - Authentication key for SDK access
 * - `tenantId: string` - Tenant identifier for multi-tenancy support
 * - `agentId: string` - Agent identifier for call management
 * - `sdkConfig?: SDKConfig` - Optional SDK configuration for customizing behavior
 *
 * @example
 * ```typescript
 * const initParams: InitSDKParams = {
 *   apiKey: "your-api-key",
 *   tenantId: "tenant-123",
 *   agentId: "agent-456",
 *   sdkConfig: {
 *     isDraggable: true,
 *     disableSoftPhone: false
 *   }
 * };
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
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;
	/** Optional URL configuration for SDK endpoints */
	urlConfig?: URLConfig;
}

/**
 * 🚀 Initialize the Call Control SDK
 *
 * @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.
 *
 * @param {InitSDKParams} params - Object containing API key, tenant ID, agent ID, and optional config
 * @returns {Promise<void>} Promise that resolves when initialization is complete
 *
 * @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
 *   }
 * });
 * ```
 *
 * @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
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface SDKInitResult {
	accessToken: string;
	expiration: string;
	ticketId: string;
	callControls: any;
	userInfo: any;
	/**
	 * Tenant this session authenticated against, forwarded from the login response.
	 * Tenant-keyed pages (Caro Voice AI) resolve their tenant from here.
	 */
	tenantInfo?: {
		tenantId?: number | string;
		slug?: string;
	};
}

declare function initSDK(params: InitSDKParams): Promise<SDKInitResult>;

/**
 * 📋 Get SDK Version
 *
 * @function getSDKVersion
 * @description Returns the current version of the Call Control SDK
 *
 * @returns {string} Current SDK version string
 *
 * @example
 * ```typescript
 * const version = getSDKVersion();
 * console.log(`Using Call Control SDK version: ${version}`);
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
declare function getSDKVersion(): string;

/**
 * ✅ Check SDK Initialization Status
 *
 * @function isSDKInitialized
 * @description Checks if the SDK has been successfully initialized
 *
 * @returns {boolean} True if SDK is initialized, false otherwise
 *
 * @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");
 * }
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
declare function isSDKInitialized(): boolean;

// =============================================================================
// 🎭 COMPONENT EXPORTS
// =============================================================================

/**
 * 🎭 Call Control Panel Component
 *
 * @component CallControlPanel
 * @description Main call control panel component for the CTI SDK.
 * Provides comprehensive call management interface with all necessary controls.
 *
 * @param {CallControlPanelProps} props - Component props
 * @returns {JSX.Element} Call control panel interface
 *
 * @example
 * ```tsx
 * <CallControlPanel onDataChange={handleDataChange} />
 *
 * <CallControlPanel onDataChange={(data) => {
 *   console.log('Call Data:', data);
 * }} />
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
declare const CallControlPanel: React.ComponentType<CallControlPanelProps>;

/**
 * ☎️ Call Control Iframe — full iframe-hosted softphone
 *
 * @component CallControlIframe
 * @description The complete softphone surface (keypad, active-call controls,
 * transfer, conference, recents, agent bar) hosted in an iframe by the ahs-cti
 * Browser-Phone app.
 *
 * Use this **instead of** {@link CallControlPanel}, not alongside it. The phone
 * owns the agent-events websocket and forwards every event into SDK state, so
 * `useGetCallerData()` / `useSDKState()` stay live for the rest of the host app
 * with no changes at the call sites. Rendering both components opens two
 * sockets for the same agent.
 *
 * Works two ways:
 * - **Zero-config** — every prop omitted; the iframe URL, user id, token, theme
 *   colour and control gating all come from the state `initSDK` populated. Pass
 *   `urlConfig.iframeURL` to `initSDK` and nothing else is needed.
 * - **Host-driven** — pass `iframeBaseUrl` / `apiHost` / `wsUrl` / `token` /
 *   `userId` / `primaryColor` and the SDK reads no state for those, for a host
 *   that owns its own auth and theme.
 *
 * @param {CallControlIframeProps} props - Component props
 * @returns {JSX.Element | null} Draggable softphone panel, or `null` while the
 * config is still resolving / when `sdkConfig.disableSoftPhone` is set
 *
 * @example
 * ```tsx
 * // Zero-config — everything resolved from initSDK
 * <CallControlIframe agentName={`${user.firstName} ${user.lastName}`} />
 *
 * // Host-driven — the SDK reads no state for these
 * <CallControlIframe
 *   iframeBaseUrl={`${MEDIA_SERVER_HOST}/static/phone/iframe_index.html`}
 *   apiHost={API_HOST}
 *   wsUrl={WS_HOST}
 *   token={token}
 *   userId={user.id}
 *   primaryColor={theme.primary}
 * />
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
declare const CallControlIframe: React.ComponentType<CallControlIframeProps>;

/**
 * @interface CallControlIframeProps
 * @description Props for {@link CallControlIframe}. Every field is optional —
 * anything omitted is resolved from the state `initSDK` populated.
 */
interface CallControlIframeProps {
	/**
	 * URL the phone is served from. Defaults to `urlConfig.iframeURL` passed to
	 * `initSDK`. A value that already carries a path is used verbatim; a bare
	 * origin gets `entryPath` appended.
	 */
	iframeBaseUrl?: string;
	/**
	 * Path appended when the resolved base is a bare origin.
	 * Default `/static/phone/iframe_index.html`.
	 */
	entryPath?: string;
	/** REST API host passed to the phone as `api_url`. Defaults to `urlConfig.iframeAPIURL`. */
	apiHost?: string;
	/** WebSocket host passed to the phone as `ws_url`. Defaults to `urlConfig.webSocketURL`. */
	wsUrl?: string;
	/** Auth token; a leading `Bearer ` is added if missing. Defaults to the SDK's own access token. */
	token?: string;
	/** Logged-in user id, passed as `user_id`. Defaults to `urlConfig.id`. */
	userId?: string | number;
	/** User reference, passed as `user_ref`. Defaults to the SDK's `agentId`. */
	userRef?: string;
	/** Theme primary color; the leading `#` is stripped before it is passed as `primary`. Defaults to the MUI theme's primary. */
	primaryColor?: string;
	/** SIP extension pushed to the phone via `cti:ext` (cosmetic — the phone self-provisions). */
	ext?: string;
	/** Agent display name shown in the phone's agent bar. */
	agentName?: string;
	/** Auto wrap-up seconds; drives the phone's wrap-up countdown. */
	autoWrapupTime?: number | null;
	/** Show the phone's break/status selector (passed as `can_break`). Default `true`. */
	canBreak?: boolean;
	/**
	 * Current call status, used to auto-reopen a collapsed panel and flag the
	 * launcher. Defaults to the live status in SDK state, which this component
	 * keeps current — so a host normally omits it.
	 */
	callStatus?: string;
	/**
	 * Raw SDK entitlements (`userInfo.entitlements.sdk`) used to derive the
	 * disabled-controls list. When passed at all it takes precedence over the
	 * entitlement-resolved `sdkConfig`, including failing closed (everything
	 * disabled) if the value is absent. Ignored when `disabledControls` is given.
	 */
	sdkEntitlements?: SDKEntitlements;
	/** Explicit comma-list of disabled controls; bypasses every derivation. */
	disabledControls?: string;
	/** Render the panel expanded on mount. Default `true`. */
	defaultOpen?: boolean;
	/** Panel width in px. Default 440. */
	width?: number;
	/** Panel height in px. Default 640. */
	height?: number;
	/** Same payload shape `CallControlPanel`'s `onDataChange` emits. */
	onDataChange?: (_data: CallData) => void;
}

/**
 * 📄 SDK Pages
 *
 * @description Pre-built pages provided by the SDK, automatically protected by permission guards.
 *
 * @properties
 * - `CallHistory` - Call History page component
 * - `Campaigns` - Campaigns / Call Scheduling page component
 * - `LoginReport` - Agent Login Report page component
 * - `CdrReports` - CDR (Call Detail Records) Report page component
 * - `AuditReportPage` - Stand-alone (full-tab) audit report page component
 * - `AgentPerformanceReport` - Agent Performance Report page component
 * - `AgentDetailReport` - Agent Detail Report page component
 * - `LiveStatus` - Supervisor Live Status / Wallboard page component
 * - `LeadIntegrations` - Lead Integrations page component (webhooks + form → campaign mappings)
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */

interface LiveStatusPageProps {
	/** When true, renders the TV/wallboard variant: shows the top bar with clock, hides monitor action buttons */
	isTvDashboard?: boolean;
}

declare const SDKPages: {
	readonly CallHistory: React.ComponentType<any>;
	readonly Campaigns: React.ComponentType<any>;
	readonly LoginReport: React.ComponentType<any>;
	readonly CdrReports: React.ComponentType<any>;
	readonly SummaryReport: React.ComponentType<any>;
	readonly AuditReportPage: React.ComponentType<{ callUuid?: string }>;
	readonly AgentPerformanceReport: React.ComponentType<any>;
	readonly AgentDetailReport: React.ComponentType<any>;
	readonly LiveStatus: React.ComponentType<LiveStatusPageProps>;
	readonly ManagementDashboard: React.ComponentType<any>;
	readonly CaroVoiceAI: React.ComponentType<any>;
	readonly QualityAuditDashboard: React.ComponentType<any>;
	readonly CaroQualityAuditDashboard: React.ComponentType<any>;
	readonly LeadIntegrations: React.ComponentType<any>;
};

// =============================================================================
// 📋 STAND-ALONE PAGE / DIALOG COMPONENTS
// =============================================================================
// These are exported at the top level (in addition to being reachable through
// `SDKPages`) so hosts can mount them directly — e.g. a ticket list opening the
// audit report for a `convoxid`, or a reports route wrapping AgentDetailReport
// in its own layout. Keep this block in sync with the `export`s in index.ts.

interface AuditReportDialogProps {
	open: boolean;
	onClose: () => void;
	/** Dialog width. Defaults to "80vw". */
	width?: string;
	/** Full CDR row to audit. */
	rowData?: any;
	/**
	 * Call to audit. Use this when you have a bare call id (e.g. a ticket's
	 * `convoxid`) rather than a full CDR row. Takes precedence over
	 * `rowData.callUuid` when both are provided.
	 */
	callUuid?: string;
	/**
	 * Per-instance override of the maximize behaviour. When provided it takes
	 * precedence over the globally-configured resolver — useful for in-app
	 * navigation instead of opening a new tab.
	 */
	onMaximize?: (callUuid: string) => void;
}

/**
 * 🔍 Audit report shown in a modal dialog. The maximize button opens the same
 * report full-screen in a new browser tab; the URL is built by the
 * host-configured resolver (see `setAuditReportUrlResolver`).
 *
 * @since 1.0.0
 */
declare const AuditReportDialog: React.ComponentType<AuditReportDialogProps>;

/** Builds the URL the audit-report maximize button opens for a given call. */
type AuditReportUrlResolver = (callUuid: string) => string;

/**
 * Configure how the audit-report maximize button builds its new-tab URL.
 * Call once during host-app startup, alongside registering the route that
 * renders `SDKPages.AuditReportPage`. The default targets a ROOT-level
 * "/audit-report/:callUuid" route.
 *
 * @example
 * // Route registered at "/reports/audit-report/:callUuid":
 * setAuditReportUrlResolver((id) => `/reports/audit-report/${encodeURIComponent(id)}`);
 * // Hash router:
 * setAuditReportUrlResolver((id) => `/#/audit-report/${encodeURIComponent(id)}`);
 */
declare function setAuditReportUrlResolver(
	resolver: AuditReportUrlResolver,
): void;

interface AgentDetailReportProps {
	/** Agent row from the Agent Performance Report list. */
	agentRow?: any;
	/** Invoked when the user navigates back to the list. */
	onBack?: () => void;
	/** Where the report was opened from; "REPORTS_LIST" renders the back affordance. */
	from?: "REPORTS_LIST" | string;
	/** Initial date-range start (dayjs instance). */
	initialStartDate?: any;
	/** Initial date-range end (dayjs instance). */
	initialEndDate?: any;
	/** Initial quick-range preset key (e.g. "today", "last7days"). */
	initialQuickRange?: string;
}

/**
 * 📊 Agent Detail Report page component.
 *
 * @since 1.0.0
 */
declare const AgentDetailReport: React.ComponentType<AgentDetailReportProps>;

// =============================================================================
// 🗃️ TYPE EXPORTS
// =============================================================================

/**
 * 📞 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
 * - `callReferenceId?: string` - Unique reference identifier for the call
 * - `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
 * - `process_id?: string` - Process identifier for the call
 * - `process_name?: string` - Name of the process handling the call
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface CallData {
	mode?: string;
	queue_name?: string;
	mobileNumber?: string;
	callReferenceId?: string;
	convoxId?: string;
	type?: string;
	status: string;
	agent_id: number;
	phone_number?: string;
	event_time?: string;
	call_id?: string;
	process_id?: string;
	process_name?: string;
	mute?: number;
	hold?: number;
	auto_wrapup_time?: number | null;
	source?: string;
	call_details?: {
		extension?: string;
		call_type?: string;
		caller_direction?: string;
		agent_id?: number;
		queue_name?: string;
		did_number?: string;
		call_uuid?: string;
		source?: string;
		[key: string]: any;
	};
	/** Lead data set by the host app; attached when available */
	lead_data?: any;
	/** Raw socket payload from the most recent WebSocket message */
	socket_info?: any;
	break_details?: {
		type: string;
		value: string;
	} | null;
}

/**
 * ⚙️ SDK Configuration Interface
 *
 * @interface SDKConfig
 * @description Configuration interface for customizing the Call Control SDK behavior.
 * Allows disabling specific features and customizing the visual appearance of components.
 *
 * @properties
 * - `disableEndCallButton?: boolean` - Whether to disable the end call button
 * - `disabledDialButton?: boolean` - Whether to disable the dial button
 * - `disableCallTransferButton?: boolean` - Whether to disable the call transfer button
 * - `isDraggable?: boolean` - Whether the control panel should be draggable
 * - `disableSoftPhone?: boolean` - Whether to disable the soft phone iframe
 * - `disableConferenceButton?: boolean` - Whether to disable the conference button
 * - `disabled?: SxProps` - Custom styles for disabled button states
 * - `enabled?: SxProps` - Custom styles for enabled button states
 * - `outlined?: SxProps` - Custom styles for outlined button states
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface SDKConfig {
	disableEndCallButton?: boolean;
	disableEndConference?: boolean;
	disabledDialButton?: boolean;
	enableSmsServices?: boolean;
	enableQueueName?: boolean;
	disableCallTransferButton?: boolean;
	isDraggable?: boolean;
	disableSoftPhone?: boolean;
	disableConferenceButton?: boolean;
	disabled?: any;
	enabled?: any;
	outlined?: any;
}

interface URLConfig {
	id?: string;
	baseURL: string;
	iframeURL: string;
	iframeAPIURL: string;
	password: string;
	webSocketURL: string;
	coreBaseURL: string;
	accessToken?: string;
	caroVoiceAIURL?: string;
}

/**
 * 🎭 Call Control Panel Props Interface
 *
 * @interface CallControlPanelProps
 * @description Props interface for the CallControlPanel component.
 * Defines the properties passed to the call control panel.
 *
 * @properties
 * - `onDataChange?: (data: CallData) => void` - Callback for call data changes
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface CallControlPanelProps {
	onDataChange?: (data: CallData) => void;
}

// =============================================================================
// 🔧 HOOK EXPORTS
// =============================================================================

/**
 *
 * This file contains TypeScript type definitions for the useEndCall custom hook
 * and its related interfaces. It provides comprehensive type safety and IntelliSense
 * support for developers using the CTI SDK call termination functionality.
 *
 * 🎯 Key Type Definitions:
 * - 📞 EndCallPayload interface for call termination API data
 * - 📞 useEndCall hook return type
 * - 🔄 Call termination function signature
 * - 📊 State management types
 * - 📅 Callback scheduling types
 *
 * @author CTI SDK Team
 * @version 6.x.x
 * @since 1.0.0
 */

/**
 * End Call Payload Interface
 *
 * @interface EndCallPayload
 * @description Defines the options for ending a call. All fields are optional —
 *              any omitted field falls back to the current session/call state automatically.
 *
 * @properties
 * - `call_id?: string`         - Convox call ID (defaults to active call's call_id)
 * - `agent_id?: string`          - Agent identifier (defaults to logged-in agent)
 * - `set_followUp?: string`      - Whether a follow-up is required: "Y" or "N" (default: "N")
 * - `callback_date?: string`     - Scheduled callback date (YYYY-MM-DD)
 * - `callback_hrs?: number`      - Scheduled callback hour (0–23)
 * - `callback_mins?: number`     - Scheduled callback minute (0–59)
 * - `mobile_number?: string`     - Customer phone number (defaults to active call's phone_number)
 * - `list_comments?: string`     - Optional comments for the call log
 * - `call_reference_id?: string` - Call reference ID (defaults to active call's call_id)
 * - `disposition?: string`       - Call outcome code (default: "RES")
 * - `line_number?: number`       - Conference line number (default: 0)
 * - `reason?: string`            - End reason sent to server (default: "normal")
 * - `is_mark_as_break?: boolean` - Whether agent is going on break after the call (sent in request body)
 * - `break_type?: string`        - Break applied with `is_mark_as_break` (a backend break type from GET /cti/breaks); empty lets the backend pick its default post-call break
 * - `patientLog?: any`           - Optional patient/contact log data
 *
 * @example
 * ```typescript
 * // Minimal — all defaults applied from session state
 * await endCall();
 *
 * // With disposition and follow-up callback
 * await endCall({
 *   disposition: "RES",
 *   set_followUp: "Y",
 *   callback_date: "2026-05-20",
 *   callback_hrs: 10,
 *   callback_mins: 30,
 * });
 *
 * // Agent going on break after call
 * await endCall({ disposition: "RES", is_mark_as_break: true });
 *
 * // …on a named break from the tenant's breaks list
 * await endCall({ disposition: "RES", is_mark_as_break: true, break_type: "Lunch" });
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface EndCallPayload {
	call_id?: string;
	agent_id?: string;
	set_followUp?: string;
	callback_date?: string;
	callback_hrs?: number;
	callback_mins?: number;
	mobile_number?: string;
	list_comments?: string;
	call_reference_id?: string;
	is_mark_as_break?: boolean;
	break_type?: string;
	disposition?: string;
	line_number?: number;
	reason?: string;
	patientLog?: any;
}

/**
 * 📅 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 = {
	/**
	 * ⏳ 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 {
	/**
	 * 📞 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 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
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
declare const useEndCall: () => UseEndCallReturn;

/**
 * 📝 Disposition Types
 *
 * @type DispositionType
 * @description 🎯 Type definitions for call disposition values
 *              Used for call outcome classification
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
type DispositionType = string;

/**
 * 📅 Follow-up Types
 *
 * @type FollowUpType
 * @description 🎯 Type definitions for follow-up requirement values
 *              Used for callback scheduling
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
type FollowUpType = string;

/**
 * ⚙️ Process Data Interface
 *
 * @interface ProcessData
 * @description 📊 Type definition for process data structure
 *              Contains information about the current process
 *
 * @properties
 * - `process_id: number` - 🔢 Process identifier
 * - `process_name: string` - 📝 Process name
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface ProcessData {
	/**
	 * 🔢 Process identifier
	 * @description Unique identifier for the process
	 * @type {number}
	 */
	process_id: number;

	/**
	 * 📝 Process name
	 * @description Human-readable name of the process
	 * @type {string}
	 */
	process_name: string;
}

/**
 * 📞 Call Data Interface
 *
 * @interface EndCallPayLoadData
 * @description 📊 Type definition for call data structure
 *              Contains information about the current call
 *
 * @properties
 * - `call_id: string` - 🔗 Call reference identifier
 * - `phone_number: string` - 📱 Customer phone number
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface EndCallPayLoadData {
	/**
	 * 🔗 Call reference identifier
	 * @description Unique identifier for the call
	 * @type {string}
	 */
	call_id: string;

	/**
	 * 📱 Customer phone number
	 * @description Phone number of the customer
	 * @type {string}
	 */
	phone_number: string;
}

/**
 * 📋 Comprehensive Type Exports
 *
 * @description 📦 Re-exports all types for easy importing
 *              Provides a single import point for all hook-related types
 *
 * @example
 * ```typescript
 * import {
 *   EndCallPayload,
 *   UseEndCallReturn,
 *   CallTerminationFunction,
 *   EndCallData
 * } from './useEndCall';
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */

/**
 *
 * This file contains TypeScript type definitions for the useLogout custom hook
 * and its related interfaces. It provides comprehensive type safety and IntelliSense
 * support for developers using the CTI SDK logout functionality.
 *
 * 🎯 Key Type Definitions:
 * - 🚪 LogoutPayload interface for logout API data
 * - 🚪 useLogout hook return type
 * - 🔄 Logout function signature
 * - 📊 State management types
 * - 🗑️ Cleanup and storage management types
 *
 * @author CTI SDK Team
 * @version 6.x.x
 * @since 1.0.0
 */

/**
 * 🚪 Logout Payload Interface
 *
 * @interface LogoutPayload
 * @description 📊 Defines the structure for agent logout API payload data
 *              Contains all necessary information for secure agent logout
 *
 * @properties
 * - `action: string` - 🎯 API action type ("LOGOUTUSER")
 * - `userId: string` - 👤 Agent identifier for logout
 *
 * @example
 * ```typescript
 * // Basic logout payload
 * const logoutPayload: LogoutPayload = {
 *   action: "LOGOUTUSER",
 *   userId: "agent123"
 * };
 *
 * // Usage in component
 * const { logout } = useLogout();
 * await logout();
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface LogoutPayload {
	/**
	 * 🎯 API action type
	 * @description The action type for the logout API call
	 * @type {string}
	 */
	action: string;

	/**
	 * 👤 Agent identifier
	 * @description Unique identifier for the agent being logged out
	 * @type {string}
	 */
	userId: string;
}

/**
 * 🚪 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();
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
type LogoutFunction = () => Promise<any>;

/**
 * 📊 Hook State Management Types
 *
 * @type LogoutHookStateTypes
 * @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 LogoutHookStateTypes = {
	/**
	 * ⏳ 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 LogoutHookStateTypes {
	/**
	 * 🚪 Logout function
	 * @description Handles secure agent logout with comprehensive cleanup procedures
	 * @type {LogoutFunction}
	 */
	logout: LogoutFunction;
}

/**
 * 🚪 Logout Custom Hook
 *
 * @function useLogout
 * @description 🎯 Custom 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
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
declare const useLogout: () => UseLogoutReturn;

/**
 * 🔐 Authorization Token Custom Hook
 *
 * @function useGetAuthorizationToken
 * @description 🎯 Custom hook that provides reactive access to the current SDK authorization token.
 *              Automatically updates when the token changes, making it perfect for external API calls
 *              and authentication headers.
 *
 * @returns {string | undefined} Current authorization token or undefined if not available
 *
 * @example
 * ```typescript
 * // Basic usage in a component
 * const ApiCallComponent = () => {
 *   const token = useGetAuthorizationToken();
 *
 *   const makeExternalApiCall = async () => {
 *     if (!token) {
 *       console.error('No authorization token available');
 *       return;
 *     }
 *
 *     try {
 *       const response = await fetch('/api/external', {
 *         headers: {
 *           'Authorization': `Bearer ${token}`,
 *           'Content-Type': 'application/json'
 *         }
 *       });
 *       const data = await response.json();
 *       console.log('External API response:', data);
 *     } catch (error) {
 *       console.error('API call failed:', error);
 *     }
 *   };
 *
 *   return (
 *     <button onClick={makeExternalApiCall} disabled={!token}>
 *       {token ? 'Make API Call' : 'No Token Available'}
 *     </button>
 *   );
 * };
 * ```
 *
 * @example
 * ```typescript
 * // Usage with axios
 * const ApiService = () => {
 *   const token = useGetAuthorizationToken();
 *
 *   useEffect(() => {
 *     if (token) {
 *       // Configure axios with the token
 *       axios.defaults.headers.common['Authorization'] = `Bearer ${token}`;
 *     }
 *   }, [token]);
 *
 *   return null; // This is just for token management
 * };
 * ```
 *
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
declare const useGetAuthorizationToken: () => string | undefined;

/**
 * 📞 Caller Data Custom Hook
 *
 * @function useGetCallerData
 * @description 🎯 Custom hook that provides reactive access to current call data.
 *              This is an independent alternative to the CallControlPanel's onDataChange prop,
 *              allowing you to access call information anywhere in your application without
 *              depending on the CallControlPanel component.
 *
 * @returns {CallData} Current call data object containing all available call information
 *
 * @example
 * ```typescript
 * // Basic usage in a component
 * const CallStatusWidget = () => {
 *   const callerData = useGetCallerData();
 *
 *   return (
 *     <div className="call-status-widget">
 *       <h3>Current Call Status</h3>
 *       {callerData.status === "ONCALL" ? (
 *         <div>
 *           <p>📞 Active Call: {callerData.phone_number}</p>
 *           <p>Agent: {callerData.agent_id}</p>
 *           <p>Process: {callerData.process_name}</p>
 *           <p>Call ID: {callerData.callReferenceId}</p>
 *         </div>
 *       ) : (
 *         <p>No active call</p>
 *       )}
 *     </div>
 *   );
 * };
 * ```
 *
 * @example
 * ```typescript
 * // Usage for call analytics
 * const CallAnalytics = () => {
 *   const callerData = useGetCallerData();
 *
 *   useEffect(() => {
 *     if (callerData.status === "ONCALL") {
 *       // Track call start
 *       analytics.track('call_started', {
 *         phone_number: callerData.phone_number,
 *         agent_id: callerData.agent_id,
 *         process_name: callerData.process_name
 *       });
 *     }
 *   }, [callerData.status]);
 *
 *   return null; // This is just for analytics
 * };
 * ```
 *
 *
 *
 * @returns_data_structure
 * ```typescript
 * {
 *   phone_number: string,        // Phone number involved in the call
 *   status: string,             // Current call status (ONCALL, RINGING, WRAPUP, etc.)
 *   callReferenceId: string,     // Unique identifier for the call
 *   agent_id: string,           // ID of the agent handling the call
 *   process_id: string,         // Process identifier for the call
 *   process_name: string        // Name of the process handling the call
 * }
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
declare const useGetCallerData: () => CallData;

/**
 * 🗃️ SDK State Interface
 *
 * @interface SDKState
 * @description 📊 Type definition for the SDK state structure
 *              Used internally by the hook to access agent and call data
 *
 * @properties
 * - `agentId: string` - 👤 Agent identifier
 * - `process: ProcessData` - ⚙️ Process information
 * - `callData: EndCallData` - 📞 Current call data
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface SDKState {
	/**
	 * 👤 Agent identifier
	 * @description Unique identifier for the current agent
	 * @type {string}
	 */
	agentId: string;

	/**
	 * ⚙️ Process information
	 * @description Information about the current process
	 * @type {ProcessData}
	 */
	process: ProcessData;

	/**
	 * 📞 Current call data
	 * @description Data about the current call
	 * @type {EndCallData}
	 */
	callData: EndCallData;
}

/**
 * 🗃️ SDK State Interface
 *
 * @interface SDKState
 * @description 📊 Type definition for the SDK state structure
 *              Used internally by the hook to access agent data
 *
 * @properties
 * - `agentId: string` - 👤 Agent identifier
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface SDKState {
	/**
	 * 👤 Agent identifier
	 * @description Unique identifier for the current agent
	 * @type {string}
	 */
	agentId: string;
}

/**
 * 🗑️ Storage Management Types
 *
 * @type StorageType
 * @description 🎯 Type definitions for storage management
 *              Used for localStorage and sessionStorage operations
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
type StorageType = "localStorage" | "sessionStorage";

/**
 * 🔄 Cleanup Operation Types
 *
 * @type CleanupOperation
 * @description 🎯 Type definitions for cleanup operations
 *              Used for state and storage cleanup procedures
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
type CleanupOperation = "clearStorage" | "resetState" | "clearAll";

/**
 * 📋 Comprehensive Type Exports
 *
 * @description 📦 Re-exports all types for easy importing
 *              Provides a single import point for all hook-related types
 *
 * @example
 * ```typescript
 * import {
 *   LogoutPayload,
 *   UseLogoutReturn,
 *   LogoutFunction,
 *   SDKState
 * } from './useLogout';
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */

/**
 * @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.x.x
 * @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;
	/** Optional user id; defaults to the logged-in agent id when omitted. */
	user?: string;
	/** Optional auto-answer flag; defaults to false when omitted. */
	auto_answer?: boolean;
	/** Optional Convox call id passthrough. */
	call_id?: string;
	/** Optional caller-provided reference id. */
	reference_id?: string;
	/** Optional source identifier (e.g. campaign, dialpad). */
	call_source?: string;
	/** Optional case id passthrough. */
	caseId?: string;
	/** Whether the call is being made during wrap-up. */
	isWrapup?: boolean;
	/** Convox call UUID of the parent call; used for wrap-up chaining. */
	parentCallUuid?: string;
}

interface ConferenceCallPayload {
	mobileNumber: string;
	lineNumber?: number;
}

/**
 * 📞 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({
 * mobileNumber: "1234567890"
 * })
 * ```
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
type CallInitiationFunction = (data: StartCallPayload) => Promise<any>;

/**
 * 📊 Hook State Management Types
 *
 * @type StartCalltHookStateTypes
 * @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 StartCalltHookStateTypes = {
	/**
	 * ⏳ 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 StartCalltHookStateTypes {
	/**
	 * 📞 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 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
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
declare const useClickToCall: () => UseClickToCallReturn;

/**
 * 📊 Agent State Types
 *
 * @type AgentStatus
 * @description 🎯 Type definitions for agent status values
 *              Used internally by the hook to determine call routing logic
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
type AgentStatus = string;

/**
 * 📞 Conference Line Interface
 *
 * @interface ConferenceLine
 * @description 📊 Type definition for conference line data structure
 *              Used internally by the hook for conference call management
 *
 * @properties
 * - `line: number` - 📞 Line number identifier
 * - `status: AgentStatus` - 📊 Current line status
 * - `isCallStart: boolean` - ✅ Whether call is active on this line
 * - `phone?: string` - 📱 Phone number for this line (optional)
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface ConferenceLine {
	/**
	 * 📞 Line number identifier
	 * @description Unique identifier for the conference line
	 * @type {number}
	 */
	line: number;

	/**
	 * 📊 Current line status
	 * @description Status of the conference line
	 * @type {AgentStatus}
	 */
	status: AgentStatus;

	/**
	 * ✅ Whether call is active on this line
	 * @description Flag indicating if a call is currently active
	 * @type {boolean}
	 */
	isCallStart: boolean;

	/**
	 * 📱 Phone number for this line
	 * @description Phone number associated with this line (optional)
	 * @type {string | undefined}
	 */
	phone?: string;
}

/**
 * 📞 Call Data Interface
 *
 * @interface StartCalltData
 * @description 📊 Type definition for call data structure
 *              Contains information about the current call
 *
 * @properties
 * - `status: AgentStatus` - 📊 Current call status
 * - `agent_id: string` - 👤 Agent identifier
 * - `process_name: string` - ⚙️ Process name
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface StartCalltData {
	/**
	 * 📊 Current call status
	 * @description Status of the current call
	 * @type {AgentStatus}
	 */
	status: AgentStatus;

	/**
	 * 👤 Agent identifier
	 * @description Unique identifier for the agent
	 * @type {string}
	 */
	agent_id: string;

	/**
	 * ⚙️ Process name
	 * @description Name of the current process
	 * @type {string}
	 */
	process_name: string;
}

/**
 * 📡 API Response Interface
 *
 * @interface APIResponse
 * @description 📊 Type definition for API response structure
 *              Used for type safety in API call responses
 *
 * @properties
 * - `data: any` - 📊 Response data
 * - `status: number` - 📊 HTTP status code
 * - `message?: string` - 📝 Optional response message
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface APIResponse {
	/**
	 * 📊 Response data
	 * @description The main response data from the API
	 * @type {any}
	 */
	data: any;

	/**
	 * 📊 HTTP status code
	 * @description HTTP status code of the response
	 * @type {number}
	 */
	status: number;

	/**
	 * 📝 Optional response message
	 * @description Optional message from the API response
	 * @type {string | undefined}
	 */
	message?: string;
}

/**
 * 📡 API Response Interface
 *
 * @interface APIResponse
 * @description 📊 Type definition for API response structure
 *              Used for type safety in API call responses
 *
 * @properties
 * - `data: any` - 📊 Response data
 * - `status: number` - 📊 HTTP status code
 * - `message?: string` - 📝 Optional response message
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface APIResponse {
	/**
	 * 📊 Response data
	 * @description The main response data from the API
	 * @type {any}
	 */
	data: any;

	/**
	 * 📊 HTTP status code
	 * @description HTTP status code of the response
	 * @type {number}
	 */
	status: number;

	/**
	 * 📝 Optional response message
	 * @description Optional message from the API response
	 * @type {string | undefined}
	 */
	message?: string;
}

/**
 * 📡 API Response Interface
 *
 * @interface APIResponse
 * @description 📊 Type definition for API response structure
 *              Used for type safety in API call responses
 *
 * @properties
 * - `data: any` - 📊 Response data
 * - `status: number` - 📊 HTTP status code
 * - `message?: string` - 📝 Optional response message
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface APIResponse {
	/**
	 * 📊 Response data
	 * @description The main response data from the API
	 * @type {any}
	 */
	data: any;

	/**
	 * 📊 HTTP status code
	 * @description HTTP status code of the response
	 * @type {number}
	 */
	status: number;

	/**
	 * 📝 Optional response message
	 * @description Optional message from the API response
	 * @type {string | undefined}
	 */
	message?: string;
}

/**
 * 🛡️ Error Response Interface
 *
 * @interface ErrorResponse
 * @description 📊 Type definition for error response structure
 *              Used for type safety in error handling
 *
 * @properties
 * - `message: string` - 📝 Error message
 * - `code?: string` - 🔢 Optional error code
 * - `details?: any` - 📊 Optional error details
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface ErrorResponse {
	/**
	 * 📝 Error message
	 * @description Human-readable error message
	 * @type {string}
	 */
	message: string;

	/**
	 * 🔢 Optional error code
	 * @description Optional error code for programmatic handling
	 * @type {string | undefined}
	 */
	code?: string;

	/**
	 * 📊 Optional error details
	 * @description Optional additional error details
	 * @type {any}
	 */
	details?: any;
}

/**
 * 🛡️ Error Response Interface
 *
 * @interface ErrorResponse
 * @description 📊 Type definition for error response structure
 *              Used for type safety in error handling
 *
 * @properties
 * - `message: string` - 📝 Error message
 * - `code?: string` - 🔢 Optional error code
 * - `details?: any` - 📊 Optional error details
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface ErrorResponse {
	/**
	 * 📝 Error message
	 * @description Human-readable error message
	 * @type {string}
	 */
	message: string;

	/**
	 * 🔢 Optional error code
	 * @description Optional error code for programmatic handling
	 * @type {string | undefined}
	 */
	code?: string;

	/**
	 * 📊 Optional error details
	 * @description Optional additional error details
	 * @type {any}
	 */
	details?: any;
}

/**
 * 🛡️ Error Response Interface
 *
 * @interface ErrorResponse
 * @description 📊 Type definition for error response structure
 *              Used for type safety in error handling
 *
 * @properties
 * - `message: string` - 📝 Error message
 * - `code?: string` - 🔢 Optional error code
 * - `details?: any` - 📊 Optional error details
 *
 * @since 1.0.0
 * @author CTI SDK Team
 */
interface ErrorResponse {
	/**
	 * 📝 Error message
	 * @description Human-readable error message
	 * @type {string}
	 */
	message: string;

	/**
	 * 🔢 Optional error code
	 * @description Optional error code for programmatic handling
	 * @type {string | undefined}
	 */
	code?: string;

	/**
	 * 📊 Optional error details
	 * @description Optional additional error details
	 * @type {any}
	 */
	details?: any;
}


// =============================================================================
// ⚡ FRAMEWORK-AGNOSTIC ACTION EXPORTS (for Angular / non-React consumers)
// =============================================================================

type SupervisorMonitorMode = "listen" | "whisper" | "barge";

interface StartMonitoringPayload {
  call_id: string;
  mode: SupervisorMonitorMode;
  supervisor_extension?: string;
  agent_extension?: string;
}

interface StopMonitoringPayload {
  call_uuid: string;
  session_id?: string;
}

interface ChangeModePayload {
  call_uuid: string;
  mode: SupervisorMonitorMode;
  session_id?: string;
}

declare function clickToCall(payload: StartCallPayload): Promise<any>;
declare function clickToConference(payload: ConferenceCallPayload): Promise<any>;
declare function endCall(options?: EndCallPayload): Promise<any>;
declare function logout(): Promise<void>;
declare function startMonitoring(payload: StartMonitoringPayload): Promise<any>;
declare function stopMonitoring(payload: StopMonitoringPayload): Promise<any>;
declare function changeMonitorMode(payload: ChangeModePayload): Promise<any>;
declare function setTransferLeadData(data: any): void;

// =============================================================================
// ⚛️ REACT HOOKS
// =============================================================================

interface UseClickToConferenceReturn {
  handleStartConferenceCall: (payload: ConferenceCallPayload) => Promise<any>;
  isLoading: boolean;
  isSuccess: boolean;
  isError: boolean;
  error: any;
  data: any;
}

declare function useClickToConference(): UseClickToConferenceReturn;

// =============================================================================
// 📊 CALL MONITORING HOOK
// =============================================================================

interface UseCallMonitoringReturn {
	startMonitoring: (payload: StartMonitoringPayload) => Promise<any>;
	stopMonitoring: (payload: StopMonitoringPayload) => Promise<any>;
	changeMode: (payload: ChangeModePayload) => Promise<any>;
	isLoading: boolean;
	isSuccess: boolean;
	isError: boolean;
	error: any;
	data: any;
}

declare const useCallMonitoring: () => UseCallMonitoringReturn;

// =============================================================================
// 🗃️ SDK STATE HOOK
// =============================================================================

declare const useSDKState: () => any;

// =============================================================================
// 🛡️ ENTITLEMENTS / PERMISSIONS
// =============================================================================

/** "*" wildcard literal used in permission and menu codes. */
declare const SDK_WILDCARD: "*";

/** Menu entitlement codes (used by SDKPages and SDKPermissionGuard). */
declare const SDK_MENU_CODES: {
	readonly WILDCARD: "*";
	readonly CALL_HISTORY: "call_history";
	readonly CAMPAIGNS: "dialer_auto";
	readonly LOGIN_REPORT: "login_report";
	readonly CDR_REPORT: "cdr_report";
	readonly AGENT_PERFORMANCE_REPORT: "agent_performance";
	readonly AGENT_DETAIL_REPORT: "agent_detail";
	readonly LIVE_STATUS: "live_status";
	readonly MANAGEMENT_DASHBOARD: "management_dashboard";
	readonly CARO_VOICE_AI: "caro_voice_ai";
	readonly QUALITY_AUDIT_DASHBOARD: "quality_audit_dashboard";
	readonly CARO_VOICE_AI_DASHBOARD: "caro_voice_ai_dashboard";
	readonly LEAD_INTEGRATIONS: "lead_integrations";
};

/** SDK permission codes — feature-level entitlements. */
declare const SDK_PERMISSIONS: {
	readonly WILDCARD: "*";
	readonly CALLS: "calls";
	readonly CALL_TRANSFER: "call_transfer";
	readonly CALL_CONFERENCE: "call_conference";
	readonly CALL_INBOUND: "call_inbound";
	readonly CALL_OUTBOUND: "call_outbound";
	readonly CONFERENCE: "call_conference";
	readonly TRANSFER_BLIND: "call_transfer_blind";
	readonly TRANSFER_ATTENDED: "call_transfer_attended";
	readonly TRANSFER_WARM: "call_transfer_warm";
	readonly CAMPAIGNS_CREATE: "campaigns:create";
	readonly CAMPAIGNS_READ: "campaigns:read";
	readonly CAMPAIGNS_UPDATE: "campaigns:update";
	readonly CAMPAIGNS_DELETE: "campaigns:delete";
	readonly CAMPAIGNS_MANAGE: "campaigns:manage";
	readonly CAMPAIGNS_CONTROL: "campaigns:control";
	readonly CAMPAIGNS_LEADS_CREATE: "leads:create";
	readonly CAMPAIGNS_LEADS_READ: "leads:read";
	readonly CAMPAIGNS_LEADS_DELETE: "leads:delete";
	readonly CAMPAIGNS_LEADS_IMPORT: "leads:import";
	readonly LEAD_INTEGRATIONS_CREATE: "lead_integrations:create";
	readonly LEAD_INTEGRATIONS_READ: "lead_integrations:read";
	readonly LEAD_INTEGRATIONS_UPDATE: "lead_integrations:update";
	readonly LEAD_INTEGRATIONS_DELETE: "lead_integrations:delete";
	readonly LEAD_INTEGRATIONS_MANAGE: "lead_integrations:manage";
	readonly REPORTS_AGENT_LOGIN_READ: "reports:agent_login:read";
	readonly REPORTS_AGENT_LOGIN_EXPORT: "reports:agent_login:export";
	readonly REPORTS_AGENT_LOGIN_MANAGE: "reports:agent_login:manage";
	readonly REPORTS_CDR_READ: "reports:cdr:read";
	readonly REPORTS_CDR_EXPORT: "reports:cdr:export";
	readonly REPORTS_CDR_MANAGE: "reports:cdr:manage";
	readonly REPORTS_AGENT_PERFORMANCE_READ: "reports:agent_performance:read";
	readonly REPORTS_AGENT_PERFORMANCE_EXPORT: "reports:agent_performance:export";
	readonly REPORTS_AGENT_PERFORMANCE_MANAGE: "reports:agent_performance:manage";
	readonly SUPERVISOR_MONITOR_LISTEN: "supervisor:monitor:listen";
	readonly SUPERVISOR_MONITOR_WHISPER: "supervisor:monitor:whisper";
	readonly SUPERVISOR_MONITOR_BARGE: "supervisor:monitor:barge";
	readonly QUALITY_AUDIT_DASHBOARD_READ: "quality_audit_dashboard:read";
	readonly CARO_VOICE_AI_DASHBOARD_READ: "caro_voice_ai_dashboard:read";
	readonly REPORTS_CALL_HISTORY_READ: "reports:call_history:read";
	readonly DASHBOARD_LIVE_STATUS_READ: "dashboard:live_status:read";
	readonly DASHBOARD_LIVE_STATUS_MANAGE: "dashboard:live_status:manage";
	readonly MANAGEMENT_DASHBOARD_READ: "management_dashboard:read";
	readonly CARO_VOICE_AI_READ: "caro_voice_ai:read";
	/** Role landing access codes — each grants its landing page on its own. */
	readonly AGENT_ACCESS: "agent_access:access";
	readonly SUPERVISOR_ACCESS: "supervisor_access:access";
};

// ─── Entitlement types ────────────────────────────────────────────────────────

interface SDKBit {
	code: string;
	enabled: boolean;
}

interface SDKEntitlement {
	enabled: boolean;
	items: SDKBit[];
}

interface SDKEntitlements {
	calls?: SDKEntitlement;
	call_controls?: SDKEntitlement;
	call_transfer?: SDKEntitlement;
	call_conference?: SDKEntitlement;
	[key: string]: any;
}

interface SDKPermissionState {
	sdk: SDKEntitlements | null;
	isLoaded: boolean;
	error: Error | null;
}

interface ControlsFromPermissions {
	disabledDialButton: boolean;
	disableEndCallButton: boolean;
	disableCallTransferButton: boolean;
	disableBlindTransfer: boolean;
	disableAttendedTransfer: boolean;
	disableWarmTransfer: boolean;
	disableConferenceButton: boolean;
	disableHoldButton: boolean;
	disableMuteButton: boolean;
	disabledMoreOptionsButton: boolean;
}

interface SDKPermissionContextValue {
	state: SDKPermissionState;
	isBitEnabled: (category: keyof SDKEntitlements, bitCode: string) => boolean;
	getControlsConfig: () => ControlsFromPermissions;
}

// ─── useSDKPermissions hook ───────────────────────────────────────────────────

interface SDKPermissionsHook {
	permissions: string[];
	menuEntitlements: Array<{ code: string; name: string; enabled: boolean }>;
	isLoaded: boolean;
	hasPermission: (permission: string) => boolean;
	hasAnyPermission: (permissions: string[]) => boolean;
	hasAllPermissions: (permissions: string[]) => boolean;
	hasMenuFeature: (code: string) => boolean;
}

declare function useSDKPermissions(): SDKPermissionsHook;

// ─── Permission guard & access denied components ──────────────────────────────

interface SDKPermissionGuardProps {
	children?: React.ReactNode;
	/** Single permission code (e.g. "calls:inbound") */
	permission?: string;
	/** Multiple permission codes — ANY match grants access by default */
	permissions?: string[];
	/** When true, ALL permissions must be granted */
	requireAll?: boolean;
	/** One or more menu feature codes — ANY match grants access by default */
	menuFeature?: string | string[];
	/** When true, ALL menu features must be enabled */
	requireAllMenus?: boolean;
	/**
	 * Permission codes that grant access on their own, short-circuiting both the
	 * menu-entitlement and permission gates (which are otherwise ANDed). Used for
	 * the role access codes ("agent_access:access", "supervisor_access:access") on
	 * the page that login lands on right after signing in.
	 */
	accessOverride?: string | string[];
	/** Custom fallback rendered when access is denied */
	fallback?: React.ReactNode;
	/** Show the default Access Denied UI when denied. Defaults to true. */
	showFallback?: boolean;
	/** Callback fired when the guard denies access */
	onDenied?: () => void;
}

declare const SDKPermissionGuard: React.FC<SDKPermissionGuardProps>;

interface SDKAccessDeniedProps {
	message?: string;
}

declare const SDKAccessDenied: React.FC<SDKAccessDeniedProps>;

export type { APIResponse, AgentDetailReportProps, AgentStatus, AuditReportDialogProps, AuditReportUrlResolver, CallControlIframeProps, CallControlPanelProps, CallData, CallInitiationFunction, CallTerminationFunction, ChangeModePayload, CleanupOperation, ConferenceCallPayload, ConferenceLine, ControlsFromPermissions, DispositionType, EndCallData, EndCallPayLoadData, EndCallPayload, ErrorResponse, FollowUpType, HookStateTypes, InitSDKParams, LiveStatusPageProps, LogoutFunction, LogoutHookStateTypes, LogoutPayload, ProcessData, SDKAccessDeniedProps, SDKBit, SDKConfig, SDKEntitlement, SDKEntitlements, SDKInitResult, SDKPermissionContextValue, SDKPermissionGuardProps, SDKPermissionState, SDKPermissionsHook, SDKState, StartCallPayload, StartCalltData, StartCalltHookStateTypes, StartMonitoringPayload, StopMonitoringPayload, StorageType, SupervisorMonitorMode, URLConfig, UseCallMonitoringReturn, UseClickToCallReturn, UseClickToConferenceReturn, UseEndCallReturn, UseLogoutReturn }
export { AgentDetailReport, AuditReportDialog, CallControlIframe, CallControlPanel, SDKAccessDenied, SDKPages, SDKPermissionGuard, SDKStateManager, SDK_MENU_CODES, SDK_PERMISSIONS, SDK_WILDCARD, changeMonitorMode, clickToCall, clickToConference, endCall, getSDKVersion, initSDK, isSDKInitialized, logout, sdkStateManager, setAuditReportUrlResolver, setTransferLeadData, startMonitoring, stopMonitoring, useCallMonitoring, useClickToCall, useClickToConference, useEndCall, useGetAuthorizationToken, useGetCallerData, useLogout, useSDKPermissions, useSDKState };