@webex/calling 3.12.0-task-refactor.1 → 3.12.0-webex-services-ready.1

package/dist/CallRecording/WxcCallRecordingConnector.js

@@ -0,0 +1,577 @@
+"use strict";
+
+var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+var _Object$keys = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WxcCallRecordingConnector = void 0;
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _SDKConnector = _interopRequireDefault(require("../SDKConnector"));
+var _types = require("../common/types");
+var _Logger = _interopRequireDefault(require("../Logger"));
+var _Utils = require("../common/Utils");
+var _constants = require("../common/constants");
+var _types2 = require("../Events/types");
+var _impl = require("../Events/impl");
+var _types3 = require("./types");
+var _constants2 = require("./constants");
+function ownKeys(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); } /* eslint-disable dot-notation */ /* eslint-disable no-underscore-dangle */
+/**
+ * Webex Calling (WXC) backend connector for Post Call Recording.
+ *
+ * Owns everything backend-specific for the Webex Calling cloud `convergedRecordings` capability:
+ * resolving the hydra developer API base URL from the u2c catalog, the REST read/delete calls, and
+ * subscribing to the `convergedRecordings.*` Mercury events (re-emitting them as typed
+ * `callRecording:*` events). The {@link CallRecording} facade selects this connector when the
+ * resolved calling backend is WXC.
+ */
+var WxcCallRecordingConnector = exports.WxcCallRecordingConnector = /*#__PURE__*/function (_Eventing) {
+  /**
+   * @param webex - `Webex SDK` instance.
+   * @param logger - Logger interface used to set the log level for the module.
+   */
+  function WxcCallRecordingConnector(webex, logger) {
+    var _this$webex$internal$, _this$webex$internal$2;
+    var _this;
+    (0, _classCallCheck2.default)(this, WxcCallRecordingConnector);
+    _this = _callSuper(this, WxcCallRecordingConnector);
+    (0, _defineProperty2.default)(_this, "sdkConnector", void 0);
+    (0, _defineProperty2.default)(_this, "webex", void 0);
+    (0, _defineProperty2.default)(_this, "recordingServiceUrl", void 0);
+    // `event` is optional because SDKConnector.registerListener invokes callbacks as `(data?: T)`.
+    // `data` uses optional chaining at runtime because malformed Mercury payloads may omit it.
+    (0, _defineProperty2.default)(_this, "handleRecordingCreatedEvent", /*#__PURE__*/function () {
+      var _ref = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(event) {
+        var _event$data;
+        return _regenerator.default.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (event !== null && event !== void 0 && (_event$data = event.data) !== null && _event$data !== void 0 && _event$data.activity) {
+                _context.next = 1;
+                break;
+              }
+              return _context.abrupt("return");
+            case 1:
+              _this.emit(_types2.COMMON_EVENT_KEYS.CALL_RECORDING_CREATED, event);
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+    /**
+     * The backend expresses the full recording lifecycle through `convergedRecordings.updated` events
+     * qualified by an `eventSubType` (rather than dedicated created/deleted events):
+     * - `TRASH` (soft delete) / `PURGE` (permanent delete) -> surfaced as `callRecording:deleted`
+     *   so consumers can drop the recording from the active list.
+     * - `RESTORE` (restored from trash) -> surfaced as `callRecording:created` so it is re-added.
+     * - `SUMMARY_CREATE` (AI summary/transcript ready) and anything else -> `callRecording:updated`.
+     *
+     * The full event (including `data.eventSubType`) is always forwarded, so consumers that need to
+     * distinguish a soft delete from a permanent purge can still inspect it.
+     */
+    (0, _defineProperty2.default)(_this, "handleRecordingUpdatedEvent", /*#__PURE__*/function () {
+      var _ref2 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2(event) {
+        var _event$data2;
+        var _t;
+        return _regenerator.default.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (event !== null && event !== void 0 && (_event$data2 = event.data) !== null && _event$data2 !== void 0 && _event$data2.activity) {
+                _context2.next = 1;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 1:
+              _t = event.data.eventSubType;
+              _context2.next = _t === _types2.RECORDING_EVENT_SUBTYPE.TRASH ? 2 : _t === _types2.RECORDING_EVENT_SUBTYPE.PURGE ? 2 : _t === _types2.RECORDING_EVENT_SUBTYPE.RESTORE ? 3 : 4;
+              break;
+            case 2:
+              _this.emit(_types2.COMMON_EVENT_KEYS.CALL_RECORDING_DELETED, event);
+              return _context2.abrupt("continue", 5);
+            case 3:
+              _this.emit(_types2.COMMON_EVENT_KEYS.CALL_RECORDING_CREATED, event);
+              return _context2.abrupt("continue", 5);
+            case 4:
+              _this.emit(_types2.COMMON_EVENT_KEYS.CALL_RECORDING_UPDATED, event);
+            case 5:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      return function (_x2) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
+    (0, _defineProperty2.default)(_this, "handleRecordingDeletedEvent", /*#__PURE__*/function () {
+      var _ref3 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3(event) {
+        var _event$data3;
+        return _regenerator.default.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              if (event !== null && event !== void 0 && (_event$data3 = event.data) !== null && _event$data3 !== void 0 && _event$data3.activity) {
+                _context3.next = 1;
+                break;
+              }
+              return _context3.abrupt("return");
+            case 1:
+              _this.emit(_types2.COMMON_EVENT_KEYS.CALL_RECORDING_DELETED, event);
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      return function (_x3) {
+        return _ref3.apply(this, arguments);
+      };
+    }());
+    _this.sdkConnector = _SDKConnector.default;
+    if (!_this.sdkConnector.getWebex()) {
+      _SDKConnector.default.setWebex(webex);
+    }
+    _this.webex = _this.sdkConnector.getWebex();
+
+    // Resolve the Post Call Recording base URL (hydra developer API) directly from the u2c
+    // service catalog. The catalog is populated by the host SDK's service discovery, so no
+    // dedicated recording plugin is required.
+    _this.recordingServiceUrl = ((_this$webex$internal$ = _this.webex.internal.services._serviceUrls) === null || _this$webex$internal$ === void 0 ? void 0 : _this$webex$internal$.hydraDeveloperApi) || _this.webex.internal.services.get((_this$webex$internal$2 = _this.webex.internal.services._activeServices) === null || _this$webex$internal$2 === void 0 ? void 0 : _this$webex$internal$2.hydraDeveloperApi);
+    _this.registerRecordingListeners();
+    _Logger.default.setLogger(logger.level, _constants2.CALL_RECORDING_FILE);
+    return _this;
+  }
+
+  /**
+   * Builds the `convergedRecordings` collection URL with the list query parameters.
+   *
+   * The converged recordings API only returns results when the request is bounded by BOTH a
+   * `from` and a `to` timestamp, so this method always sends both (a `from`-only request comes
+   * back empty). When the caller does not supply an explicit `from`, it is derived from the
+   * `days` lookback (`now - days`, default {@link DEFAULT_NUMBER_OF_DAYS}); when `to` is omitted
+   * it defaults to the current time (`now`). `status` and `max` default to `available` and `30`.
+   * The remaining filters (`serviceType`, `format`, `ownerType`, `storageRegion`, `locationId`,
+   * `topic`) are pass-through and only appended when the caller provides them.
+   *
+   * @param options - Optional time window/filtering/pagination from {@link GetRecordingsOptions}.
+   * @returns The fully-qualified request URL.
+   */
+  (0, _inherits2.default)(WxcCallRecordingConnector, _Eventing);
+  return (0, _createClass2.default)(WxcCallRecordingConnector, [{
+    key: "buildRecordingsUrl",
+    value: function buildRecordingsUrl(options) {
+      var _options$to, _options$status, _options$max;
+      var params = new URLSearchParams();
+      var fromDate = options === null || options === void 0 ? void 0 : options.from;
+      if (!fromDate) {
+        var _options$days;
+        var date = new Date();
+        date.setDate(date.getDate() - ((_options$days = options === null || options === void 0 ? void 0 : options.days) !== null && _options$days !== void 0 ? _options$days : _constants2.DEFAULT_NUMBER_OF_DAYS));
+        fromDate = date.toISOString();
+      }
+      var toDate = (_options$to = options === null || options === void 0 ? void 0 : options.to) !== null && _options$to !== void 0 ? _options$to : new Date().toISOString();
+      params.append(_constants2.FROM, fromDate);
+      params.append(_constants2.TO, toDate);
+      params.append(_constants2.STATUS, (_options$status = options === null || options === void 0 ? void 0 : options.status) !== null && _options$status !== void 0 ? _options$status : _constants2.DEFAULT_STATUS);
+      params.append(_constants2.MAX, "".concat((_options$max = options === null || options === void 0 ? void 0 : options.max) !== null && _options$max !== void 0 ? _options$max : _constants2.DEFAULT_MAX));
+
+      // Optional pass-through filters: only sent when the caller provides them so the API can apply
+      // its own defaults for any that are omitted.
+      var optionalParams = [[_constants2.SERVICE_TYPE, options === null || options === void 0 ? void 0 : options.serviceType], [_constants2.FORMAT, options === null || options === void 0 ? void 0 : options.format], [_constants2.OWNER_TYPE, options === null || options === void 0 ? void 0 : options.ownerType], [_constants2.STORAGE_REGION, options === null || options === void 0 ? void 0 : options.storageRegion], [_constants2.LOCATION_ID, options === null || options === void 0 ? void 0 : options.locationId], [_constants2.TOPIC, options === null || options === void 0 ? void 0 : options.topic]];
+      optionalParams.forEach(function (_ref4) {
+        var _ref5 = (0, _slicedToArray2.default)(_ref4, 2),
+          key = _ref5[0],
+          value = _ref5[1];
+        if (value) {
+          params.append(key, value);
+        }
+      });
+      return "".concat(this.recordingServiceUrl, "/").concat(_constants2.CONVERGED_RECORDINGS, "?").concat(params.toString());
+    }
+
+    /**
+     * Reads Post Call Recordings, dispatching to the matching operation based on the request `type`.
+     * The concrete response type is inferred per request via {@link RecordingResponseFor}.
+     *
+     * @param request - The discriminated read request.
+     */
+  }, {
+    key: "getCallRecording",
+    value: function getCallRecording(request) {
+      return this.dispatchGetCallRecording(request);
+    }
+
+    /**
+     * Internal dispatcher for {@link getCallRecording}. Routes the discriminated request to the
+     * backend-specific read method. Kept separate from the public generic signature so the switch
+     * runs against a concrete union (with exhaustiveness checking) and the conditional return type is
+     * narrowed in exactly one place.
+     *
+     * @param request - The discriminated read request.
+     */
+  }, {
+    key: "dispatchGetCallRecording",
+    value: function dispatchGetCallRecording(request) {
+      switch (request.type) {
+        case _types3.RecordingRequestType.LIST:
+          return this.getRecordings(request.options);
+        case _types3.RecordingRequestType.DETAIL:
+          return this.getRecording(request.recordingId);
+        case _types3.RecordingRequestType.METADATA:
+          return this.getRecordingMetadata(request.recordingId);
+        case _types3.RecordingRequestType.BY_CALL_SESSION:
+          return this.getRecordingsByCallSessionId(request.callSessionId, request.options);
+        default:
+          {
+            var exhaustiveCheck = request;
+            throw new Error("Unsupported recording request type: ".concat((0, _stringify.default)(exhaustiveCheck)));
+          }
+      }
+    }
+
+    /**
+     * Fetches the converged recordings for the current user.
+     * @param options - Optional filters and pagination parameters.
+     */
+  }, {
+    key: "getRecordings",
+    value: (function () {
+      var _getRecordings = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4(options) {
+        var loggerContext, _response$headers, _response$body, _body$items, _responseDetails$data, _responseDetails$data2, url, response, body, responseDetails, errorInfo, _t2;
+        return _regenerator.default.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CALL_RECORDING_FILE,
+                method: _constants2.METHODS.GET_RECORDINGS
+              };
+              _Logger.default.info("".concat(_constants.METHOD_START_MESSAGE, " with options=").concat((0, _stringify.default)(options !== null && options !== void 0 ? options : {})), loggerContext);
+              _context4.prev = 1;
+              url = this.buildRecordingsUrl(options);
+              _context4.next = 2;
+              return this.webex.request(_objectSpread({
+                uri: url,
+                method: _types.HTTP_METHODS.GET,
+                service: _types.ALLOWED_SERVICES.HYDRA_DEVELOPER_API
+              }, options !== null && options !== void 0 && options.webexUserRequest ? {
+                headers: (0, _defineProperty2.default)({}, _constants2.WEBEX_USER_REQUEST_HEADER, 'true')
+              } : {}));
+            case 2:
+              response = _context4.sent;
+              _Logger.default.log("Response trackingId: ".concat(response === null || response === void 0 ? void 0 : (_response$headers = response.headers) === null || _response$headers === void 0 ? void 0 : _response$headers.trackingid), loggerContext);
+              body = (_response$body = response.body) !== null && _response$body !== void 0 ? _response$body : {};
+              responseDetails = {
+                statusCode: Number(response.statusCode) || _constants.SUCCESS_STATUS_CODE,
+                data: {
+                  recordings: (_body$items = body.items) !== null && _body$items !== void 0 ? _body$items : []
+                },
+                message: _constants.SUCCESS_MESSAGE
+              };
+              _Logger.default.log("Successfully retrieved ".concat((_responseDetails$data = (_responseDetails$data2 = responseDetails.data.recordings) === null || _responseDetails$data2 === void 0 ? void 0 : _responseDetails$data2.length) !== null && _responseDetails$data !== void 0 ? _responseDetails$data : 0, " recordings"), loggerContext);
+              return _context4.abrupt("return", responseDetails);
+            case 3:
+              _context4.prev = 3;
+              _t2 = _context4["catch"](1);
+              _Logger.default.error("Failed to get recordings: ".concat((0, _stringify.default)(_t2)), loggerContext);
+              _context4.next = 4;
+              return (0, _Utils.uploadLogs)();
+            case 4:
+              errorInfo = _t2;
+              return _context4.abrupt("return", (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext));
+            case 5:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this, [[1, 3]]);
+      }));
+      function getRecordings(_x4) {
+        return _getRecordings.apply(this, arguments);
+      }
+      return getRecordings;
+    }()
+    /**
+     * Fetches a single converged recording by its id.
+     * @param recordingId - The recording id (`id`).
+     */
+    )
+  }, {
+    key: "getRecording",
+    value: (function () {
+      var _getRecording = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(recordingId) {
+        var loggerContext, _response$headers2, url, response, responseDetails, errorInfo, _t3;
+        return _regenerator.default.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CALL_RECORDING_FILE,
+                method: _constants2.METHODS.GET_RECORDING
+              };
+              _Logger.default.info("".concat(_constants.METHOD_START_MESSAGE, " with recordingId=").concat(recordingId), loggerContext);
+              _context5.prev = 1;
+              url = "".concat(this.recordingServiceUrl, "/").concat(_constants2.CONVERGED_RECORDINGS, "/").concat(recordingId);
+              _context5.next = 2;
+              return this.webex.request({
+                uri: url,
+                method: _types.HTTP_METHODS.GET,
+                service: _types.ALLOWED_SERVICES.HYDRA_DEVELOPER_API
+              });
+            case 2:
+              response = _context5.sent;
+              _Logger.default.log("Response trackingId: ".concat(response === null || response === void 0 ? void 0 : (_response$headers2 = response.headers) === null || _response$headers2 === void 0 ? void 0 : _response$headers2.trackingid), loggerContext);
+              responseDetails = {
+                statusCode: Number(response.statusCode) || _constants.SUCCESS_STATUS_CODE,
+                data: {
+                  recording: response.body
+                },
+                message: _constants.SUCCESS_MESSAGE
+              };
+              _Logger.default.log("Successfully retrieved recording ".concat(recordingId), loggerContext);
+              return _context5.abrupt("return", responseDetails);
+            case 3:
+              _context5.prev = 3;
+              _t3 = _context5["catch"](1);
+              _Logger.default.error("Failed to get recording: ".concat((0, _stringify.default)(_t3)), loggerContext);
+              _context5.next = 4;
+              return (0, _Utils.uploadLogs)();
+            case 4:
+              errorInfo = _t3;
+              return _context5.abrupt("return", (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext));
+            case 5:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this, [[1, 3]]);
+      }));
+      function getRecording(_x5) {
+        return _getRecording.apply(this, arguments);
+      }
+      return getRecording;
+    }()
+    /**
+     * Returns all recordings linked to a given call session id.
+     *
+     * Note (documented API gap): the recording API does not expose a confirmed server-side query parameter
+     * to filter by call session id, so a list is fetched and filtered client-side on
+     * `serviceData.callSessionId`. The scan is bounded by the list query, so `options` is forwarded
+     * to {@link getRecordings} to let callers widen the time window/status/page when the target
+     * session may fall outside the defaults.
+     *
+     * @param callSessionId - The call session id to filter by.
+     * @param options - Optional list query forwarded to {@link getRecordings} to control the
+     *   set of recordings scanned before filtering.
+     */
+    )
+  }, {
+    key: "getRecordingsByCallSessionId",
+    value: (function () {
+      var _getRecordingsByCallSessionId = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6(callSessionId, options) {
+        var _listResponse$data$re;
+        var loggerContext, listResponse, filtered;
+        return _regenerator.default.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CALL_RECORDING_FILE,
+                method: _constants2.METHODS.GET_RECORDINGS_BY_CALL_SESSION_ID
+              };
+              _Logger.default.info("".concat(_constants.METHOD_START_MESSAGE, " with callSessionId=").concat(callSessionId), loggerContext);
+              _context6.next = 1;
+              return this.getRecordings(options);
+            case 1:
+              listResponse = _context6.sent;
+              if (!(listResponse.statusCode !== _constants.SUCCESS_STATUS_CODE)) {
+                _context6.next = 2;
+                break;
+              }
+              return _context6.abrupt("return", listResponse);
+            case 2:
+              filtered = ((_listResponse$data$re = listResponse.data.recordings) !== null && _listResponse$data$re !== void 0 ? _listResponse$data$re : []).filter(function (recording) {
+                var _recording$serviceDat;
+                return ((_recording$serviceDat = recording.serviceData) === null || _recording$serviceDat === void 0 ? void 0 : _recording$serviceDat.callSessionId) === callSessionId;
+              });
+              if (filtered.length === 0) {
+                _Logger.default.info(_constants2.RECORDING_NOT_FOUND_MESSAGE, loggerContext);
+              } else {
+                _Logger.default.log("Successfully retrieved ".concat(filtered.length, " recordings for call session ").concat(callSessionId), loggerContext);
+              }
+              return _context6.abrupt("return", {
+                statusCode: _constants.SUCCESS_STATUS_CODE,
+                data: {
+                  recordings: filtered
+                },
+                message: _constants.SUCCESS_MESSAGE
+              });
+            case 3:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function getRecordingsByCallSessionId(_x6, _x7) {
+        return _getRecordingsByCallSessionId.apply(this, arguments);
+      }
+      return getRecordingsByCallSessionId;
+    }()
+    /**
+     * Fetches the metadata for a single recording.
+     * @param recordingId - The recording id (`id`).
+     */
+    )
+  }, {
+    key: "getRecordingMetadata",
+    value: (function () {
+      var _getRecordingMetadata = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7(recordingId) {
+        var loggerContext, _response$headers3, url, response, responseDetails, errorInfo, _t4;
+        return _regenerator.default.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CALL_RECORDING_FILE,
+                method: _constants2.METHODS.GET_RECORDING_METADATA
+              };
+              _Logger.default.info("".concat(_constants.METHOD_START_MESSAGE, " with recordingId=").concat(recordingId), loggerContext);
+              _context7.prev = 1;
+              url = "".concat(this.recordingServiceUrl, "/").concat(_constants2.CONVERGED_RECORDINGS, "/").concat(recordingId, "/").concat(_constants2.METADATA);
+              _context7.next = 2;
+              return this.webex.request({
+                uri: url,
+                method: _types.HTTP_METHODS.GET,
+                service: _types.ALLOWED_SERVICES.HYDRA_DEVELOPER_API
+              });
+            case 2:
+              response = _context7.sent;
+              _Logger.default.log("Response trackingId: ".concat(response === null || response === void 0 ? void 0 : (_response$headers3 = response.headers) === null || _response$headers3 === void 0 ? void 0 : _response$headers3.trackingid), loggerContext);
+              responseDetails = {
+                statusCode: Number(response.statusCode) || _constants.SUCCESS_STATUS_CODE,
+                data: {
+                  metadata: response.body
+                },
+                message: _constants.SUCCESS_MESSAGE
+              };
+              _Logger.default.log("Successfully retrieved metadata for recording ".concat(recordingId), loggerContext);
+              return _context7.abrupt("return", responseDetails);
+            case 3:
+              _context7.prev = 3;
+              _t4 = _context7["catch"](1);
+              _Logger.default.error("Failed to get recording metadata: ".concat((0, _stringify.default)(_t4)), loggerContext);
+              _context7.next = 4;
+              return (0, _Utils.uploadLogs)();
+            case 4:
+              errorInfo = _t4;
+              return _context7.abrupt("return", (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext));
+            case 5:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this, [[1, 3]]);
+      }));
+      function getRecordingMetadata(_x8) {
+        return _getRecordingMetadata.apply(this, arguments);
+      }
+      return getRecordingMetadata;
+    }()
+    /**
+     * Moves a recording to the recycle bin (soft delete). Matches native Webex user delete:
+     * `POST /convergedRecordings/softDelete` with `recordingIds: [recordingId]`.
+     * Requires `spark:recordings_write` on the access token.
+     *
+     * Mercury emits `convergedRecordings.updated` + `eventSubType: TRASH`, which this connector
+     * surfaces as `callRecording:deleted`.
+     *
+     * @param recordingId - The recording id (`id`) to move to the recycle bin.
+     * @param _options - Deprecated. Ignored. Compliance permanent delete uses a separate API.
+     */
+    )
+  }, {
+    key: "deleteRecording",
+    value: (function () {
+      var _deleteRecording = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8(recordingId,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- kept for ICallRecording signature parity; soft delete ignores options
+      _options) {
+        var loggerContext, _response$headers4, url, response, responseDetails, errorInfo, _t5;
+        return _regenerator.default.wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CALL_RECORDING_FILE,
+                method: _constants2.METHODS.DELETE_RECORDING
+              };
+              _Logger.default.info("".concat(_constants.METHOD_START_MESSAGE, " with recordingId=").concat(recordingId), loggerContext);
+              _context8.prev = 1;
+              url = "".concat(this.recordingServiceUrl, "/").concat(_constants2.CONVERGED_RECORDINGS, "/").concat(_constants2.SOFT_DELETE);
+              _context8.next = 2;
+              return this.webex.request({
+                uri: url,
+                method: _types.HTTP_METHODS.POST,
+                service: _types.ALLOWED_SERVICES.HYDRA_DEVELOPER_API,
+                body: {
+                  recordingIds: [recordingId]
+                }
+              });
+            case 2:
+              response = _context8.sent;
+              _Logger.default.log("Response trackingId: ".concat(response === null || response === void 0 ? void 0 : (_response$headers4 = response.headers) === null || _response$headers4 === void 0 ? void 0 : _response$headers4.trackingid), loggerContext);
+              responseDetails = {
+                statusCode: Number(response.statusCode) || _constants.SUCCESS_STATUS_CODE,
+                data: {},
+                message: _constants.SUCCESS_MESSAGE
+              };
+              _Logger.default.log("Successfully moved recording ".concat(recordingId, " to recycle bin"), loggerContext);
+              return _context8.abrupt("return", responseDetails);
+            case 3:
+              _context8.prev = 3;
+              _t5 = _context8["catch"](1);
+              _Logger.default.error("Failed to delete recording: ".concat((0, _stringify.default)(_t5)), loggerContext);
+              _context8.next = 4;
+              return (0, _Utils.uploadLogs)();
+            case 4:
+              errorInfo = _t5;
+              return _context8.abrupt("return", (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext));
+            case 5:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this, [[1, 3]]);
+      }));
+      function deleteRecording(_x9, _x0) {
+        return _deleteRecording.apply(this, arguments);
+      }
+      return deleteRecording;
+    }())
+  }, {
+    key: "registerRecordingListeners",
+    value:
+    /**
+     * Subscribes to the recording Mercury events and re-emits them as typed client events.
+     */
+    function registerRecordingListeners() {
+      this.sdkConnector.registerListener(_types2.MOBIUS_EVENT_KEYS.RECORDING_EVENT_CREATED, this.handleRecordingCreatedEvent);
+      this.sdkConnector.registerListener(_types2.MOBIUS_EVENT_KEYS.RECORDING_EVENT_UPDATED, this.handleRecordingUpdatedEvent);
+      this.sdkConnector.registerListener(_types2.MOBIUS_EVENT_KEYS.RECORDING_EVENT_DELETED, this.handleRecordingDeletedEvent);
+    }
+  }]);
+}(_impl.Eventing);
+//# sourceMappingURL=WxcCallRecordingConnector.js.map