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

package/dist/module/mobius-socket/socket/socket-base.js

@@ -0,0 +1,368 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import { EventEmitter } from 'events';
+import { checkRequired } from '@webex/common';
+import { safeSetTimeout } from '@webex/common-timers';
+import { defaults, has, isObject } from 'lodash';
+import { BadRequest, ConnectionError, createTimeoutError, createWssResponseError, Forbidden, NotAuthorized, UnknownResponse, } from '../errors';
+import { MESSAGE_TYPES, SOCKET_READY_STATE } from './constants';
+const sockets = new WeakMap();
+function createTrackingId() {
+    return `webex-js-sdk_${crypto.randomUUID()}`;
+}
+export default class Socket extends EventEmitter {
+    domain;
+    pendingResponses;
+    forceCloseDelay;
+    logger;
+    refreshToken;
+    token;
+    trackingId;
+    wssResponseTimeout;
+    constructor() {
+        super();
+        this.domain = 'unknown-domain';
+        this.pendingResponses = new Map();
+        this.onmessage = this.onmessage.bind(this);
+        this.onclose = this.onclose.bind(this);
+        this.setMaxListeners(10);
+    }
+    get binaryType() {
+        return sockets.get(this)?.binaryType || '';
+    }
+    get bufferedAmount() {
+        return sockets.get(this)?.bufferedAmount || 0;
+    }
+    get extensions() {
+        return sockets.get(this)?.extensions || '';
+    }
+    get protocol() {
+        return sockets.get(this)?.protocol || '';
+    }
+    get readyState() {
+        return sockets.get(this)?.readyState || 0;
+    }
+    get url() {
+        return sockets.get(this)?.url || '';
+    }
+    static getWebSocketConstructor() {
+        throw new Error('Socket.getWebSocketConstructor() must be implemented in an environmentally appropriate way');
+    }
+    close(options) {
+        return new Promise((resolve, reject) => {
+            const socket = sockets.get(this);
+            if (!socket) {
+                resolve();
+                return;
+            }
+            this.logger.info(`socket,${this.domain}: closing`);
+            if (socket.readyState === SOCKET_READY_STATE.CLOSING ||
+                socket.readyState === SOCKET_READY_STATE.CLOSED) {
+                this.logger.info(`socket,${this.domain}: already closed`);
+                resolve();
+                return;
+            }
+            const originalCode = options?.code;
+            const originalReason = options?.reason;
+            const resolvedOptions = defaults(options || {}, {
+                code: 1000,
+                reason: 'Done',
+            });
+            if (resolvedOptions.code &&
+                resolvedOptions.code !== 1000 &&
+                (resolvedOptions.code < 3000 || resolvedOptions.code > 4999)) {
+                reject(new Error('`options.code` must be 1000 or between 3000 and 4999 (inclusive)'));
+                return;
+            }
+            const closeTimer = safeSetTimeout(() => {
+                try {
+                    this.logger.info(`socket,${this.domain}: no close event received, forcing closure`);
+                    resolve(this.onclose(originalCode
+                        ? { code: originalCode, reason: originalReason || 'Done (unknown)' }
+                        : {
+                            code: 1000,
+                            reason: 'Done (forced)',
+                        }));
+                }
+                catch (error) {
+                    this.logger.warn(`socket,${this.domain}: force-close failed`, error);
+                }
+            }, this.forceCloseDelay);
+            socket.onclose = (event) => {
+                this.logger.info(`socket,${this.domain}: close event fired`, event.code, event.reason);
+                clearTimeout(closeTimer);
+                this.onclose(event);
+                resolve(event);
+            };
+            if (socket.readyState === SOCKET_READY_STATE.CONNECTING) {
+                this.logger.info(`socket,${this.domain}: socket still connecting, triggering close manually`);
+                clearTimeout(closeTimer);
+                const closeEvent = {
+                    code: resolvedOptions.code,
+                    reason: resolvedOptions.reason,
+                };
+                this.onclose(closeEvent);
+                resolve(closeEvent);
+                try {
+                    socket.close(resolvedOptions.code, resolvedOptions.reason);
+                }
+                catch (error) {
+                    this.logger.info(`socket,${this.domain}: error while closing CONNECTING socket, likely due to browser incompatibility with custom close codes`, error);
+                }
+            }
+            else {
+                socket.close(resolvedOptions.code, resolvedOptions.reason);
+            }
+        });
+    }
+    open(url, options) {
+        try {
+            this.domain = new URL(url).hostname;
+        }
+        catch {
+            this.domain = url;
+        }
+        return new Promise((resolve, reject) => {
+            if (!url) {
+                reject(new Error('`url` is required'));
+                return;
+            }
+            if (sockets.get(this)) {
+                reject(new Error('Socket#open() can only be called once per instance'));
+                return;
+            }
+            const resolvedOptions = (options || {});
+            checkRequired(['forceCloseDelay', 'token', 'trackingId', 'logger'], resolvedOptions);
+            Object.keys(resolvedOptions).forEach((key) => {
+                Reflect.defineProperty(this, key, {
+                    enumerable: false,
+                    value: resolvedOptions[key],
+                });
+            });
+            const WebSocket = Socket.getWebSocketConstructor();
+            this.logger.info(`socket,${this.domain}: creating WebSocket`);
+            const socket = new WebSocket(url, [], resolvedOptions);
+            socket.binaryType = 'arraybuffer';
+            socket.onmessage = this.onmessage;
+            socket.onclose = (event) => {
+                event = this.fixCloseCode(event);
+                this.logger.info(`socket,${this.domain}: closed before open`, event.code, event.reason);
+                switch (event.code) {
+                    case 1005:
+                        return reject(new UnknownResponse(event));
+                    case 4400:
+                        return reject(new BadRequest(event));
+                    case 4401:
+                        return reject(new NotAuthorized(event));
+                    case 4403:
+                        return reject(new Forbidden(event));
+                    default:
+                        return reject(new ConnectionError(event));
+                }
+            };
+            socket.onopen = () => {
+                this.logger.info(`socket,${this.domain}: connected`);
+                this.authorize(this.token)
+                    .then(() => {
+                    this.logger.info(`socket,${this.domain}: authorized`);
+                    socket.onclose = this.onclose;
+                    resolve();
+                })
+                    .catch(reject);
+            };
+            socket.onerror = (event) => {
+                this.logger.warn(`socket,${this.domain}: error event fired`, event);
+            };
+            sockets.set(this, socket);
+            this.logger.info(`socket,${this.domain}: waiting for server`);
+        });
+    }
+    onclose(event) {
+        this.logger.info(`socket,${this.domain}: closed`, event.code, event.reason);
+        event = this.fixCloseCode(event);
+        this.rejectPendingResponses(new ConnectionError(event));
+        this.emit('close', event);
+        this.removeAllListeners();
+    }
+    onmessage(event) {
+        try {
+            const data = JSON.parse(event.data);
+            const processedEvent = { data };
+            if (data.type === 'async_event') {
+                this.acknowledge(processedEvent).catch((error) => {
+                    this.logger.warn(`socket,${this.domain}: failed to acknowledge async event`, error);
+                });
+            }
+            this.handlePendingResponse(data);
+            this.emit('message', processedEvent);
+        }
+        catch (error) {
+            this.logger.warn(`socket,${this.domain}: error while receiving WebSocket message`, error);
+        }
+    }
+    send(data) {
+        return new Promise((resolve, reject) => {
+            if (this.readyState !== SOCKET_READY_STATE.OPEN) {
+                reject(new Error('INVALID_STATE_ERROR'));
+                return;
+            }
+            if (isObject(data)) {
+                data = JSON.stringify(data);
+            }
+            const socket = sockets.get(this);
+            if (!socket) {
+                reject(new Error('INVALID_STATE_ERROR'));
+                return;
+            }
+            socket.send(data);
+            resolve();
+        });
+    }
+    sendRequest(data, options = {}) {
+        if (!isObject(data)) {
+            return Promise.reject(new Error('`data` is required'));
+        }
+        const request = { ...data };
+        const trackingId = request.trackingId || createTrackingId();
+        const timeout = options.timeout || this.wssResponseTimeout || 10000;
+        if (this.pendingResponses.has(trackingId)) {
+            return Promise.reject(new Error(`socket request already sent for trackingId ${trackingId}`));
+        }
+        request.trackingId = trackingId;
+        return new Promise((resolve, reject) => {
+            const timeoutId = safeSetTimeout(() => {
+                this.clearPendingResponse(trackingId);
+                reject(createTimeoutError(request));
+            }, timeout);
+            const pendingResponse = {
+                request,
+                resolve: (response) => {
+                    this.clearPendingResponse(trackingId);
+                    resolve(response);
+                },
+                reject: (error) => {
+                    this.clearPendingResponse(trackingId);
+                    reject(error);
+                },
+                timeoutId,
+            };
+            this.pendingResponses.set(trackingId, pendingResponse);
+            this.send(request).catch((error) => {
+                this.clearPendingResponse(trackingId);
+                reject(error);
+            });
+        });
+    }
+    acknowledge(event) {
+        if (!event) {
+            return Promise.reject(new Error('`event` is required'));
+        }
+        if (!has(event, 'data.eventId')) {
+            return Promise.reject(new Error('`event.data.eventId` is required'));
+        }
+        if (this.readyState !== SOCKET_READY_STATE.OPEN) {
+            return Promise.resolve();
+        }
+        return this.send({
+            type: MESSAGE_TYPES.EVENT_ACK,
+            trackingId: event.data.trackingId || createTrackingId(),
+            eventId: event.data.eventId,
+        }).catch((error) => {
+            if (error.message === 'INVALID_STATE_ERROR') {
+                return Promise.resolve();
+            }
+            throw error;
+        });
+    }
+    refresh(token) {
+        if (!token) {
+            return Promise.reject(new Error('`token` is required for Socket#refresh()'));
+        }
+        let refreshedToken;
+        if (typeof token === 'string') {
+            refreshedToken = token;
+        }
+        else if (token && typeof token.toString === 'function') {
+            refreshedToken = token.toString();
+        }
+        else {
+            refreshedToken = String(token);
+        }
+        return this.authorize(refreshedToken);
+    }
+    authorize(token) {
+        this.logger.info(`socket,${this.domain}: authorizing`);
+        return this.sendRequest({
+            type: MESSAGE_TYPES.AUTH,
+            data: { token },
+        });
+    }
+    clearPendingResponse(trackingId) {
+        const pendingResponse = this.pendingResponses.get(trackingId);
+        if (pendingResponse?.timeoutId) {
+            clearTimeout(pendingResponse.timeoutId);
+        }
+        this.pendingResponses.delete(trackingId);
+    }
+    rejectPendingResponses(error) {
+        if (!this.pendingResponses.size) {
+            return;
+        }
+        for (const pendingResponse of this.pendingResponses.values()) {
+            pendingResponse.reject(error);
+        }
+    }
+    handlePendingResponse(response) {
+        if (!response) {
+            return false;
+        }
+        const pendingResponse = this.pendingResponses.get(response.trackingId || '');
+        if (!pendingResponse) {
+            return false;
+        }
+        if (response.subtype !== pendingResponse.request.type) {
+            return false;
+        }
+        const statusCode = response?.statusCode;
+        const statusMessage = response?.statusMessage;
+        if (statusCode === 440 && response?.subtype !== MESSAGE_TYPES.AUTH) {
+            if (typeof this.refreshToken === 'function') {
+                Promise.resolve(this.refreshToken(response)).catch((error) => {
+                    this.logger.warn(`socket,${this.domain}: failed token-expiry re-auth`, error);
+                });
+            }
+            else {
+                this.logger.warn(`socket,${this.domain}: refreshToken callback is unavailable for statusCode 440`);
+            }
+        }
+        if (statusCode === undefined) {
+            const error = createWssResponseError(response, statusCode, statusMessage || 'Socket response missing status code');
+            pendingResponse.reject(error);
+        }
+        else if (statusCode >= 200 && statusCode < 300) {
+            pendingResponse.resolve(response);
+        }
+        else {
+            pendingResponse.reject(createWssResponseError(response, statusCode, statusMessage));
+        }
+        return true;
+    }
+    fixCloseCode(event) {
+        if (event.code === 1005 && event.reason) {
+            switch (event.reason.toLowerCase()) {
+                case 'replaced':
+                    this.logger.info(`socket,${this.domain}: fixing CloseEvent code for reason: `, event.reason);
+                    event.code = 4000;
+                    break;
+                case 'authentication failed':
+                case 'authentication did not happen within the timeout window of 30000 seconds.':
+                    this.logger.info(`socket,${this.domain}: fixing CloseEvent code for reason: `, event.reason);
+                    event.code = 1008;
+                    break;
+                default:
+            }
+        }
+        return event;
+    }
+}

package/dist/module/mobius-socket/socket/socket.js

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import WS from 'ws';
+import Socket from './socket-base';
+Socket.getWebSocketConstructor = function getWebSocketConstructor() {
+    return WS;
+};
+export default Socket;

package/dist/module/mobius-socket/socket/socket.shim.js

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import Socket from './socket-base';
+Socket.getWebSocketConstructor = function getWebSocketConstructor() {
+    if (typeof WebSocket !== 'undefined') {
+        return WebSocket;
+    }
+    const scope = typeof globalThis !== 'undefined' ? globalThis : undefined;
+    return (scope?.WebSocket || scope?.MozWebSocket);
+};
+export default Socket;

package/dist/module/mobius-socket/socket/types.js

@@ -0,0 +1 @@
+export {};

package/dist/module/mobius-socket/types.js

@@ -0,0 +1 @@
+export {};

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"}

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

@@ -0,0 +1,61 @@
+import { MOBIUS_EVENT_KEYS, RecordingEvent } from '../Events/types';
+import { Recording, RecordingMetadata } from './types';
+export declare const CALL_SESSION_ID = "a1b2c3d4-1111-2222-3333-444455556666";
+export declare const RECORDING_ONE: Recording;
+export declare const RECORDING_TWO: Recording;
+export declare const MOCK_RECORDING_LIST_BODY: {
+    statusCode: number;
+    body: {
+        items: Recording[];
+    };
+};
+export declare const MOCK_EMPTY_RECORDING_LIST_BODY: {
+    statusCode: number;
+    body: {
+        items: never[];
+    };
+};
+export declare const MOCK_RECORDING_BODY: {
+    statusCode: number;
+    body: Recording;
+};
+export declare const RECORDING_OWNER_ID = "8a67806f-fc4d-446b-a131-31e71ea5b0e9";
+export declare const RECORDING_REMOTE_PARTY_ID = "0fea4a63-4e27-46ee-99c3-2472cb12bf68";
+export declare const MOCK_RECORDING_METADATA: RecordingMetadata;
+export declare const MOCK_RECORDING_METADATA_BODY: {
+    statusCode: number;
+    body: RecordingMetadata;
+};
+export declare const ERROR_DETAILS_400: {
+    statusCode: number;
+    data: {
+        error: string;
+    };
+    message: string;
+};
+export declare const ERROR_DETAILS_401: {
+    statusCode: number;
+    data: {
+        error: string;
+    };
+    message: string;
+};
+export declare const ERROR_DETAILS_404: {
+    statusCode: number;
+    data: {
+        error: string;
+    };
+    message: string;
+};
+export declare const MOCK_RECORDING_CREATED_EVENT: RecordingEvent;
+export declare const MOCK_RECORDING_UPDATED_EVENT: RecordingEvent;
+export declare const MOCK_RECORDING_DELETED_EVENT: RecordingEvent;
+export declare const MOCK_RECORDING_TRASH_EVENT: RecordingEvent;
+export declare const MOCK_RECORDING_PURGE_EVENT: RecordingEvent;
+export declare const MOCK_RECORDING_RESTORE_EVENT: RecordingEvent;
+export declare const RECORDING_MERCURY_KEYS: {
+    CREATED: MOBIUS_EVENT_KEYS;
+    UPDATED: MOBIUS_EVENT_KEYS;
+    DELETED: MOBIUS_EVENT_KEYS;
+};
+//# sourceMappingURL=callRecordingFixtures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"callRecordingFixtures.d.ts","sourceRoot":"","sources":["../../../src/CallRecording/callRecordingFixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EAGjB,cAAc,EACf,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAC,SAAS,EAAE,iBAAiB,EAAkB,MAAM,SAAS,CAAC;AAEtE,eAAO,MAAM,eAAe,yCAAyC,CAAC;AAEtE,eAAO,MAAM,aAAa,EAAE,SAkB3B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,SAkB3B,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;CAKpC,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;;;CAK1C,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;CAG/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,yCAAyC,CAAC;AACzE,eAAO,MAAM,yBAAyB,yCAAyC,CAAC;AAEhF,eAAO,MAAM,uBAAuB,EAAE,iBAoCrC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;CAGxC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;CAM7B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;CAM7B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;CAM7B,CAAC;AAqBF,eAAO,MAAM,4BAA4B,EAAE,cAQ1C,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,cAS1C,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,cAQ1C,CAAC;AAIF,eAAO,MAAM,0BAA0B,EAAE,cASxC,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,cASxC,CAAC;AAGF,eAAO,MAAM,4BAA4B,EAAE,cAS1C,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;CAIlC,CAAC"}

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

@@ -0,0 +1,28 @@
+export declare const CALL_RECORDING_FILE = "CallRecording";
+export declare const CONVERGED_RECORDINGS = "convergedRecordings";
+export declare const METADATA = "metadata";
+export declare const FROM = "from";
+export declare const TO = "to";
+export declare const STATUS = "status";
+export declare const MAX = "max";
+export declare const SERVICE_TYPE = "serviceType";
+export declare const FORMAT = "format";
+export declare const OWNER_TYPE = "ownerType";
+export declare const STORAGE_REGION = "storageRegion";
+export declare const LOCATION_ID = "locationId";
+export declare const TOPIC = "topic";
+export declare const DEFAULT_STATUS = "available";
+export declare const DEFAULT_MAX = 30;
+export declare const DEFAULT_NUMBER_OF_DAYS = 30;
+export declare const WEBEX_USER_REQUEST_HEADER = "WebexUserRequest";
+export declare const RECORDING_NOT_FOUND_MESSAGE = "No recordings found for the given call session id.";
+export declare const METHODS: {
+    INITIALIZE_BACKEND_CONNECTOR: string;
+    GET_CALL_RECORDING: string;
+    GET_RECORDINGS: string;
+    GET_RECORDING: string;
+    GET_RECORDINGS_BY_CALL_SESSION_ID: string;
+    GET_RECORDING_METADATA: string;
+    DELETE_RECORDING: string;
+};
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/CallRecording/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,kBAAkB,CAAC;AAGnD,eAAO,MAAM,oBAAoB,wBAAwB,CAAC;AAC1D,eAAO,MAAM,QAAQ,aAAa,CAAC;AAGnC,eAAO,MAAM,IAAI,SAAS,CAAC;AAC3B,eAAO,MAAM,EAAE,OAAO,CAAC;AACvB,eAAO,MAAM,MAAM,WAAW,CAAC;AAC/B,eAAO,MAAM,GAAG,QAAQ,CAAC;AACzB,eAAO,MAAM,YAAY,gBAAgB,CAAC;AAC1C,eAAO,MAAM,MAAM,WAAW,CAAC;AAC/B,eAAO,MAAM,UAAU,cAAc,CAAC;AACtC,eAAO,MAAM,cAAc,kBAAkB,CAAC;AAC9C,eAAO,MAAM,WAAW,eAAe,CAAC;AACxC,eAAO,MAAM,KAAK,UAAU,CAAC;AAG7B,eAAO,MAAM,cAAc,cAAc,CAAC;AAC1C,eAAO,MAAM,WAAW,KAAK,CAAC;AAK9B,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAGzC,eAAO,MAAM,yBAAyB,qBAAqB,CAAC;AAE5D,eAAO,MAAM,2BAA2B,uDAAuD,CAAC;AAGhG,eAAO,MAAM,OAAO;;;;;;;;CAQnB,CAAC"}