@webex/calling 3.12.0-next.60 → 3.12.0-next.61

package/dist/module/CallRecording/WxcCallRecordingConnector.js

@@ -0,0 +1,264 @@
+import SDKConnector from '../SDKConnector';
+import { ALLOWED_SERVICES, HTTP_METHODS } from '../common/types';
+import log from '../Logger';
+import { serviceErrorCodeHandler, uploadLogs } from '../common/Utils';
+import { METHOD_START_MESSAGE, SUCCESS_MESSAGE, SUCCESS_STATUS_CODE } from '../common/constants';
+import { COMMON_EVENT_KEYS, MOBIUS_EVENT_KEYS, RECORDING_EVENT_SUBTYPE, } from '../Events/types';
+import { Eventing } from '../Events/impl';
+import { RecordingRequestType, } from './types';
+import { CALL_RECORDING_FILE, CONVERGED_RECORDINGS, DEFAULT_MAX, DEFAULT_NUMBER_OF_DAYS, DEFAULT_STATUS, FORMAT, FROM, LOCATION_ID, MAX, METADATA, METHODS, OWNER_TYPE, RECORDING_NOT_FOUND_MESSAGE, SERVICE_TYPE, STATUS, STORAGE_REGION, TO, TOPIC, WEBEX_USER_REQUEST_HEADER, } from './constants';
+export class WxcCallRecordingConnector extends Eventing {
+    sdkConnector;
+    webex;
+    recordingServiceUrl;
+    constructor(webex, logger) {
+        super();
+        this.sdkConnector = SDKConnector;
+        if (!this.sdkConnector.getWebex()) {
+            SDKConnector.setWebex(webex);
+        }
+        this.webex = this.sdkConnector.getWebex();
+        this.recordingServiceUrl =
+            this.webex.internal.services._serviceUrls?.hydraDeveloperApi ||
+                this.webex.internal.services.get(this.webex.internal.services._activeServices?.hydraDeveloperApi);
+        this.registerRecordingListeners();
+        log.setLogger(logger.level, CALL_RECORDING_FILE);
+    }
+    buildRecordingsUrl(options) {
+        const params = new URLSearchParams();
+        let fromDate = options?.from;
+        if (!fromDate) {
+            const date = new Date();
+            date.setDate(date.getDate() - (options?.days ?? DEFAULT_NUMBER_OF_DAYS));
+            fromDate = date.toISOString();
+        }
+        const toDate = options?.to ?? new Date().toISOString();
+        params.append(FROM, fromDate);
+        params.append(TO, toDate);
+        params.append(STATUS, options?.status ?? DEFAULT_STATUS);
+        params.append(MAX, `${options?.max ?? DEFAULT_MAX}`);
+        const optionalParams = [
+            [SERVICE_TYPE, options?.serviceType],
+            [FORMAT, options?.format],
+            [OWNER_TYPE, options?.ownerType],
+            [STORAGE_REGION, options?.storageRegion],
+            [LOCATION_ID, options?.locationId],
+            [TOPIC, options?.topic],
+        ];
+        optionalParams.forEach(([key, value]) => {
+            if (value) {
+                params.append(key, value);
+            }
+        });
+        return `${this.recordingServiceUrl}/${CONVERGED_RECORDINGS}?${params.toString()}`;
+    }
+    getCallRecording(request) {
+        return this.dispatchGetCallRecording(request);
+    }
+    dispatchGetCallRecording(request) {
+        switch (request.type) {
+            case RecordingRequestType.LIST:
+                return this.getRecordings(request.options);
+            case RecordingRequestType.DETAIL:
+                return this.getRecording(request.recordingId);
+            case RecordingRequestType.METADATA:
+                return this.getRecordingMetadata(request.recordingId);
+            case RecordingRequestType.BY_CALL_SESSION:
+                return this.getRecordingsByCallSessionId(request.callSessionId, request.options);
+            default: {
+                const exhaustiveCheck = request;
+                throw new Error(`Unsupported recording request type: ${JSON.stringify(exhaustiveCheck)}`);
+            }
+        }
+    }
+    async getRecordings(options) {
+        const loggerContext = {
+            file: CALL_RECORDING_FILE,
+            method: METHODS.GET_RECORDINGS,
+        };
+        log.info(`${METHOD_START_MESSAGE} with options=${JSON.stringify(options ?? {})}`, loggerContext);
+        try {
+            const url = this.buildRecordingsUrl(options);
+            const response = await this.webex.request({
+                uri: url,
+                method: HTTP_METHODS.GET,
+                service: ALLOWED_SERVICES.HYDRA_DEVELOPER_API,
+                ...(options?.webexUserRequest ? { headers: { [WEBEX_USER_REQUEST_HEADER]: 'true' } } : {}),
+            });
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
+            const body = (response.body ?? {});
+            const responseDetails = {
+                statusCode: Number(response.statusCode) || SUCCESS_STATUS_CODE,
+                data: {
+                    recordings: body.items ?? [],
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            log.log(`Successfully retrieved ${responseDetails.data.recordings?.length ?? 0} recordings`, loggerContext);
+            return responseDetails;
+        }
+        catch (err) {
+            log.error(`Failed to get recordings: ${JSON.stringify(err)}`, loggerContext);
+            await uploadLogs();
+            const errorInfo = err;
+            return serviceErrorCodeHandler(errorInfo, loggerContext);
+        }
+    }
+    async getRecording(recordingId) {
+        const loggerContext = {
+            file: CALL_RECORDING_FILE,
+            method: METHODS.GET_RECORDING,
+        };
+        log.info(`${METHOD_START_MESSAGE} with recordingId=${recordingId}`, loggerContext);
+        try {
+            const url = `${this.recordingServiceUrl}/${CONVERGED_RECORDINGS}/${recordingId}`;
+            const response = await this.webex.request({
+                uri: url,
+                method: HTTP_METHODS.GET,
+                service: ALLOWED_SERVICES.HYDRA_DEVELOPER_API,
+            });
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
+            const responseDetails = {
+                statusCode: Number(response.statusCode) || SUCCESS_STATUS_CODE,
+                data: {
+                    recording: response.body,
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            log.log(`Successfully retrieved recording ${recordingId}`, loggerContext);
+            return responseDetails;
+        }
+        catch (err) {
+            log.error(`Failed to get recording: ${JSON.stringify(err)}`, loggerContext);
+            await uploadLogs();
+            const errorInfo = err;
+            return serviceErrorCodeHandler(errorInfo, loggerContext);
+        }
+    }
+    async getRecordingsByCallSessionId(callSessionId, options) {
+        const loggerContext = {
+            file: CALL_RECORDING_FILE,
+            method: METHODS.GET_RECORDINGS_BY_CALL_SESSION_ID,
+        };
+        log.info(`${METHOD_START_MESSAGE} with callSessionId=${callSessionId}`, loggerContext);
+        const listResponse = await this.getRecordings(options);
+        if (listResponse.statusCode !== SUCCESS_STATUS_CODE) {
+            return listResponse;
+        }
+        const filtered = (listResponse.data.recordings ?? []).filter((recording) => recording.serviceData?.callSessionId === callSessionId);
+        if (filtered.length === 0) {
+            log.info(RECORDING_NOT_FOUND_MESSAGE, loggerContext);
+        }
+        else {
+            log.log(`Successfully retrieved ${filtered.length} recordings for call session ${callSessionId}`, loggerContext);
+        }
+        return {
+            statusCode: SUCCESS_STATUS_CODE,
+            data: {
+                recordings: filtered,
+            },
+            message: SUCCESS_MESSAGE,
+        };
+    }
+    async getRecordingMetadata(recordingId) {
+        const loggerContext = {
+            file: CALL_RECORDING_FILE,
+            method: METHODS.GET_RECORDING_METADATA,
+        };
+        log.info(`${METHOD_START_MESSAGE} with recordingId=${recordingId}`, loggerContext);
+        try {
+            const url = `${this.recordingServiceUrl}/${CONVERGED_RECORDINGS}/${recordingId}/${METADATA}`;
+            const response = await this.webex.request({
+                uri: url,
+                method: HTTP_METHODS.GET,
+                service: ALLOWED_SERVICES.HYDRA_DEVELOPER_API,
+            });
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
+            const responseDetails = {
+                statusCode: Number(response.statusCode) || SUCCESS_STATUS_CODE,
+                data: {
+                    metadata: response.body,
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            log.log(`Successfully retrieved metadata for recording ${recordingId}`, loggerContext);
+            return responseDetails;
+        }
+        catch (err) {
+            log.error(`Failed to get recording metadata: ${JSON.stringify(err)}`, loggerContext);
+            await uploadLogs();
+            const errorInfo = err;
+            return serviceErrorCodeHandler(errorInfo, loggerContext);
+        }
+    }
+    async deleteRecording(recordingId, options) {
+        const loggerContext = {
+            file: CALL_RECORDING_FILE,
+            method: METHODS.DELETE_RECORDING,
+        };
+        log.info(`${METHOD_START_MESSAGE} with recordingId=${recordingId}`, loggerContext);
+        try {
+            const url = `${this.recordingServiceUrl}/${CONVERGED_RECORDINGS}/${recordingId}`;
+            const body = {};
+            if (options?.reason) {
+                body.reason = options.reason;
+            }
+            if (options?.comment) {
+                body.comment = options.comment;
+            }
+            const response = await this.webex.request({
+                uri: url,
+                method: HTTP_METHODS.DELETE,
+                service: ALLOWED_SERVICES.HYDRA_DEVELOPER_API,
+                ...(Object.keys(body).length > 0 ? { body } : {}),
+            });
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
+            const responseDetails = {
+                statusCode: Number(response.statusCode) || SUCCESS_STATUS_CODE,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+            log.log(`Successfully deleted recording ${recordingId}`, loggerContext);
+            return responseDetails;
+        }
+        catch (err) {
+            log.error(`Failed to delete recording: ${JSON.stringify(err)}`, loggerContext);
+            await uploadLogs();
+            const errorInfo = err;
+            return serviceErrorCodeHandler(errorInfo, loggerContext);
+        }
+    }
+    handleRecordingCreatedEvent = async (event) => {
+        if (!event?.data?.activity) {
+            return;
+        }
+        this.emit(COMMON_EVENT_KEYS.CALL_RECORDING_CREATED, event);
+    };
+    handleRecordingUpdatedEvent = async (event) => {
+        if (!event?.data?.activity) {
+            return;
+        }
+        switch (event.data.eventSubType) {
+            case RECORDING_EVENT_SUBTYPE.TRASH:
+            case RECORDING_EVENT_SUBTYPE.PURGE:
+                this.emit(COMMON_EVENT_KEYS.CALL_RECORDING_DELETED, event);
+                break;
+            case RECORDING_EVENT_SUBTYPE.RESTORE:
+                this.emit(COMMON_EVENT_KEYS.CALL_RECORDING_CREATED, event);
+                break;
+            default:
+                this.emit(COMMON_EVENT_KEYS.CALL_RECORDING_UPDATED, event);
+        }
+    };
+    handleRecordingDeletedEvent = async (event) => {
+        if (!event?.data?.activity) {
+            return;
+        }
+        this.emit(COMMON_EVENT_KEYS.CALL_RECORDING_DELETED, event);
+    };
+    registerRecordingListeners() {
+        this.sdkConnector.registerListener(MOBIUS_EVENT_KEYS.RECORDING_EVENT_CREATED, this.handleRecordingCreatedEvent);
+        this.sdkConnector.registerListener(MOBIUS_EVENT_KEYS.RECORDING_EVENT_UPDATED, this.handleRecordingUpdatedEvent);
+        this.sdkConnector.registerListener(MOBIUS_EVENT_KEYS.RECORDING_EVENT_DELETED, this.handleRecordingDeletedEvent);
+    }
+}

package/dist/module/CallRecording/callRecordingFixtures.js

@@ -0,0 +1,201 @@
+import { MOBIUS_EVENT_KEYS, RECORDING_EVENT_SUBTYPE, RECORDING_EVENT_TYPE, } from '../Events/types';
+import { RecordingStatus } from './types';
+export const CALL_SESSION_ID = 'a1b2c3d4-1111-2222-3333-444455556666';
+export const RECORDING_ONE = {
+    id: '11111111-aaaa-bbbb-cccc-222222222222',
+    topic: 'Call with Alice',
+    createTime: '2024-05-01T10:01:05.000Z',
+    timeRecorded: '2024-05-01T10:00:00.000Z',
+    format: 'MP3',
+    serviceType: 'calling',
+    durationSeconds: 65,
+    sizeBytes: 1048576,
+    status: RecordingStatus.AVAILABLE,
+    ownerId: '8a67806f-fc4d-446b-a131-31e71ea5b0e9',
+    ownerEmail: 'owner@cisco.com',
+    ownerType: 'user',
+    storageRegion: 'US',
+    serviceData: {
+        locationId: 'loc-1',
+        callSessionId: CALL_SESSION_ID,
+    },
+};
+export const RECORDING_TWO = {
+    id: '33333333-dddd-eeee-ffff-444444444444',
+    topic: 'Call with Bob',
+    createTime: '2024-05-02T11:02:05.000Z',
+    timeRecorded: '2024-05-02T11:00:00.000Z',
+    format: 'MP3',
+    serviceType: 'calling',
+    durationSeconds: 120,
+    sizeBytes: 2097152,
+    status: RecordingStatus.AVAILABLE,
+    ownerId: '8a67806f-fc4d-446b-a131-31e71ea5b0e9',
+    ownerEmail: 'owner@cisco.com',
+    ownerType: 'user',
+    storageRegion: 'US',
+    serviceData: {
+        locationId: 'loc-1',
+        callSessionId: 'ffffffff-9999-8888-7777-666666666666',
+    },
+};
+export const MOCK_RECORDING_LIST_BODY = {
+    statusCode: 200,
+    body: {
+        items: [RECORDING_ONE, RECORDING_TWO],
+    },
+};
+export const MOCK_EMPTY_RECORDING_LIST_BODY = {
+    statusCode: 200,
+    body: {
+        items: [],
+    },
+};
+export const MOCK_RECORDING_BODY = {
+    statusCode: 200,
+    body: RECORDING_ONE,
+};
+export const RECORDING_OWNER_ID = '8a67806f-fc4d-446b-a131-31e71ea5b0e9';
+export const RECORDING_REMOTE_PARTY_ID = '0fea4a63-4e27-46ee-99c3-2472cb12bf68';
+export const MOCK_RECORDING_METADATA = {
+    id: RECORDING_ONE.id,
+    callSessionId: CALL_SESSION_ID,
+    owner: {
+        ownerID: RECORDING_OWNER_ID,
+        ownerEmail: 'owner@cisco.com',
+        ownerName: 'Mark',
+        orgID: '1704d30d-a131-4bc7-9449-948487643793',
+    },
+    participants: [
+        { id: RECORDING_OWNER_ID, name: 'Mark', email: 'owner@cisco.com' },
+        { id: RECORDING_REMOTE_PARTY_ID, name: 'Alice', email: 'alice@cisco.com' },
+    ],
+    mediaStreams: [{ streamId: 'audio-1', type: 'audio', codec: 'opus', durationMS: 65000 }],
+    extensionData: {
+        callData: { direction: 'OUTGOING' },
+        acd: {},
+        redirectInfo: {},
+    },
+    serviceData: {
+        callRecordingId: RECORDING_ONE.id,
+        locationId: 'loc-1',
+        callSessionId: CALL_SESSION_ID,
+        personality: 'originator',
+        callingParty: {
+            actor: { type: 'USER', id: RECORDING_OWNER_ID, email: 'owner@cisco.com' },
+            number: '9902',
+            name: 'Mark',
+        },
+        calledParty: {
+            actor: { type: 'USER', id: RECORDING_REMOTE_PARTY_ID, email: 'alice@cisco.com' },
+            number: '9903',
+            name: 'Alice',
+        },
+    },
+};
+export const MOCK_RECORDING_METADATA_BODY = {
+    statusCode: 200,
+    body: MOCK_RECORDING_METADATA,
+};
+export const ERROR_DETAILS_400 = {
+    statusCode: 400,
+    data: {
+        error: '400 Bad request',
+    },
+    message: 'FAILURE',
+};
+export const ERROR_DETAILS_401 = {
+    statusCode: 401,
+    data: {
+        error: 'User is unauthorised, possible token expiry',
+    },
+    message: 'FAILURE',
+};
+export const ERROR_DETAILS_404 = {
+    statusCode: 404,
+    data: {
+        error: 'User info not found',
+    },
+    message: 'FAILURE',
+};
+const RECORDING_ACTIVITY = {
+    id: 'activity-1',
+    objectType: 'activity',
+    verb: 'add',
+    published: '2024-05-01T10:01:05.000Z',
+    actor: {
+        id: '8a67806f-fc4d-446b-a131-31e71ea5b0e9',
+        objectType: 'person',
+        emailAddress: 'owner@cisco.com',
+    },
+    object: {
+        id: RECORDING_ONE.id,
+        objectType: 'wxCallingCallRecording',
+        callSessionId: CALL_SESSION_ID,
+        durationSeconds: 65,
+        sizeBytes: 1048576,
+    },
+};
+export const MOCK_RECORDING_CREATED_EVENT = {
+    id: 'event-created',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.CREATED,
+    },
+    timestamp: 12345,
+    trackingId: 'tracking-id',
+};
+export const MOCK_RECORDING_UPDATED_EVENT = {
+    id: 'event-updated',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.UPDATED,
+        eventSubType: RECORDING_EVENT_SUBTYPE.SUMMARY_CREATE,
+    },
+    timestamp: 12346,
+    trackingId: 'tracking-id',
+};
+export const MOCK_RECORDING_DELETED_EVENT = {
+    id: 'event-deleted',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.DELETED,
+    },
+    timestamp: 12347,
+    trackingId: 'tracking-id',
+};
+export const MOCK_RECORDING_TRASH_EVENT = {
+    id: 'event-trash',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.UPDATED,
+        eventSubType: RECORDING_EVENT_SUBTYPE.TRASH,
+    },
+    timestamp: 12348,
+    trackingId: 'tracking-id',
+};
+export const MOCK_RECORDING_PURGE_EVENT = {
+    id: 'event-purge',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.UPDATED,
+        eventSubType: RECORDING_EVENT_SUBTYPE.PURGE,
+    },
+    timestamp: 12349,
+    trackingId: 'tracking-id',
+};
+export const MOCK_RECORDING_RESTORE_EVENT = {
+    id: 'event-restore',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.UPDATED,
+        eventSubType: RECORDING_EVENT_SUBTYPE.RESTORE,
+    },
+    timestamp: 12350,
+    trackingId: 'tracking-id',
+};
+export const RECORDING_MERCURY_KEYS = {
+    CREATED: MOBIUS_EVENT_KEYS.RECORDING_EVENT_CREATED,
+    UPDATED: MOBIUS_EVENT_KEYS.RECORDING_EVENT_UPDATED,
+    DELETED: MOBIUS_EVENT_KEYS.RECORDING_EVENT_DELETED,
+};

package/dist/module/CallRecording/constants.js

@@ -0,0 +1,27 @@
+export const CALL_RECORDING_FILE = 'CallRecording';
+export const CONVERGED_RECORDINGS = 'convergedRecordings';
+export const METADATA = 'metadata';
+export const FROM = 'from';
+export const TO = 'to';
+export const STATUS = 'status';
+export const MAX = 'max';
+export const SERVICE_TYPE = 'serviceType';
+export const FORMAT = 'format';
+export const OWNER_TYPE = 'ownerType';
+export const STORAGE_REGION = 'storageRegion';
+export const LOCATION_ID = 'locationId';
+export const TOPIC = 'topic';
+export const DEFAULT_STATUS = 'available';
+export const DEFAULT_MAX = 30;
+export const DEFAULT_NUMBER_OF_DAYS = 30;
+export const WEBEX_USER_REQUEST_HEADER = 'WebexUserRequest';
+export const RECORDING_NOT_FOUND_MESSAGE = 'No recordings found for the given call session id.';
+export const METHODS = {
+    INITIALIZE_BACKEND_CONNECTOR: 'initializeBackendConnector',
+    GET_CALL_RECORDING: 'getCallRecording',
+    GET_RECORDINGS: 'getRecordings',
+    GET_RECORDING: 'getRecording',
+    GET_RECORDINGS_BY_CALL_SESSION_ID: 'getRecordingsByCallSessionId',
+    GET_RECORDING_METADATA: 'getRecordingMetadata',
+    DELETE_RECORDING: 'deleteRecording',
+};

package/dist/module/CallRecording/types.js

@@ -0,0 +1,19 @@
+export var RecordingStatus;
+(function (RecordingStatus) {
+    RecordingStatus["AVAILABLE"] = "available";
+    RecordingStatus["DELETED"] = "deleted";
+})(RecordingStatus || (RecordingStatus = {}));
+export var AiGenerationStatus;
+(function (AiGenerationStatus) {
+    AiGenerationStatus["NOT_STARTED"] = "NOT_STARTED";
+    AiGenerationStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    AiGenerationStatus["COMPLETED"] = "COMPLETED";
+    AiGenerationStatus["FAILED"] = "FAILED";
+})(AiGenerationStatus || (AiGenerationStatus = {}));
+export var RecordingRequestType;
+(function (RecordingRequestType) {
+    RecordingRequestType["LIST"] = "list";
+    RecordingRequestType["DETAIL"] = "detail";
+    RecordingRequestType["METADATA"] = "metadata";
+    RecordingRequestType["BY_CALL_SESSION"] = "byCallSession";
+})(RecordingRequestType || (RecordingRequestType = {}));

package/dist/module/CallRecording/utils.js

@@ -0,0 +1,14 @@
+export const getRemoteParty = (serviceData) => {
+    if (!serviceData) {
+        return undefined;
+    }
+    const { personality, callingParty, calledParty } = serviceData;
+    switch (personality) {
+        case 'originator':
+            return calledParty;
+        case 'terminator':
+            return callingParty;
+        default:
+            return undefined;
+    }
+};

package/dist/module/Events/types.js

@@ -7,6 +7,9 @@ export var COMMON_EVENT_KEYS;
     COMMON_EVENT_KEYS["CALL_HISTORY_USER_SESSION_INFO"] = "callHistory:user_recent_sessions";
     COMMON_EVENT_KEYS["CALL_HISTORY_USER_VIEWED_SESSIONS"] = "callHistory:user_viewed_sessions";
     COMMON_EVENT_KEYS["CALL_HISTORY_USER_SESSIONS_DELETED"] = "callHistory:user_sessions_deleted";
+    COMMON_EVENT_KEYS["CALL_RECORDING_CREATED"] = "callRecording:created";
+    COMMON_EVENT_KEYS["CALL_RECORDING_UPDATED"] = "callRecording:updated";
+    COMMON_EVENT_KEYS["CALL_RECORDING_DELETED"] = "callRecording:deleted";
 })(COMMON_EVENT_KEYS || (COMMON_EVENT_KEYS = {}));
 export var LINE_EVENT_KEYS;
 (function (LINE_EVENT_KEYS) {
@@ -69,12 +72,28 @@ export var MOBIUS_EVENT_KEYS;
     MOBIUS_EVENT_KEYS["CALL_SESSION_EVENT_LEGACY"] = "event:janus.user_sessions";
     MOBIUS_EVENT_KEYS["CALL_SESSION_EVENT_VIEWED"] = "event:janus.user_viewed_sessions";
     MOBIUS_EVENT_KEYS["CALL_SESSION_EVENT_DELETED"] = "event:janus.user_sessions_deleted";
+    MOBIUS_EVENT_KEYS["RECORDING_EVENT_CREATED"] = "event:convergedRecordings.created";
+    MOBIUS_EVENT_KEYS["RECORDING_EVENT_UPDATED"] = "event:convergedRecordings.updated";
+    MOBIUS_EVENT_KEYS["RECORDING_EVENT_DELETED"] = "event:convergedRecordings.deleted";
 })(MOBIUS_EVENT_KEYS || (MOBIUS_EVENT_KEYS = {}));
 export var MEDIA_CONNECTION_EVENT_KEYS;
 (function (MEDIA_CONNECTION_EVENT_KEYS) {
     MEDIA_CONNECTION_EVENT_KEYS["ROAP_MESSAGE_TO_SEND"] = "roap:messageToSend";
     MEDIA_CONNECTION_EVENT_KEYS["MEDIA_TYPE_AUDIO"] = "audio";
 })(MEDIA_CONNECTION_EVENT_KEYS || (MEDIA_CONNECTION_EVENT_KEYS = {}));
+export var RECORDING_EVENT_TYPE;
+(function (RECORDING_EVENT_TYPE) {
+    RECORDING_EVENT_TYPE["CREATED"] = "convergedRecordings.created";
+    RECORDING_EVENT_TYPE["UPDATED"] = "convergedRecordings.updated";
+    RECORDING_EVENT_TYPE["DELETED"] = "convergedRecordings.deleted";
+})(RECORDING_EVENT_TYPE || (RECORDING_EVENT_TYPE = {}));
+export var RECORDING_EVENT_SUBTYPE;
+(function (RECORDING_EVENT_SUBTYPE) {
+    RECORDING_EVENT_SUBTYPE["TRASH"] = "TRASH";
+    RECORDING_EVENT_SUBTYPE["PURGE"] = "PURGE";
+    RECORDING_EVENT_SUBTYPE["RESTORE"] = "RESTORE";
+    RECORDING_EVENT_SUBTYPE["SUMMARY_CREATE"] = "SUMMARY_CREATE";
+})(RECORDING_EVENT_SUBTYPE || (RECORDING_EVENT_SUBTYPE = {}));
 var CALL_STATE;
 (function (CALL_STATE) {
     CALL_STATE["HELD"] = "held";

package/dist/module/api.js

@@ -3,5 +3,6 @@ import { CallSettings, createCallSettingsClient } from './CallSettings/CallSetti
 import { CallingClient, createClient } from './CallingClient/CallingClient';
 import { ContactsClient, createContactsClient } from './Contacts/ContactsClient';
 import { Voicemail, createVoicemailClient } from './Voicemail/Voicemail';
-export { CallHistory, CallSettings, CallingClient, ContactsClient, Voicemail };
-export { createCallHistoryClient, createCallSettingsClient, createClient, createContactsClient, createVoicemailClient, };
+import { CallRecording, createCallRecordingClient } from './CallRecording/CallRecording';
+export { CallHistory, CallSettings, CallingClient, ContactsClient, Voicemail, CallRecording };
+export { createCallHistoryClient, createCallSettingsClient, createClient, createContactsClient, createVoicemailClient, createCallRecordingClient, };

package/dist/module/common/testUtil.js

@@ -65,6 +65,7 @@ export function getTestUtilsWebex() {
                     mercuryApi: 'https://mercury-api-intb.ciscospark.com/v1',
                     'ucmgmt-gateway': 'https://gw.telemetry.int-ucmgmt.cisco.com',
                     contactsService: 'https://contacts-service-a.wbx2.com/contact/api/v1',
+                    hydraDeveloperApi: 'https://integration.webexapis.com/v1',
                 },
                 fetchClientRegionInfo: jest.fn(),
                 getMobiusClusters: jest.fn(),

package/dist/module/common/types.js

@@ -3,6 +3,7 @@ export var ALLOWED_SERVICES;
 (function (ALLOWED_SERVICES) {
     ALLOWED_SERVICES["MOBIUS"] = "mobius";
     ALLOWED_SERVICES["JANUS"] = "janus";
+    ALLOWED_SERVICES["HYDRA_DEVELOPER_API"] = "hydraDeveloperApi";
 })(ALLOWED_SERVICES || (ALLOWED_SERVICES = {}));
 export var HTTP_METHODS;
 (function (HTTP_METHODS) {

package/dist/module/index.js

@@ -4,9 +4,12 @@ import { createContactsClient } from './Contacts/ContactsClient';
 import { createClient } from './CallingClient/CallingClient';
 import { createCallHistoryClient } from './CallHistory/CallHistory';
 import { createVoicemailClient } from './Voicemail/Voicemail';
+import { createCallRecordingClient } from './CallRecording/CallRecording';
 import Logger from './Logger';
-export { createClient, createCallHistoryClient, createCallSettingsClient, createContactsClient, createMicrophoneStream, createVoicemailClient, Logger, NoiseReductionEffect, };
+export { createClient, createCallHistoryClient, createCallSettingsClient, createContactsClient, createMicrophoneStream, createVoicemailClient, createCallRecordingClient, Logger, NoiseReductionEffect, };
 export { ERROR_LAYER, ERROR_TYPE } from './Errors/types';
+export { RecordingStatus, RecordingRequestType, } from './CallRecording/types';
+export { getRemoteParty } from './CallRecording/utils';
 export { GroupType } from './Contacts/types';
 export { LINE_EVENTS } from './CallingClient/line/types';
 export { CALLING_CLIENT_EVENT_KEYS, CALL_EVENT_KEYS, Disposition, LINE_EVENT_KEYS, COMMON_EVENT_KEYS, MOBIUS_SOCKET_DISCONNECT_REASON, } from './Events/types';

package/dist/types/CallRecording/CallRecording.d.ts

@@ -0,0 +1,18 @@
+import { WebexSDK } from '../SDKConnector/types';
+import { CallRecordingEventTypes } from '../Events/types';
+import { Eventing } from '../Events/impl';
+import { DeleteRecordingOptions, GetCallRecordingRequest, ICallRecording, LoggerInterface, RecordingDeleteResponse, RecordingResponseFor } from './types';
+export declare class CallRecording extends Eventing<CallRecordingEventTypes> implements ICallRecording {
+    logger: LoggerInterface;
+    private sdkConnector;
+    private webex;
+    private callingBackend;
+    private backendConnector;
+    constructor(webex: WebexSDK, logger: LoggerInterface);
+    private initializeBackendConnector;
+    private forwardRecordingEvents;
+    getCallRecording<T extends GetCallRecordingRequest>(request: T): Promise<RecordingResponseFor<T>>;
+    deleteRecording(recordingId: string, options?: DeleteRecordingOptions): Promise<RecordingDeleteResponse>;
+}
+export declare const createCallRecordingClient: (webex: WebexSDK, logger: LoggerInterface) => ICallRecording;
+//# sourceMappingURL=CallRecording.d.ts.map

package/dist/types/CallRecording/CallRecording.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallRecording.d.ts","sourceRoot":"","sources":["../../../src/CallRecording/CallRecording.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgB,QAAQ,EAAC,MAAM,uBAAuB,CAAC;AAK9D,OAAO,EAAC,uBAAuB,EAAoC,MAAM,iBAAiB,CAAC;AAC3F,OAAO,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACxC,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,cAAc,EACd,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAmBjB,qBAAa,aAAc,SAAQ,QAAQ,CAAC,uBAAuB,CAAE,YAAW,cAAc;IAYxD,MAAM,EAAE,eAAe;IAX3D,OAAO,CAAC,YAAY,CAAgB;IAEpC,OAAO,CAAC,KAAK,CAAW;IAExB,OAAO,CAAC,cAAc,CAAkB;IAExC,OAAO,CAAC,gBAAgB,CAAkB;gBAK9B,KAAK,EAAE,QAAQ,EAAS,MAAM,EAAE,eAAe;IAiB3D,OAAO,CAAC,0BAA0B;IAsBlC,OAAO,CAAC,sBAAsB;IAiBvB,gBAAgB,CAAC,CAAC,SAAS,uBAAuB,EACvD,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;IAStB,eAAe,CAC1B,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,uBAAuB,CAAC;CAGpC;AAQD,eAAO,MAAM,yBAAyB,UAC7B,QAAQ,UACP,eAAe,KACtB,cAAkD,CAAC"}

package/dist/types/CallRecording/WxcCallRecordingConnector.d.ts

@@ -0,0 +1,23 @@
+import { WebexSDK } from '../SDKConnector/types';
+import { CallRecordingEventTypes, RecordingEvent } from '../Events/types';
+import { Eventing } from '../Events/impl';
+import { DeleteRecordingOptions, GetCallRecordingRequest, ICallRecording, LoggerInterface, RecordingDeleteResponse, RecordingResponseFor } from './types';
+export declare class WxcCallRecordingConnector extends Eventing<CallRecordingEventTypes> implements ICallRecording {
+    private sdkConnector;
+    private webex;
+    private recordingServiceUrl;
+    constructor(webex: WebexSDK, logger: LoggerInterface);
+    private buildRecordingsUrl;
+    getCallRecording<T extends GetCallRecordingRequest>(request: T): Promise<RecordingResponseFor<T>>;
+    private dispatchGetCallRecording;
+    private getRecordings;
+    private getRecording;
+    private getRecordingsByCallSessionId;
+    private getRecordingMetadata;
+    deleteRecording(recordingId: string, options?: DeleteRecordingOptions): Promise<RecordingDeleteResponse>;
+    handleRecordingCreatedEvent: (event?: RecordingEvent) => Promise<void>;
+    handleRecordingUpdatedEvent: (event?: RecordingEvent) => Promise<void>;
+    handleRecordingDeletedEvent: (event?: RecordingEvent) => Promise<void>;
+    private registerRecordingListeners;
+}
+//# sourceMappingURL=WxcCallRecordingConnector.d.ts.map

package/dist/types/CallRecording/WxcCallRecordingConnector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WxcCallRecordingConnector.d.ts","sourceRoot":"","sources":["../../../src/CallRecording/WxcCallRecordingConnector.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgB,QAAQ,EAAC,MAAM,uBAAuB,CAAC;AAK9D,OAAO,EACL,uBAAuB,EAIvB,cAAc,EACf,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACxC,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EAEvB,cAAc,EACd,eAAe,EAEf,uBAAuB,EAOvB,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAgCjB,qBAAa,yBACX,SAAQ,QAAQ,CAAC,uBAAuB,CACxC,YAAW,cAAc;IAEzB,OAAO,CAAC,YAAY,CAAgB;IAEpC,OAAO,CAAC,KAAK,CAAW;IAExB,OAAO,CAAC,mBAAmB,CAAS;gBAMxB,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe;IAmCpD,OAAO,CAAC,kBAAkB;IAyCnB,gBAAgB,CAAC,CAAC,SAAS,uBAAuB,EACvD,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;IAYnC,OAAO,CAAC,wBAAwB;YA4BlB,aAAa;YAqDb,YAAY;YAqDZ,4BAA4B;YA2C5B,oBAAoB;IAgDrB,eAAe,CAC1B,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,uBAAuB,CAAC;IAiDnC,2BAA2B,WAAkB,cAAc,mBAMzD;IAaF,2BAA2B,WAAkB,cAAc,mBAkBzD;IAEF,2BAA2B,WAAkB,cAAc,mBAMzD;IAKF,OAAO,CAAC,0BAA0B;CAcnC"}