@campxdev/campx-web-utils 2.0.13 → 2.0.14

package/dist/esm/types/src/components/Exotel/CallButton.d.ts

@@ -0,0 +1,10 @@
+interface CallButtonProps {
+    phoneNumber?: string;
+    encryptedPhoneNumber?: string;
+    callerName?: string;
+    prospectId?: string;
+    className?: string;
+    disabled?: boolean;
+}
+declare const CallButton: ({ phoneNumber, encryptedPhoneNumber, callerName, prospectId, className, disabled, }: CallButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default CallButton;

package/dist/esm/types/src/components/Exotel/CallDispositionForm.d.ts

@@ -0,0 +1,29 @@
+import type { CallDispositionData } from '../../providers/ExotelProvider';
+type CallStatusType = 'connected' | 'not_connected';
+export interface DispositionFormData {
+    prospectId?: string;
+    callId: string;
+    channel: string;
+    direction: string;
+    duration: number;
+    callStatusDisposition: CallStatusType;
+    dispositionReason?: string;
+    dispositionCategory: string;
+    remarks: string;
+    callerName: string;
+    callerNumber: string;
+}
+export interface ExistingDispositionData {
+    callStatusDisposition?: CallStatusType;
+    dispositionCategory?: string;
+    dispositionNotes?: string;
+}
+interface CallDispositionFormProps {
+    dispositionData: CallDispositionData;
+    prospectId?: string;
+    onClose: () => void;
+    onSave: (data: DispositionFormData) => Promise<any>;
+    existingData?: ExistingDispositionData;
+}
+declare const CallDispositionForm: ({ dispositionData, prospectId, onClose, onSave, existingData, }: CallDispositionFormProps) => import("react/jsx-runtime").JSX.Element;
+export default CallDispositionForm;

package/dist/esm/types/src/components/Exotel/ExotelPhone.d.ts

@@ -0,0 +1,10 @@
+import { type DispositionFormData } from './CallDispositionForm';
+interface ExotelPhoneProps {
+    className?: string;
+    prospectId?: string;
+    prospectName?: string;
+    prospectNumber?: string;
+    onSaveDisposition?: (data: DispositionFormData) => Promise<any>;
+}
+declare const ExotelPhone: ({ className, prospectId, prospectName, prospectNumber, onSaveDisposition }: ExotelPhoneProps) => import("react/jsx-runtime").JSX.Element;
+export default ExotelPhone;

package/dist/esm/types/src/components/Exotel/ExotelWrapper.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+interface ExotelWrapperProps {
+    children: ReactNode;
+    enabled?: boolean;
+    prospectId?: string;
+    prospectName?: string;
+    prospectNumber?: string;
+}
+/**
+ * Wrapper component that initializes Exotel VoIP functionality
+ * Fetches the access token from backend and provides the Exotel context to children
+ */
+declare const ExotelWrapper: ({ children, enabled, prospectId, prospectName, prospectNumber, }: ExotelWrapperProps) => import("react/jsx-runtime").JSX.Element;
+export default ExotelWrapper;

package/dist/esm/types/src/components/Exotel/MicrophonePermission.d.ts

@@ -0,0 +1,6 @@
+interface MicrophonePermissionProps {
+    onPermissionGranted?: () => void;
+    onPermissionDenied?: () => void;
+}
+declare const MicrophonePermission: ({ onPermissionGranted, onPermissionDenied, }: MicrophonePermissionProps) => import("react/jsx-runtime").JSX.Element;
+export default MicrophonePermission;

package/dist/esm/types/src/components/Exotel/index.d.ts

@@ -0,0 +1,6 @@
+export { default as ExotelPhone } from './ExotelPhone';
+export { default as CallButton } from './CallButton';
+export { default as CallDispositionForm } from './CallDispositionForm';
+export { default as MicrophonePermission } from './MicrophonePermission';
+export { default as ExotelWrapper } from './ExotelWrapper';
+export type { DispositionFormData, ExistingDispositionData, } from './CallDispositionForm';

package/dist/esm/types/src/config/index.d.ts

@@ -1,3 +1,4 @@
 export * from './axios';
 export * from './createRsbuildSharedConfig';
 export * from './nonWorkspaceAxios';
+export * from './voip.config';

package/dist/esm/types/src/config/voip.config.d.ts

@@ -0,0 +1,18 @@
+/**
+ * VoIP Configuration Module
+ *
+ * This module manages VoIP/Exotel configuration for workspaces.
+ * Only workspaces listed in VOIP_ENABLED_WORKSPACES will have VoIP functionality.
+ */
+/**
+ * List of workspaces that have VoIP/Exotel calling enabled.
+ * Add workspace names here to enable VoIP for that workspace.
+ */
+export declare const VOIP_ENABLED_WORKSPACES: string[];
+/**
+ * Check if VoIP is enabled for a given workspace
+ *
+ * @param workspaceName - The name of the workspace to check
+ * @returns boolean indicating if VoIP is enabled for the workspace
+ */
+export declare function isVoIPEnabledForWorkspace(workspaceName: string): boolean;

package/dist/esm/types/src/constants/exotel.constants.d.ts

@@ -0,0 +1,7 @@
+export declare const EXOTEL_CONSTANTS: {
+    MODAL_Z_INDEX: number;
+    MODAL_BACKDROP_Z_INDEX: number;
+    MODAL_BORDER_RADIUS: string;
+    DECLINE_TIMEOUT_MS: number;
+    TIMER_INTERVAL_MS: number;
+};

package/dist/esm/types/src/providers/ExotelProvider.d.ts

@@ -0,0 +1,79 @@
+import React, { ReactNode } from 'react';
+import { PermissionStatus } from '../services/exotel/ExotelService';
+export interface CallEventData {
+    callId: string;
+    remoteId: string;
+    remoteDisplayName: string;
+    callDirection: string;
+    callState: string;
+    callDuration: string;
+    callStartedTime: string;
+    callEstablishedTime: string;
+    callEndedTime: string;
+    callAnswerTime: string;
+    callEndReason: string;
+    sessionId: string;
+    callFromNumber?: string;
+    status?: string;
+}
+export type CallPhase = 'idle' | 'ready_to_call' | 'calling' | 'incoming' | 'connected' | 'ended';
+export interface CallState {
+    phase: CallPhase;
+    callData: CallEventData | null;
+    isOnHold: boolean;
+    isMuted: boolean;
+    isSpeakerOff: boolean;
+    callDirection: 'outbound' | 'inbound' | null;
+    callStartTime: number | null;
+    callDuration: number;
+    callerName: string | null;
+    callerNumber: string | null;
+    callActivityId: string | null;
+    exotelCallSid: string | null;
+    prospectUniqueId: number | null;
+    wasAccepted: boolean;
+}
+export interface CallDispositionData {
+    callId: string;
+    exotelCallId: string;
+    callDirection: 'outbound' | 'inbound';
+    callDuration: number;
+    callerName: string | null;
+    callerNumber: string | null;
+}
+export interface ExotelContextType {
+    isInitialized: boolean;
+    isConnected: boolean;
+    callState: CallState;
+    permissionStatus: PermissionStatus;
+    dispositionData: CallDispositionData | null;
+    makeCall: (phoneNumber: string, callerName?: string, callActivityId?: string, maskedNumber?: string) => Promise<any>;
+    acceptCall: () => Promise<void>;
+    hangupCall: () => void;
+    rejectCall: () => void;
+    toggleHold: () => void;
+    toggleMute: () => void;
+    toggleSpeaker: () => void;
+    sendDTMF: (digit: string) => void;
+    registerDevice: () => Promise<void>;
+    unregisterDevice: () => void;
+    requestMicrophoneAccess: () => Promise<boolean>;
+    clearDisposition: () => void;
+    setCallActivityId: (callActivityId: string) => void;
+    setExotelCallSid: (callSid: string) => void;
+}
+export interface ExotelProviderProps {
+    children: ReactNode;
+    accessToken: string;
+    agentUserId: string;
+    autoConnectVOIP?: boolean;
+    callerName?: string;
+    callerNumber?: string;
+}
+export declare const ExotelProvider: React.FC<ExotelProviderProps>;
+export declare const useExotel: () => ExotelContextType;
+/**
+ * Safe version of useExotel that returns null when outside the provider
+ * Use this in components that may render outside of ExotelProvider
+ */
+export declare const useExotelSafe: () => ExotelContextType | null;

package/dist/esm/types/src/providers/VoIPProvider.d.ts

@@ -0,0 +1,33 @@
+import React, { ReactNode } from 'react';
+import { DispositionFormData } from '../components/Exotel';
+export type { DispositionFormData } from '../components/Exotel';
+interface VoIPProviderProps {
+    children: ReactNode;
+    workspace: string;
+    agentUserId?: string;
+    prospectId?: string;
+    prospectName?: string;
+    prospectNumber?: string;
+    onSaveDisposition?: (data: DispositionFormData) => Promise<any>;
+}
+/**
+ * VoIPProvider - Workspace-level VoIP/Exotel integration
+ *
+ * This provider checks if VoIP is enabled for the current workspace AND tenant
+ * and initializes the Exotel SDK if enabled.
+ *
+ * VoIP is enabled only when ALL conditions are met:
+ * 1. Workspace is in VOIP_ENABLED_WORKSPACES (common-workspace, tele-caller-workspace)
+ * 2. Tenant has enableVoice: true in notification config
+ * 3. Tenant has at least one enabled voice config (voiceConfigs[].isEnabled: true)
+ * 4. Active token is available
+ *
+ * Features:
+ * - Workspace-level VoIP enablement
+ * - Tenant-level VoIP configuration check
+ * - Automatic token fetching from backend
+ * - Microphone permission handling
+ * - Floating phone UI for active calls
+ */
+export declare const VoIPProvider: React.FC<VoIPProviderProps>;
+export default VoIPProvider;

package/dist/esm/types/src/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ExotelProvider';
+export * from './VoIPProvider';

package/dist/esm/types/src/services/crypto/CryptoService.d.ts

@@ -0,0 +1,23 @@
+declare class CryptoService {
+    private static instance;
+    private readonly algorithm;
+    private secretKey;
+    private initialized;
+    private constructor();
+    private ensureInitialized;
+    static getInstance(): CryptoService;
+    /**
+     * Decrypt data using AES-256-CBC (same as backend)
+     * Format: "iv_hex:encrypted_hex"
+     */
+    decryptData(encryptedData: string): string;
+    /**
+     * Mask mobile number for display (first 2 and last 2 of actual number visible)
+     * Handles country code prefix (+91)
+     * e.g., "+919876543210" -> "+9198******10"
+     * e.g., "9876543210" -> "98******10"
+     */
+    maskMobile(mobile: string): string;
+}
+declare const _default: CryptoService;
+export default _default;

package/dist/esm/types/src/services/exotel/ExotelService.d.ts

@@ -0,0 +1,47 @@
+import { CallEventData } from '@exotel-npm-dev/exotel-ip-calling-crm-websdk';
+export type PermissionStatus = 'granted' | 'denied' | 'prompt' | 'unknown';
+declare class ExotelService {
+    private static instance;
+    private exotelSDK;
+    private webPhone;
+    private callListeners;
+    private registerListeners;
+    private sessionListeners;
+    private permissionStatus;
+    static getInstance(): ExotelService;
+    /**
+     * Initialize the Exotel SDK
+     * @param accessToken - The access token for authentication
+     * @param agentUserId - The user ID of the agent
+     * @param autoConnectVOIP - Whether to automatically connect VOIP (default: true)
+     * @returns boolean indicating success
+     */
+    initialize(accessToken: string, agentUserId: string, autoConnectVOIP?: boolean): Promise<boolean>;
+    checkAudioPermissions(): Promise<boolean>;
+    requestMicrophoneAccess(): Promise<boolean>;
+    makeCall(phoneNumber: string): Promise<any>;
+    acceptCall(): Promise<void>;
+    hangupCall(): void;
+    /**
+     * Reject an incoming call before accepting it.
+     * Note: Exotel SDK only has HangupCall - no separate RejectCall method.
+     * HangupCall internally calls webrtcSIPPhone.rejectCall() -> phone.sipHangUp()
+     */
+    rejectCall(): void;
+    toggleHold(): void;
+    toggleMute(): void;
+    sendDTMF(digit: string): void;
+    registerDevice(): Promise<void>;
+    unregisterDevice(): void;
+    getPermissionStatus(): PermissionStatus;
+    private handleCallEvent;
+    private handleRegisterEvent;
+    private handleSessionEvent;
+    addCallListener(listener: (event: string, data: CallEventData) => void): void;
+    removeCallListener(listener: (event: string, data: CallEventData) => void): void;
+    addRegisterListener(listener: (state: string) => void): void;
+    removeRegisterListener(listener: (state: string) => void): void;
+    addSessionListener(listener: (state: string, data: any) => void): void;
+    removeSessionListener(listener: (state: string, data: any) => void): void;
+}
+export default ExotelService;

package/dist/esm/types/src/services/exotel/api.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Voice config from notification-configs API
+ */
+export interface VoiceConfig {
+    id: string;
+    isEnabled: boolean;
+    name: string;
+    channelType: string;
+    EXOTEL?: {
+        appId: string;
+        appSecret: string;
+        token?: string;
+        tokenExpiresAt?: string;
+    };
+}
+/**
+ * Notification config response structure
+ */
+export interface NotificationConfigResponse {
+    config: {
+        id: string;
+        tenantId: string;
+        institutionUniqueId: number;
+        enableVoice?: boolean;
+        voiceConfigs?: VoiceConfig[];
+    };
+    options: {
+        voiceChannels?: string[];
+    };
+}
+/**
+ * Check if VoIP is enabled for the current tenant by fetching notification config.
+ * Returns true only if:
+ * - enableVoice is true
+ * - voiceConfigs has at least one enabled config
+ */
+export declare const checkVoIPEnabled: () => Promise<{
+    enabled: boolean;
+    hasValidToken: boolean;
+}>;
+/**
+ * Get the active Exotel voice token from the backend.
+ * The backend manages credentials securely and auto-refreshes tokens.
+ */
+export declare const getActiveVoiceToken: () => Promise<{
+    token: string;
+    expiresAt: string;
+} | null>;
+/**
+ * @deprecated Use getActiveVoiceToken instead.
+ * This function is kept for backwards compatibility but will be removed.
+ */
+export declare const createExotelAppToken: () => Promise<{
+    Data: string;
+}>;
+export interface CallActivity {
+    id: string;
+    callSid: string;
+    prospectId: string;
+    direction: 'inbound' | 'outbound';
+    status: string;
+    durationSeconds?: number;
+    createdAt: string;
+    startTime?: string;
+    endTime?: string;
+    fromNumber?: string;
+    toNumber?: string;
+    userId?: number;
+    dispositionCategory?: string;
+    dispositionReason?: string;
+    dispositionNotes?: string;
+    callStatusDisposition?: 'connected' | 'not_connected';
+    recordingUrl?: string;
+}
+export interface InitiateCallInput {
+    prospectId: string;
+    toNumber: string;
+    fromNumber?: string;
+    userId?: number;
+    callSid?: string;
+}
+export interface SaveDispositionInput {
+    callId: string;
+    prospectId?: string;
+    callStatusDisposition?: 'connected' | 'not_connected';
+    dispositionCategory: string;
+    dispositionReason?: string;
+    dispositionNotes?: string;
+    callbackScheduledAt?: string;
+}
+export interface CancelCallInput {
+    callSid: string;
+    reason?: string;
+}
+export interface CallActivityResponse {
+    success: boolean;
+    message: string;
+    data: CallActivity;
+}
+export interface RegisterIncomingCallInput {
+    callSid: string;
+    fromNumber: string;
+    toNumber?: string;
+    prospectId?: string;
+    userId?: number;
+}
+export interface RegisterIncomingCallResponse {
+    success: boolean;
+    message: string;
+    data: CallActivity;
+    prospect?: {
+        id: string;
+        uniqueId?: number;
+        prospectId?: string;
+        name: string;
+        mobile: string;
+    };
+}
+/**
+ * Initiate an outbound call - creates call activity record
+ */
+export declare const initiateCallActivity: (input: InitiateCallInput) => Promise<{
+    success: boolean;
+    message: string;
+    data: CallActivity;
+}>;
+/**
+ * Register an incoming call - creates call activity record
+ */
+export declare const registerIncomingCall: (input: RegisterIncomingCallInput) => Promise<RegisterIncomingCallResponse>;
+/**
+ * Fetch call history for a prospect
+ */
+export declare const fetchCallHistory: (prospectId: string) => Promise<CallActivity[]>;
+/**
+ * Get call activity by ID
+ */
+export declare const getCallActivityById: (id: string) => Promise<CallActivity>;
+/**
+ * Get call activity by CallSid
+ */
+export declare const getCallActivityByCallSid: (callSid: string) => Promise<CallActivity>;
+/**
+ * Get call count for a prospect
+ */
+export declare const getCallCountByProspect: (prospectId: string) => Promise<number>;
+/**
+ * Save call disposition
+ */
+export declare const saveCallDisposition: (input: SaveDispositionInput) => Promise<CallActivity>;
+/**
+ * Cancel/decline a call before it was connected
+ * Updates the call activity status to CANCELED
+ */
+export declare const cancelCall: (input: CancelCallInput) => Promise<{
+    success: boolean;
+    message: string;
+}>;

package/dist/esm/types/src/services/exotel/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ExotelService';
+export * from './api';

package/dist/esm/types/src/utils/exotel/formatters.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Format duration in MM:SS format (e.g., "02:30")
+ */
+export declare const formatDurationTimer: (seconds: number) => string;
+/**
+ * Format duration in verbose format (e.g., "2m 30s")
+ */
+export declare const formatDurationVerbose: (seconds: number) => string;

package/dist/esm/types/src/utils/exotel/index.d.ts

@@ -0,0 +1 @@
+export * from './formatters';