rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.20220317

package/dist/_esm5.processed/core/{eme → decrypt}/__tests__/__global__/utils.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 /// <reference types="jest" />
-import { Observable, Subject } from "rxjs";
+import { Subject } from "rxjs";
 import { IEncryptedEventData } from "../../../../compat/eme";
 import EventEmitter from "../../../../utils/event_emitter";
 /** Default MediaKeySystemAccess configuration used by the RxPlayer. */
@@ -97,7 +97,7 @@ export declare class MediaKeySystemAccessImpl {
     createMediaKeys(): Promise<MediaKeysImpl>;
     getConfiguration(): MediaKeySystemConfiguration[];
 }
-export declare function requestMediaKeySystemAccessImpl(keySystem: string, config: MediaKeySystemConfiguration[]): Observable<MediaKeySystemAccessImpl>;
+export declare function requestMediaKeySystemAccessImpl(keySystem: string, config: MediaKeySystemConfiguration[]): Promise<MediaKeySystemAccessImpl>;
 /**
  * Mock functions coming from the compat directory.
  */
@@ -109,15 +109,13 @@ export declare function mockCompat(exportedFunctions?: {}): {
         triggerKeyError: Subject<unknown>;
         triggerKeyStatusesChange: Subject<unknown>;
     };
-    requestMediaKeySystemAccessSpy: jest.Mock<Observable<MediaKeySystemAccessImpl>, [keySystem: string, config: MediaKeySystemConfiguration[]]>;
+    requestMediaKeySystemAccessSpy: jest.Mock<Promise<MediaKeySystemAccessImpl>, [keySystem: string, config: MediaKeySystemConfiguration[]]>;
     getInitDataSpy: jest.Mock<IEncryptedEventData, [encryptedEvent: IEncryptedEventData]>;
-    setMediaKeysSpy: jest.Mock<Observable<null>, []>;
-    generateKeyRequestSpy: jest.Mock<Observable<void>, [mks: MediaKeySessionImpl, initializationDataType: any, initializationData: any]>;
+    setMediaKeysSpy: jest.Mock<any, any>;
+    generateKeyRequestSpy: jest.Mock<Promise<void>, [mks: MediaKeySessionImpl, initializationDataType: any, initializationData: any]>;
 };
 /**
- * Check that the EMEManager, when called with those arguments, throws
- * directly without any event emitted.
- *
+ * Check that the ContentDecryptor, when called with those arguments, throws.
  * If that's the case, resolve with the corresponding error.
  * Else, reject.
  * @param {HTMLMediaElement} mediaElement
@@ -125,47 +123,7 @@ export declare function mockCompat(exportedFunctions?: {}): {
  * @param {Observable} contentProtections$
  * @returns {Promise}
  */
-export declare function testEMEManagerImmediateError(EMEManager: any, mediaElement: HTMLMediaElement, keySystemsConfigs: unknown[], contentProtections$: Observable<unknown>): Promise<unknown>;
-/**
- * Check that the event received corresponds to the session-message event for a
- * license request.
- * @param {Object} evt
- * @param {Object} initDataVal
- */
-export declare function expectLicenseRequestMessage(evt: {
-    type: string;
-    value: any;
-}, initDataVal: {
-    type: string | undefined;
-    values: Array<{
-        systemId: string | unknown;
-        data: Uint8Array;
-    }>;
-}): void;
-/**
- * @param {Object} evt
- * @param {Uint8Array} initData
- * @param {string|undefined} initDataType
- */
-export declare function expectInitDataIgnored(evt: {
-    type: string;
-    value: any;
-}, initDataVal: {
-    type: string | undefined;
-    values: Array<{
-        systemId: string | undefined;
-        data: Uint8Array;
-    }>;
-}): void;
-/**
- * @param {Object} evt
- * @param {Uint8Array} initData
- * @param {string|undefined} initDataType
- */
-export declare function expectEncryptedEventReceived(evt: {
-    type: string;
-    value: any;
-}, initData: IEncryptedEventData): void;
+export declare function testContentDecryptorError(ContentDecryptor: any, mediaElement: HTMLMediaElement, keySystemsConfigs: unknown[]): Promise<unknown>;
 /**
  * Does the reverse operation than what `formatFakeChallengeFromInitData` does:
  * Retrieve initialization data from a fake challenge done in our tests

package/dist/_esm5.processed/core/{eme → decrypt}/__tests__/__global__/utils.js

@@ -46,10 +46,12 @@ var __assign = (this && this.__assign) || function () {
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 /* eslint-disable no-restricted-properties */
-import { defer as observableDefer, of as observableOf, Subject, } from "rxjs";
+import { Subject } from "rxjs";
 import { base64ToBytes, bytesToBase64, } from "../../../../utils/base64";
-import castToObservable from "../../../../utils/cast_to_observable";
 import EventEmitter, { fromEvent } from "../../../../utils/event_emitter";
 import flatMap from "../../../../utils/flat_map";
 import { strToUtf8, utf8ToStr, } from "../../../../utils/string_parsing";
@@ -155,13 +157,16 @@ var MediaKeySessionImpl = /** @class */ (function (_super) {
         return Promise.resolve();
     };
     MediaKeySessionImpl.prototype.generateRequest = function (initDataType, initData) {
+        var _this = this;
         var msg = formatFakeChallengeFromInitData(initData, initDataType);
-        var event = Object.assign(new CustomEvent("message"), { message: msg.buffer,
-            messageType: "license-request" });
-        this.trigger("message", event);
-        if (this.onmessage !== null && this.onmessage !== undefined) {
-            this.onmessage(event);
-        }
+        setTimeout(function () {
+            var event = Object.assign(new CustomEvent("message"), { message: msg.buffer,
+                messageType: "license-request" });
+            _this.trigger("message", event);
+            if (_this.onmessage !== null && _this.onmessage !== undefined) {
+                _this.onmessage(event);
+            }
+        }, 5);
         return Promise.resolve();
     };
     MediaKeySessionImpl.prototype.load = function (_sessionId) {
@@ -220,7 +225,7 @@ var MediaKeySystemAccessImpl = /** @class */ (function () {
 }());
 export { MediaKeySystemAccessImpl };
 export function requestMediaKeySystemAccessImpl(keySystem, config) {
-    return observableOf(new MediaKeySystemAccessImpl(keySystem, config));
+    return Promise.resolve(new MediaKeySystemAccessImpl(keySystem, config));
 }
 /**
  * Mock functions coming from the compat directory.
@@ -245,11 +250,9 @@ export function mockCompat(exportedFunctions) {
         }),
     };
     var rmksaSpy = jest.fn(requestMediaKeySystemAccessImpl);
-    var setMediaKeysSpy = jest.fn(function () { return observableOf(null); });
+    var setMediaKeysSpy = jest.fn();
     var generateKeyRequestSpy = jest.fn(function (mks, initializationDataType, initializationData) {
-        return observableDefer(function () {
-            return castToObservable(mks.generateRequest(initializationDataType, initializationData));
-        });
+        return mks.generateRequest(initializationDataType, initializationData);
     });
     var getInitDataSpy = jest.fn(function (encryptedEvent) {
         return encryptedEvent;
@@ -259,9 +262,7 @@ export function mockCompat(exportedFunctions) {
         requestMediaKeySystemAccessSpy: rmksaSpy, getInitDataSpy: getInitDataSpy, setMediaKeysSpy: setMediaKeysSpy, generateKeyRequestSpy: generateKeyRequestSpy };
 }
 /**
- * Check that the EMEManager, when called with those arguments, throws
- * directly without any event emitted.
- *
+ * Check that the ContentDecryptor, when called with those arguments, throws.
  * If that's the case, resolve with the corresponding error.
  * Else, reject.
  * @param {HTMLMediaElement} mediaElement
@@ -269,58 +270,17 @@ export function mockCompat(exportedFunctions) {
  * @param {Observable} contentProtections$
  * @returns {Promise}
  */
-export function testEMEManagerImmediateError(
-/* eslint-disable @typescript-eslint/naming-convention */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-EMEManager, 
-/* eslint-enable @typescript-eslint/no-explicit-any */
-/* eslint-enable @typescript-eslint/naming-convention */
-mediaElement, keySystemsConfigs, contentProtections$) {
+export function testContentDecryptorError(ContentDecryptor, mediaElement, keySystemsConfigs) {
     return new Promise(function (res, rej) {
-        EMEManager(mediaElement, keySystemsConfigs, contentProtections$)
-            .subscribe(function (evt) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            var eventStr = JSON.stringify(evt);
-            rej(new Error("Received an EMEManager event: " + eventStr));
-        }, function (err) { res(err); }, function () { return rej(new Error("EMEManager completed.")); });
+        var contentDecryptor = new ContentDecryptor(mediaElement, keySystemsConfigs);
+        contentDecryptor.addEventListener("error", function (error) {
+            res(error);
+        });
+        setTimeout(function () {
+            rej(new Error("Timeout exceeded"));
+        }, 10);
     });
 }
-/**
- * Check that the event received corresponds to the session-message event for a
- * license request.
- * @param {Object} evt
- * @param {Object} initDataVal
- */
-export function expectLicenseRequestMessage(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-evt, initDataVal) {
-    expect(evt.type).toEqual("session-message");
-    expect(evt.value.messageType).toEqual("license-request");
-    expect(evt.value.initializationData).toEqual(initDataVal);
-}
-/**
- * @param {Object} evt
- * @param {Uint8Array} initData
- * @param {string|undefined} initDataType
- */
-export function expectInitDataIgnored(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-evt, initDataVal) {
-    expect(evt.type).toEqual("init-data-ignored");
-    expect(evt.value.initializationData).toEqual(initDataVal);
-}
-/**
- * @param {Object} evt
- * @param {Uint8Array} initData
- * @param {string|undefined} initDataType
- */
-export function expectEncryptedEventReceived(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-evt, initData) {
-    expect(evt.type).toEqual("encrypted-event-received");
-    expect(evt.value).toEqual(initData);
-}
 /**
  * Does the reverse operation than what `formatFakeChallengeFromInitData` does:
  * Retrieve initialization data from a fake challenge done in our tests

package/dist/_esm5.processed/core/{eme → decrypt}/attach_media_keys.d.ts

@@ -13,16 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import { ICustomMediaKeys, ICustomMediaKeySystemAccess } from "../../compat";
+import { CancellationSignal } from "../../utils/task_canceller";
 import { IKeySystemOption } from "./types";
 import LoadedSessionsStore from "./utils/loaded_sessions_store";
 /**
- * Dispose the media keys on media element.
+ * Dispose of the MediaKeys instance attached to the given media element, if
+ * one.
  * @param {Object} mediaElement
+ */
+export declare function disableMediaKeys(mediaElement: HTMLMediaElement): void;
+/**
+ * Attach MediaKeys and its associated state to an HTMLMediaElement.
+ *
+ * /!\ Mutates heavily MediaKeysInfosStore
+ * @param {Object} mediaKeysInfos
+ * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-export declare function disableMediaKeys(mediaElement: HTMLMediaElement): Observable<unknown>;
+export default function attachMediaKeys(mediaElement: HTMLMediaElement, { keySystemOptions, loadedSessionsStore, mediaKeySystemAccess, mediaKeys }: IMediaKeysState, cancelSignal: CancellationSignal): Promise<void>;
 /** MediaKeys and associated state attached to a media element. */
 export interface IMediaKeysState {
     /** Options set when the MediaKeys has been attached. */
@@ -34,12 +43,3 @@ export interface IMediaKeysState {
     /** The MediaKeys instance to attach to the media element. */
     mediaKeys: MediaKeys | ICustomMediaKeys;
 }
-/**
- * Attach MediaKeys and its associated state to an HTMLMediaElement.
- *
- * /!\ Mutates heavily MediaKeysInfosStore
- * @param {Object} mediaKeysInfos
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-export default function attachMediaKeys(mediaElement: HTMLMediaElement, { keySystemOptions, loadedSessionsStore, mediaKeySystemAccess, mediaKeys }: IMediaKeysState): Observable<unknown>;

package/dist/_esm5.processed/core/decrypt/attach_media_keys.js

@@ -0,0 +1,104 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { setMediaKeys, } from "../../compat";
+import log from "../../log";
+import PPromise from "../../utils/promise";
+import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+/**
+ * Dispose of the MediaKeys instance attached to the given media element, if
+ * one.
+ * @param {Object} mediaElement
+ */
+export function disableMediaKeys(mediaElement) {
+    MediaKeysInfosStore.setState(mediaElement, null);
+    setMediaKeys(mediaElement, null);
+}
+/**
+ * Attach MediaKeys and its associated state to an HTMLMediaElement.
+ *
+ * /!\ Mutates heavily MediaKeysInfosStore
+ * @param {Object} mediaKeysInfos
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+export default function attachMediaKeys(mediaElement, _a, cancelSignal) {
+    var keySystemOptions = _a.keySystemOptions, loadedSessionsStore = _a.loadedSessionsStore, mediaKeySystemAccess = _a.mediaKeySystemAccess, mediaKeys = _a.mediaKeys;
+    return __awaiter(this, void 0, void 0, function () {
+        var previousState, closeAllSessions;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    previousState = MediaKeysInfosStore.getState(mediaElement);
+                    closeAllSessions = previousState !== null &&
+                        previousState.loadedSessionsStore !== loadedSessionsStore ?
+                        previousState.loadedSessionsStore.closeAllSessions() :
+                        PPromise.resolve();
+                    return [4 /*yield*/, closeAllSessions];
+                case 1:
+                    _b.sent();
+                    // If this task has been cancelled while we were closing previous sessions,
+                    // stop now (and thus avoid setting the new media keys);
+                    if (cancelSignal.isCancelled) {
+                        throw cancelSignal.cancellationError;
+                    }
+                    MediaKeysInfosStore.setState(mediaElement, { keySystemOptions: keySystemOptions, mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, loadedSessionsStore: loadedSessionsStore });
+                    if (mediaElement.mediaKeys === mediaKeys) {
+                        return [2 /*return*/];
+                    }
+                    log.info("DRM: Attaching MediaKeys to the media element");
+                    setMediaKeys(mediaElement, mediaKeys);
+                    log.info("DRM: MediaKeys attached with success");
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

package/dist/_esm5.processed/core/{eme/clear_eme_session.d.ts → decrypt/clear_on_stop.d.ts}

@@ -13,11 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 /**
- * Clear EME ressources that should be cleared when the current content stops
- * its playback.
+ * Clear DRM-related resources that should be cleared when the current content
+ * stops its playback.
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-export default function clearEMESession(mediaElement: HTMLMediaElement): Observable<never>;
+export default function clearOnStop(mediaElement: HTMLMediaElement): Promise<void>;

package/dist/_esm5.processed/core/decrypt/clear_on_stop.js

@@ -0,0 +1,41 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { shouldUnsetMediaKeys } from "../../compat/";
+import log from "../../log";
+import PPromise from "../../utils/promise";
+import disposeDecryptionResources from "./dispose_decryption_resources";
+import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+/**
+ * Clear DRM-related resources that should be cleared when the current content
+ * stops its playback.
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+export default function clearOnStop(mediaElement) {
+    log.info("DRM: Clearing-up DRM session.");
+    if (shouldUnsetMediaKeys()) {
+        log.info("DRM: disposing current MediaKeys.");
+        return disposeDecryptionResources(mediaElement);
+    }
+    var currentState = MediaKeysInfosStore.getState(mediaElement);
+    if (currentState !== null &&
+        currentState.keySystemOptions.closeSessionsOnStop === true) {
+        log.info("DRM: closing all current sessions.");
+        return currentState.loadedSessionsStore.closeAllSessions();
+    }
+    log.info("DRM: Nothing to clear. Returning right away. No state =", currentState === null);
+    return PPromise.resolve();
+}

package/dist/_esm5.processed/core/decrypt/content_decryptor.d.ts

@@ -0,0 +1,216 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ICustomError } from "../../errors";
+import EventEmitter from "../../utils/event_emitter";
+import { IProtectionData, IKeySystemOption } from "./types";
+/**
+ * Module communicating with the Content Decryption Module (or CDM) to be able
+ * to decrypt contents.
+ *
+ * The `ContentDecryptor` starts communicating with the CDM, to initialize the
+ * key system, as soon as it is created.
+ *
+ * You can be notified of various events, such as fatal errors, by registering
+ * to one of its multiple events (@see IContentDecryptorEvent).
+ *
+ * @class ContentDecryptor
+ */
+export default class ContentDecryptor extends EventEmitter<IContentDecryptorEvent> {
+    /**
+     * Hexadecimal id identifying the currently-chosen key system.
+     * `undefined` if not known or if the key system hasn't been initialized yet.
+     *
+     * When providing protection initialization data to the ContentDecryptor, you
+     * may only provide those linked to that system id. You can also provide all
+     * available protection initialization data, in which case it will be
+     * automatically filtered.
+     *
+     * This `systemId` may only be known once the `ReadyForContent` state (@see
+     * ContentDecryptorState) is reached, and even then, it may still be unknown,
+     * in which case it will stay to `undefined`.
+     */
+    systemId: string | undefined;
+    /**
+     * Set only if the `ContentDecryptor` failed on an error.
+     * The corresponding Error.
+     */
+    error: Error | null;
+    /**
+     * State of the ContentDecryptor (@see ContentDecryptorState) and associated
+     * data.
+     *
+     * The ContentDecryptor goes into a series of steps as it is initializing.
+     * This private property stores the current state and the potentially linked
+     * data.
+     */
+    private _stateData;
+    /**
+     * Contains information about all key sessions loaded for this current
+     * content.
+     * This object is most notably used to check which keys are already obtained,
+     * thus avoiding to perform new unnecessary license requests and CDM interactions.
+     */
+    private _currentSessions;
+    /**
+     * Allows to dispose the resources taken by the current instance of the
+     * ContentDecryptor.
+     */
+    private _canceller;
+    /**
+     * `true` once the `attach` method has been called`.
+     * Allows to avoid calling multiple times that function.
+     */
+    private _wasAttachCalled;
+    /**
+     * This queue stores initialization data which hasn't been processed yet,
+     * probably because the "queue is locked" for now. (@see _stateData private
+     * property).
+     *
+     * For example, this queue stores initialization data communicated while
+     * initializing so it can be processed when the initialization is done.
+     */
+    private _initDataQueue;
+    /**
+     * Create a new `ContentDecryptor`, and initialize its decryption capabilities
+     * right away.
+     * Goes into the `WaitingForAttachment` state once that initialization is
+     * done, after which you should call the `attach` method when you're ready for
+     * those decryption capabilities to be attached to the HTMLMediaElement.
+     *
+     * @param {HTMLMediaElement} mediaElement - The MediaElement which will be
+     * associated to a MediaKeys object
+     * @param {Array.<Object>} ksOptions - key system configuration.
+     * The `ContentDecryptor` can be given one or multiple key system
+     * configurations. It will choose the appropriate one depending on user
+     * settings and browser support.
+     */
+    constructor(mediaElement: HTMLMediaElement, ksOptions: IKeySystemOption[]);
+    /**
+     * Returns the current state of the ContentDecryptor.
+     * @see ContentDecryptorState
+     * @returns {Object}
+     */
+    getState(): ContentDecryptorState;
+    /**
+     * Attach the current decryption capabilities to the HTMLMediaElement.
+     * This method should only be called once the `ContentDecryptor` is in the
+     * `WaitingForAttachment` state.
+     *
+     * You might want to first set the HTMLMediaElement's `src` attribute before
+     * calling this method, and only push data to it once the `ReadyForContent`
+     * state is reached, for compatibility reasons.
+     */
+    attach(): void;
+    /**
+     * Stop this `ContentDecryptor` instance:
+     *   - stop listening and reacting to the various event listeners
+     *   - abort all operations.
+     *
+     * Once disposed, a `ContentDecryptor` cannot be used anymore.
+     */
+    dispose(): void;
+    /**
+     * Method to call when new protection initialization data is encounted on the
+     * content.
+     *
+     * When called, the `ContentDecryptor` will try to obtain the decryption key
+     * if not already obtained.
+     *
+     * @param {Object} initializationData
+     */
+    onInitializationData(initializationData: IProtectionData): void;
+    /**
+     * Async logic run each time new initialization data has to be processed.
+     * The promise return may reject, in which case a fatal error should be linked
+     * the current `ContentDecryptor`.
+     *
+     * The Promise's resolution however provides no semantic value.
+     * @param {Object} initializationData
+     * @returns {Promise.<void>}
+     */
+    private _processInitializationData;
+    private _tryToUseAlreadyCreatedSession;
+    private _onFatalError;
+    /**
+     * Return `true` if the `ContentDecryptor` has either been disposed or
+     * encountered a fatal error which made it stop.
+     * @returns {boolean}
+     */
+    private _isStopped;
+    private _processCurrentInitDataQueue;
+    private _lockInitDataQueue;
+    private _unlockInitDataQueue;
+}
+/** Events sent by the `ContentDecryptor`, in a `{ event: payload }` format. */
+export interface IContentDecryptorEvent {
+    /**
+     * Event emitted when a major error occured which made the ContentDecryptor
+     * stopped.
+     * When that event is sent, the `ContentDecryptor` is in the `Error` state and
+     * cannot be used anymore.
+     */
+    error: Error;
+    /**
+     * Event emitted when a minor error occured which the ContentDecryptor can
+     * recover from.
+     */
+    warning: ICustomError;
+    /**
+     * Event emitted when the `ContentDecryptor`'s state changed.
+     * States are a central aspect of the `ContentDecryptor`, be sure to check the
+     * ContentDecryptorState type.
+     */
+    stateChange: ContentDecryptorState;
+}
+/** Enumeration of the various "state" the `ContentDecryptor` can be in. */
+export declare enum ContentDecryptorState {
+    /**
+     * The `ContentDecryptor` is not yet ready to create key sessions and request
+     * licenses.
+     * This is is the initial state of the ContentDecryptor.
+     */
+    Initializing = 0,
+    /**
+     * The `ContentDecryptor` has been initialized.
+     * You should now called the `attach` method when you want to add decryption
+     * capabilities to the HTMLMediaElement. The ContentDecryptor won't go to the
+     * `ReadyForContent` state until `attach` is called.
+     *
+     * For compatibility reasons, this should be done after the HTMLMediaElement's
+     * src attribute is set.
+     *
+     * It is also from when this state is reached that the `ContentDecryptor`'s
+     * `systemId` property may be known.
+     *
+     * This state is always coming after the `Initializing` state.
+     */
+    WaitingForAttachment = 1,
+    /**
+     * Content (encrypted or not) can begin to be pushed on the HTMLMediaElement
+     * (this state was needed because some browser quirks sometimes forces us to
+     * call EME API before this can be done).
+     *
+     * This state is always coming after the `WaitingForAttachment` state.
+     */
+    ReadyForContent = 2,
+    /**
+     * The `ContentDecryptor` has encountered a fatal error and has been stopped.
+     * It is now unusable.
+     */
+    Error = 3,
+    /** The `ContentDecryptor` has been disposed of and is now unusable. */
+    Disposed = 4
+}