From b8414f0a6b82243ea78c5ff2835fd2fbe92481b6 Mon Sep 17 00:00:00 2001
From: Paul Berberian <paul.berberian+github@proton.me>
Date: Fri, 5 Jul 2024 16:00:53 +0200
Subject: [PATCH] [Proposal] Forbid usage of the `MediaKeys` type and other EME
 TS types

Based on #1397.

In the idea of including fake encrypted contents in our integration
tests by mocking MSE+EME+HTML 5 media API (not as complex as it sounds)
to increase by a lot the types of issues our CI is capable to catch, I
noticed an opportunity to even improve on the current code.

Like in #1397, the idea is there to provide typings subset of the
various EME API and to rely on them instead in the RxPlayer code (and
enforcing this through our linter).

This allows to:

  - much simplify EME API mocking by not having to implement the full
    extent of the EME API - though almost all of it is implemented
    instead (exceptions are the `EventTarget`'s third `options` optional
    parameter which we never use, `dispatchEvent`, and the `onevent`
    methods that we never rely on).

  - Allow the definition of environment-specific APIs

  - Be more aware of which EME API we currently use

The gain is here much more evident than in #1397 as we already had some
kind of sub-typings with the `ICustom...` types (e.g.
`ICustomMediaKeys`). By renaming those `I...` (e.g. `IMediaKeys`) and
ensuring they are actually compatible with the base type (e.g.
`MediaKeys`), we end up in my opinion with simpler code.
---
 .eslintrc.js                                  | 12 +++
 src/compat/browser_compatibility_types.ts     | 73 +++++++++++++++----
 src/compat/eme/close_session.ts               |  6 +-
 src/compat/eme/custom_key_system_access.ts    | 15 +---
 .../eme/custom_media_keys/ie11_media_keys.ts  | 52 +++++++------
 src/compat/eme/custom_media_keys/index.ts     |  2 -
 .../moz_media_keys_constructor.ts             | 14 ++--
 .../old_webkit_media_keys.ts                  | 35 ++++-----
 src/compat/eme/custom_media_keys/types.ts     | 66 -----------------
 .../custom_media_keys/webkit_media_keys.ts    | 64 +++++++---------
 src/compat/eme/eme-api-implementation.ts      | 30 ++++----
 src/compat/eme/generate_key_request.ts        |  4 +-
 src/compat/eme/get_init_data.ts               |  4 +-
 src/compat/eme/index.ts                       | 11 +--
 src/compat/eme/load_session.ts                | 14 +---
 src/compat/eme/set_media_keys.ts              |  5 +-
 src/compat/event_listeners.ts                 |  4 +-
 .../media_key_system_access.test.ts           |  4 +-
 src/main_thread/decrypt/attach_media_keys.ts  | 14 ++--
 src/main_thread/decrypt/content_decryptor.ts  | 13 ++--
 .../decrypt/create_or_load_session.ts         |  6 +-
 src/main_thread/decrypt/create_session.ts     |  6 +-
 src/main_thread/decrypt/find_key_system.ts    | 12 +--
 src/main_thread/decrypt/get_media_keys.ts     | 15 ++--
 .../decrypt/session_events_listener.ts        |  6 +-
 .../decrypt/set_server_certificate.ts         |  8 +-
 .../decrypt/utils/check_key_statuses.ts       |  4 +-
 .../decrypt/utils/is_session_usable.ts        |  6 +-
 .../decrypt/utils/loaded_sessions_store.ts    | 31 ++++----
 .../decrypt/utils/media_keys_infos_store.ts   | 14 ++--
 .../utils/persistent_sessions_store.ts        | 12 ++-
 .../decrypt/utils/server_certificate_store.ts | 18 ++---
 .../isobmff/extract_complete_chunks.ts        |  2 +-
 33 files changed, 267 insertions(+), 315 deletions(-)
 delete mode 100644 src/compat/eme/custom_media_keys/types.ts

diff --git a/.eslintrc.js b/.eslintrc.js
index 473df4d2eb..907cfcb3e5 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -71,6 +71,18 @@ module.exports = {
             message:
               "Avoid relying on `SourceBufferList` directly unless it is API-facing. Prefer our more restricted `ISourceBufferList` type",
           },
+          MediaKeySystemAccess: {
+            message:
+              "Avoid relying on `MediaKeySystemAccess` directly unless it is API-facing. Prefer our more restricted `IMediaKeySystemAccess` type",
+          },
+          MediaKeys: {
+            message:
+              "Avoid relying on `MediaKeys` directly unless it is API-facing. Prefer our more restricted `IMediaKeys` type",
+          },
+          MediaKeySession: {
+            message:
+              "Avoid relying on `MediaKeySession` directly unless it is API-facing. Prefer our more restricted `IMediaKeySession` type",
+          },
         },
       },
     ],
diff --git a/src/compat/browser_compatibility_types.ts b/src/compat/browser_compatibility_types.ts
index 3bfd5c90a0..8c9037e585 100644
--- a/src/compat/browser_compatibility_types.ts
+++ b/src/compat/browser_compatibility_types.ts
@@ -18,12 +18,6 @@ import type { IListener } from "../utils/event_emitter";
 import globalScope from "../utils/global_scope";
 import isNullOrUndefined from "../utils/is_null_or_undefined";
 
-/** Regular MediaKeys type + optional functions present in IE11. */
-interface ICompatMediaKeysConstructor {
-  isTypeSupported?: (type: string) => boolean; // IE11 only
-  new (keyType?: string): MediaKeys; // argument for IE11 only
-}
-
 /**
  * Browser implementation of a VTTCue constructor.
  * TODO open TypeScript issue about it?
@@ -189,18 +183,22 @@ export interface ISourceBuffer extends IEventTarget<ISourceBufferEventMap> {
   onupdatestart: ((evt: Event) => void) | null;
 }
 
+export interface IMediaEncryptedEvent extends MediaEncryptedEvent {
+  forceSessionRecreation?: boolean;
+}
+
 /** Events potentially dispatched by an `IMediaElement` */
 export interface IMediaElementEventMap {
   canplay: Event;
   canplaythrough: Event;
-  encrypted: MediaEncryptedEvent;
+  encrypted: IMediaEncryptedEvent;
   ended: Event;
   enterpictureinpicture: Event;
   error: Event;
   leavepictureinpicture: Event;
   loadeddata: Event;
   loadedmetadata: Event;
-  needkey: MediaEncryptedEvent;
+  needkey: IMediaEncryptedEvent;
   pause: Event;
   play: Event;
   playing: Event;
@@ -212,7 +210,7 @@ export interface IMediaElementEventMap {
   visibilitychange: Event;
   volumechange: Event;
   waiting: Event;
-  webkitneedkey: MediaEncryptedEvent;
+  webkitneedkey: IMediaEncryptedEvent;
 }
 
 /**
@@ -239,7 +237,7 @@ export interface IMediaElement extends IEventTarget<IMediaElementEventMap> {
   duration: number;
   ended: boolean;
   error: MediaError | null;
-  mediaKeys: null | MediaKeys;
+  mediaKeys: null | IMediaKeys;
   muted: boolean;
   nodeName: string;
   paused: boolean;
@@ -261,9 +259,9 @@ export interface IMediaElement extends IEventTarget<IMediaElementEventMap> {
   play(): Promise<void>;
   removeAttribute(attr: string): void;
   removeChild(x: unknown): void;
-  setMediaKeys(x: MediaKeys | null): Promise<void>;
+  setMediaKeys(x: IMediaKeys | null): Promise<void>;
 
-  onencrypted: ((evt: MediaEncryptedEvent) => void) | null;
+  onencrypted: ((evt: IMediaEncryptedEvent) => void) | null;
   oncanplay: ((evt: Event) => void) | null;
   oncanplaythrough: ((evt: Event) => void) | null;
   onended: ((evt: Event) => void) | null;
@@ -293,12 +291,36 @@ export interface IMediaElement extends IEventTarget<IMediaElementEventMap> {
   msSetMediaKeys?: (mediaKeys: unknown) => void;
   webkitSetMediaKeys?: (mediaKeys: unknown) => void;
   webkitKeys?: {
-    createSession?: (mimeType: string, initData: BufferSource) => MediaKeySession;
+    createSession?: (mimeType: string, initData: BufferSource) => IMediaKeySession;
   };
   audioTracks?: ICompatAudioTrackList;
   videoTracks?: ICompatVideoTrackList;
 }
 
+export interface IMediaKeySystemAccess {
+  readonly keySystem: string;
+  getConfiguration(): MediaKeySystemConfiguration;
+  createMediaKeys(): Promise<IMediaKeys>;
+}
+
+export interface IMediaKeys {
+  isTypeSupported?: (type: string) => boolean; // IE11 only
+  createSession(sessionType?: MediaKeySessionType): IMediaKeySession;
+  setServerCertificate(serverCertificate: BufferSource): Promise<boolean>;
+}
+
+export interface IMediaKeySession extends IEventTarget<MediaKeySessionEventMap> {
+  readonly closed: Promise<MediaKeySessionClosedReason>;
+  readonly expiration: number;
+  readonly keyStatuses: MediaKeyStatusMap;
+  readonly sessionId: string;
+  close(): Promise<void>;
+  generateRequest(_initDataType: string, _initData: BufferSource): Promise<void>;
+  load(sessionId: string): Promise<boolean>;
+  remove(): Promise<void>;
+  update(response: BufferSource): Promise<void>;
+}
+
 // @ts-expect-error unused function, just used for compile-time typechecking
 // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-restricted-types
 function testMediaElement(x: HTMLMediaElement) {
@@ -331,6 +353,30 @@ function testSourceBufferList(x: SourceBufferList) {
 function assertCompatibleISourceBufferList(_x: ISourceBufferList) {
   // Noop
 }
+// @ts-expect-error unused function, just used for compile-time typechecking
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-restricted-types
+function testMediaKeySystemAccess(x: MediaKeySystemAccess) {
+  assertCompatibleIMediaKeySystemAccess(x);
+}
+function assertCompatibleIMediaKeySystemAccess(_x: IMediaKeySystemAccess) {
+  // Noop
+}
+// @ts-expect-error unused function, just used for compile-time typechecking
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-restricted-types
+function testMediaKeys(x: MediaKeys) {
+  assertCompatibleIMediaKeys(x);
+}
+function assertCompatibleIMediaKeys(_x: IMediaKeys) {
+  // Noop
+}
+// @ts-expect-error unused function, just used for compile-time typechecking
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-restricted-types
+function testMediaKeySession(x: MediaKeySession) {
+  assertCompatibleIMediaKeySession(x);
+}
+function assertCompatibleIMediaKeySession(_x: IMediaKeySession) {
+  // Noop
+}
 
 /**
  * AudioTrackList implementation (that TS forgot).
@@ -443,7 +489,6 @@ export type {
   ICompatVideoTrackList,
   ICompatAudioTrack,
   ICompatVideoTrack,
-  ICompatMediaKeysConstructor,
   ICompatTextTrack,
   ICompatVTTCue,
   ICompatVTTCueConstructor,
diff --git a/src/compat/eme/close_session.ts b/src/compat/eme/close_session.ts
index 92a42d6f81..d0babfa7f3 100644
--- a/src/compat/eme/close_session.ts
+++ b/src/compat/eme/close_session.ts
@@ -17,7 +17,7 @@
 import log from "../../log";
 import cancellableSleep from "../../utils/cancellable_sleep";
 import TaskCanceller, { CancellationError } from "../../utils/task_canceller";
-import type { ICustomMediaKeySession } from "./custom_media_keys";
+import type { IMediaKeySession } from "../browser_compatibility_types";
 
 /**
  * Close the given `MediaKeySession` and returns a Promise resolving when the
@@ -32,9 +32,7 @@ import type { ICustomMediaKeySession } from "./custom_media_keys";
  * @param {MediaKeySession|Object} session
  * @returns {Promise.<undefined>}
  */
-export default function closeSession(
-  session: MediaKeySession | ICustomMediaKeySession,
-): Promise<void> {
+export default function closeSession(session: IMediaKeySession): Promise<void> {
   const timeoutCanceller = new TaskCanceller();
 
   return Promise.race([
diff --git a/src/compat/eme/custom_key_system_access.ts b/src/compat/eme/custom_key_system_access.ts
index af888b79f1..da27d29e4a 100644
--- a/src/compat/eme/custom_key_system_access.ts
+++ b/src/compat/eme/custom_key_system_access.ts
@@ -13,14 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { ICustomMediaKeys } from "./custom_media_keys";
-
-// MediaKeySystemAccess implementation
-export interface ICustomMediaKeySystemAccess {
-  readonly keySystem: string;
-  getConfiguration(): MediaKeySystemConfiguration;
-  createMediaKeys(): Promise<MediaKeys | ICustomMediaKeys>;
-}
+import type { IMediaKeySystemAccess, IMediaKeys } from "../browser_compatibility_types";
 
 /**
  * Simple implementation of the MediaKeySystemAccess EME API.
@@ -28,7 +21,7 @@ export interface ICustomMediaKeySystemAccess {
  * All needed arguments are given to the constructor
  * @class CustomMediaKeySystemAccess
  */
-export default class CustomMediaKeySystemAccess implements ICustomMediaKeySystemAccess {
+export default class CustomMediaKeySystemAccess implements IMediaKeySystemAccess {
   /**
    * @param {string} _keyType - type of key system (e.g. "widevine" or
    * "com.widevine.alpha").
@@ -38,7 +31,7 @@ export default class CustomMediaKeySystemAccess implements ICustomMediaKeySystem
    */
   constructor(
     private readonly _keyType: string,
-    private readonly _mediaKeys: ICustomMediaKeys | MediaKeys,
+    private readonly _mediaKeys: IMediaKeys,
     private readonly _configuration: MediaKeySystemConfiguration,
   ) {}
 
@@ -54,7 +47,7 @@ export default class CustomMediaKeySystemAccess implements ICustomMediaKeySystem
    * @returns {Promise.<Object>} - Promise wrapping the MediaKeys for this
    * MediaKeySystemAccess. Never rejects.
    */
-  public createMediaKeys(): Promise<ICustomMediaKeys | MediaKeys> {
+  public createMediaKeys(): Promise<IMediaKeys> {
     return new Promise((res) => res(this._mediaKeys));
   }
 
diff --git a/src/compat/eme/custom_media_keys/ie11_media_keys.ts b/src/compat/eme/custom_media_keys/ie11_media_keys.ts
index 9cd20c8aca..e10108b611 100644
--- a/src/compat/eme/custom_media_keys/ie11_media_keys.ts
+++ b/src/compat/eme/custom_media_keys/ie11_media_keys.ts
@@ -18,25 +18,23 @@ import EventEmitter from "../../../utils/event_emitter";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import TaskCanceller from "../../../utils/task_canceller";
 import wrapInPromise from "../../../utils/wrapInPromise";
-import type { IMediaElement } from "../../browser_compatibility_types";
+import type {
+  IMediaElement,
+  IMediaKeySession,
+  IMediaKeys,
+} from "../../browser_compatibility_types";
 import * as events from "../../event_listeners";
 import type { MSMediaKeys, MSMediaKeySession } from "./ms_media_keys_constructor";
 import { MSMediaKeysConstructor } from "./ms_media_keys_constructor";
-import type {
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  ICustomMediaKeyStatusMap,
-  IMediaKeySessionEvents,
-} from "./types";
 
 class IE11MediaKeySession
-  extends EventEmitter<IMediaKeySessionEvents>
-  implements ICustomMediaKeySession
+  extends EventEmitter<MediaKeySessionEventMap>
+  implements IMediaKeySession
 {
   public readonly update: (license: Uint8Array) => Promise<void>;
-  public readonly closed: Promise<void>;
+  public readonly closed: Promise<MediaKeySessionClosedReason>;
   public expiration: number;
-  public keyStatuses: ICustomMediaKeyStatusMap;
+  public keyStatuses: MediaKeyStatusMap;
   private readonly _mk: MSMediaKeys;
   private readonly _sessionClosingCanceller: TaskCanceller;
   private _ss: MSMediaKeySession | undefined;
@@ -47,7 +45,9 @@ class IE11MediaKeySession
     this._mk = mk;
     this._sessionClosingCanceller = new TaskCanceller();
     this.closed = new Promise((resolve) => {
-      this._sessionClosingCanceller.signal.register(() => resolve());
+      this._sessionClosingCanceller.signal.register(() =>
+        resolve("closed-by-application"),
+      );
     });
     this.update = (license: Uint8Array) => {
       return new Promise((resolve, reject) => {
@@ -81,21 +81,30 @@ class IE11MediaKeySession
       events.onKeyMessage(
         this._ss,
         (evt) => {
-          this.trigger((evt as Event).type ?? "message", evt as Event);
+          this.trigger(
+            ((evt as Event).type ?? "message") as keyof MediaKeySessionEventMap,
+            evt as Event,
+          );
         },
         this._sessionClosingCanceller.signal,
       );
       events.onKeyAdded(
         this._ss,
         (evt) => {
-          this.trigger((evt as Event).type ?? "keyadded", evt as Event);
+          this.trigger(
+            ((evt as Event).type ?? "keyadded") as keyof MediaKeySessionEventMap,
+            evt as Event,
+          );
         },
         this._sessionClosingCanceller.signal,
       );
       events.onKeyError(
         this._ss,
         (evt) => {
-          this.trigger((evt as Event).type ?? "keyerror", evt as Event);
+          this.trigger(
+            ((evt as Event).type ?? "keyerror") as keyof MediaKeySessionEventMap,
+            evt as Event,
+          );
         },
         this._sessionClosingCanceller.signal,
       );
@@ -123,7 +132,7 @@ class IE11MediaKeySession
   }
 }
 
-class IE11CustomMediaKeys implements ICustomMediaKeys {
+class IE11CustomMediaKeys implements IMediaKeys {
   private _videoElement?: IMediaElement;
   private _mediaKeys?: MSMediaKeys;
 
@@ -143,14 +152,14 @@ class IE11CustomMediaKeys implements ICustomMediaKeys {
     });
   }
 
-  createSession(/* sessionType */): ICustomMediaKeySession {
+  createSession(/* sessionType */): IMediaKeySession {
     if (this._videoElement === undefined || this._mediaKeys === undefined) {
       throw new Error("Video not attached to the MediaKeys");
     }
     return new IE11MediaKeySession(this._mediaKeys);
   }
 
-  setServerCertificate(): Promise<void> {
+  setServerCertificate(): Promise<boolean> {
     throw new Error("Server certificate is not implemented in your browser");
   }
 }
@@ -158,10 +167,7 @@ class IE11CustomMediaKeys implements ICustomMediaKeys {
 export default function getIE11MediaKeysCallbacks(): {
   isTypeSupported: (keyType: string) => boolean;
   createCustomMediaKeys: (keyType: string) => IE11CustomMediaKeys;
-  setMediaKeys: (
-    elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
-  ) => Promise<unknown>;
+  setMediaKeys: (elt: IMediaElement, mediaKeys: IMediaKeys | null) => Promise<unknown>;
 } {
   const isTypeSupported = (keySystem: string, type?: string | null) => {
     if (MSMediaKeysConstructor === undefined) {
@@ -175,7 +181,7 @@ export default function getIE11MediaKeysCallbacks(): {
   const createCustomMediaKeys = (keyType: string) => new IE11CustomMediaKeys(keyType);
   const setMediaKeys = (
     elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ): Promise<unknown> => {
     if (mediaKeys === null) {
       // msSetMediaKeys only accepts native MSMediaKeys as argument.
diff --git a/src/compat/eme/custom_media_keys/index.ts b/src/compat/eme/custom_media_keys/index.ts
index 19ae83bb8e..21eff0060c 100644
--- a/src/compat/eme/custom_media_keys/index.ts
+++ b/src/compat/eme/custom_media_keys/index.ts
@@ -5,11 +5,9 @@ import getMozMediaKeysCallbacks, {
 import getOldKitWebKitMediaKeyCallbacks, {
   isOldWebkitMediaElement,
 } from "./old_webkit_media_keys";
-import type { ICustomMediaKeys, ICustomMediaKeySession } from "./types";
 import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 
-export type { ICustomMediaKeys, ICustomMediaKeySession };
 export {
   getIE11MediaKeysCallbacks,
   MSMediaKeysConstructor,
diff --git a/src/compat/eme/custom_media_keys/moz_media_keys_constructor.ts b/src/compat/eme/custom_media_keys/moz_media_keys_constructor.ts
index e615f17279..203af1c121 100644
--- a/src/compat/eme/custom_media_keys/moz_media_keys_constructor.ts
+++ b/src/compat/eme/custom_media_keys/moz_media_keys_constructor.ts
@@ -16,11 +16,10 @@
 
 import globalScope from "../../../utils/global_scope";
 import wrapInPromise from "../../../utils/wrapInPromise";
-import type { IMediaElement } from "../../browser_compatibility_types";
-import type { ICustomMediaKeys } from "./types";
+import type { IMediaElement, IMediaKeys } from "../../browser_compatibility_types";
 
 interface IMozMediaKeysConstructor {
-  new (keySystem: string): ICustomMediaKeys;
+  new (keySystem: string): IMediaKeys;
   isTypeSupported(keySystem: string, type?: string | null): boolean;
 }
 
@@ -41,11 +40,8 @@ export { MozMediaKeysConstructor };
 
 export default function getMozMediaKeysCallbacks(): {
   isTypeSupported: (keyType: string) => boolean;
-  createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
-  setMediaKeys: (
-    elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
-  ) => Promise<unknown>;
+  createCustomMediaKeys: (keyType: string) => IMediaKeys;
+  setMediaKeys: (elt: IMediaElement, mediaKeys: IMediaKeys | null) => Promise<unknown>;
 } {
   const isTypeSupported = (keySystem: string, type?: string | null) => {
     if (MozMediaKeysConstructor === undefined) {
@@ -64,7 +60,7 @@ export default function getMozMediaKeysCallbacks(): {
   };
   const setMediaKeys = (
     elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ): Promise<unknown> => {
     return wrapInPromise(() => {
       if (
diff --git a/src/compat/eme/custom_media_keys/old_webkit_media_keys.ts b/src/compat/eme/custom_media_keys/old_webkit_media_keys.ts
index 92dce51f13..134d93d9a3 100644
--- a/src/compat/eme/custom_media_keys/old_webkit_media_keys.ts
+++ b/src/compat/eme/custom_media_keys/old_webkit_media_keys.ts
@@ -20,13 +20,11 @@ import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import noop from "../../../utils/noop";
 import { utf8ToStr } from "../../../utils/string_parsing";
 import wrapInPromise from "../../../utils/wrapInPromise";
-import type { IMediaElement } from "../../browser_compatibility_types";
 import type {
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  ICustomMediaKeyStatusMap,
-  IMediaKeySessionEvents,
-} from "./types";
+  IMediaElement,
+  IMediaKeySession,
+  IMediaKeys,
+} from "../../browser_compatibility_types";
 
 export interface IOldWebkitHTMLMediaElement extends HTMLVideoElement {
   webkitGenerateKeyRequest: (keyType: string, initData: ArrayBuffer) => void;
@@ -60,12 +58,12 @@ export function isOldWebkitMediaElement(
  * @class OldWebkitMediaKeySession
  */
 class OldWebkitMediaKeySession
-  extends EventEmitter<IMediaKeySessionEvents>
-  implements ICustomMediaKeySession
+  extends EventEmitter<MediaKeySessionEventMap>
+  implements IMediaKeySession
 {
-  public readonly closed: Promise<void>;
+  public readonly closed: Promise<MediaKeySessionClosedReason>;
   public expiration: number;
-  public keyStatuses: ICustomMediaKeyStatusMap;
+  public keyStatuses: MediaKeyStatusMap;
   public sessionId: string;
 
   private readonly _vid: IOldWebkitHTMLMediaElement;
@@ -84,7 +82,7 @@ class OldWebkitMediaKeySession
     this.expiration = NaN;
 
     const onSessionRelatedEvent = (evt: Event) => {
-      this.trigger(evt.type, evt);
+      this.trigger(evt.type as keyof MediaKeySessionEventMap, evt);
     };
     this.closed = new Promise((resolve) => {
       this._closeSession = () => {
@@ -94,7 +92,7 @@ class OldWebkitMediaKeySession
             mediaElement.removeEventListener(`webkit${evt}`, onSessionRelatedEvent);
           },
         );
-        resolve();
+        resolve("closed-by-application");
       };
     });
 
@@ -155,7 +153,7 @@ class OldWebkitMediaKeySession
   }
 }
 
-class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
+class OldWebKitCustomMediaKeys implements IMediaKeys {
   private readonly _keySystem: string;
   private _videoElement?: IOldWebkitHTMLMediaElement;
 
@@ -172,14 +170,14 @@ class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
     });
   }
 
-  createSession(/* sessionType */): ICustomMediaKeySession {
+  createSession(/* sessionType */): IMediaKeySession {
     if (isNullOrUndefined(this._videoElement)) {
       throw new Error("Video not attached to the MediaKeys");
     }
     return new OldWebkitMediaKeySession(this._videoElement, this._keySystem);
   }
 
-  setServerCertificate(): Promise<void> {
+  setServerCertificate(): Promise<boolean> {
     throw new Error("Server certificate is not implemented in your browser");
   }
 }
@@ -187,10 +185,7 @@ class OldWebKitCustomMediaKeys implements ICustomMediaKeys {
 export default function getOldWebKitMediaKeysCallbacks(): {
   isTypeSupported: (keyType: string) => boolean;
   createCustomMediaKeys: (keyType: string) => OldWebKitCustomMediaKeys;
-  setMediaKeys: (
-    elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
-  ) => Promise<unknown>;
+  setMediaKeys: (elt: IMediaElement, mediaKeys: IMediaKeys | null) => Promise<unknown>;
 } {
   const isTypeSupported = function (keyType: string): boolean {
     // get any <video> element from the DOM or create one
@@ -217,7 +212,7 @@ export default function getOldWebKitMediaKeysCallbacks(): {
     new OldWebKitCustomMediaKeys(keyType);
   const setMediaKeys = (
     elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ): Promise<unknown> => {
     if (mediaKeys === null) {
       return Promise.resolve(undefined);
diff --git a/src/compat/eme/custom_media_keys/types.ts b/src/compat/eme/custom_media_keys/types.ts
deleted file mode 100644
index d81509a418..0000000000
--- a/src/compat/eme/custom_media_keys/types.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-/**
- * 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 type { IEventEmitter } from "../../../utils/event_emitter";
-import type { IMediaElement } from "../../browser_compatibility_types";
-
-export interface ICustomMediaKeySession extends IEventEmitter<IMediaKeySessionEvents> {
-  // Attributes
-  readonly closed: Promise<void>;
-  expiration: number;
-  keyStatuses: ICustomMediaKeyStatusMap;
-  sessionId: string;
-
-  // Event handlers
-  onmessage?: (message: MediaKeyMessageEvent) => void;
-  onkeystatusesChange?: (evt: Event) => void;
-
-  // Functions
-
-  generateRequest(initDataType: string, initData: BufferSource | null): Promise<void>;
-
-  load(sessionId: string): Promise<boolean>;
-  update(response: BufferSource | null): Promise<void>;
-  close(): Promise<void>;
-  remove(): Promise<void>;
-}
-
-export interface ICustomMediaKeys {
-  _setVideo: (vid: IMediaElement) => Promise<unknown>;
-  createSession(sessionType?: MediaKeySessionType): ICustomMediaKeySession;
-  setServerCertificate(setServerCertificate: BufferSource): Promise<void>;
-}
-
-export interface ICustomMediaKeyStatusMap {
-  readonly size: number;
-  forEach(callback: (status: MediaKeyStatus) => void, thisArg?: unknown): void;
-  get(keyId: BufferSource | null): MediaKeyStatus | undefined;
-  has(keyId: BufferSource | null): boolean;
-}
-
-export interface IMediaKeySessionEvents {
-  [key: string]: MediaKeyMessageEvent | Event;
-  // "keymessage"
-  // "message"
-  // "keyadded"
-  // "ready"
-  // "keyerror"
-  /* "error" */
-}
-
-export interface ICustomMediaEncryptedEvent extends MediaEncryptedEvent {
-  forceSessionRecreation?: boolean | undefined;
-}
diff --git a/src/compat/eme/custom_media_keys/webkit_media_keys.ts b/src/compat/eme/custom_media_keys/webkit_media_keys.ts
index b220d381b6..0ff73e0c80 100644
--- a/src/compat/eme/custom_media_keys/webkit_media_keys.ts
+++ b/src/compat/eme/custom_media_keys/webkit_media_keys.ts
@@ -18,23 +18,15 @@ import EventEmitter from "../../../utils/event_emitter";
 import noop from "../../../utils/noop";
 import startsWith from "../../../utils/starts_with";
 import wrapInPromise from "../../../utils/wrapInPromise";
-import type { IMediaElement } from "../../browser_compatibility_types";
-import getWebKitFairplayInitData from "../get_webkit_fairplay_initdata";
 import type {
-  ICustomMediaKeys,
-  ICustomMediaKeySession,
-  ICustomMediaKeyStatusMap,
-  IMediaKeySessionEvents,
-} from "./types";
+  IMediaElement,
+  IMediaKeySession,
+  IMediaKeys,
+} from "../../browser_compatibility_types";
+import getWebKitFairplayInitData from "../get_webkit_fairplay_initdata";
 import type { IWebKitMediaKeys } from "./webkit_media_keys_constructor";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 
-export interface ICustomWebKitMediaKeys {
-  _setVideo: (videoElement: IMediaElement) => Promise<unknown>;
-  createSession(mimeType: string, initData: Uint8Array): ICustomMediaKeySession;
-  setServerCertificate(setServerCertificate: BufferSource): Promise<void>;
-}
-
 /**
  * Check if keyType is for fairplay DRM
  * @param {string} keyType
@@ -69,19 +61,19 @@ function setWebKitMediaKeys(elt: IMediaElement, mediaKeys: unknown): Promise<unk
  * EME custom APIs.
  */
 class WebkitMediaKeySession
-  extends EventEmitter<IMediaKeySessionEvents>
-  implements ICustomMediaKeySession
+  extends EventEmitter<MediaKeySessionEventMap>
+  implements IMediaKeySession
 {
-  public readonly closed: Promise<void>;
+  public readonly closed: Promise<MediaKeySessionClosedReason>;
   public expiration: number;
-  public keyStatuses: ICustomMediaKeyStatusMap;
+  public keyStatuses: MediaKeyStatusMap;
 
   private readonly _videoElement: IMediaElement;
   private readonly _keyType: string;
-  private _nativeSession: undefined | MediaKeySession;
+  private _nativeSession: undefined | IMediaKeySession;
   private _serverCertificate: Uint8Array | undefined;
 
-  private _closeSession: () => void;
+  private _closeSession: (val: MediaKeySessionClosedReason) => void;
   private _unbindSession: () => void;
 
   /**
@@ -101,7 +93,7 @@ class WebkitMediaKeySession
 
     this._unbindSession = noop;
     this._closeSession = noop; // Just here to make TypeScript happy
-    this.closed = new Promise((resolve) => {
+    this.closed = new Promise((resolve: (val: MediaKeySessionClosedReason) => void) => {
       this._closeSession = resolve;
     });
     this.keyStatuses = new Map();
@@ -167,7 +159,7 @@ class WebkitMediaKeySession
   public close(): Promise<void> {
     return new Promise((resolve, reject) => {
       this._unbindSession();
-      this._closeSession();
+      this._closeSession("closed-by-application");
       if (this._nativeSession === undefined) {
         reject("No session to close.");
         return;
@@ -190,30 +182,33 @@ class WebkitMediaKeySession
     return this._nativeSession?.sessionId ?? "";
   }
 
-  private _listenEvent(session: MediaKeySession): void {
+  private _listenEvent(session: IMediaKeySession): void {
     this._unbindSession(); // If previous session was linked
 
     const onEvent = (evt: Event) => {
-      this.trigger(evt.type, evt);
+      this.trigger(evt.type as keyof MediaKeySessionEventMap, evt);
     };
 
     ["keymessage", "message", "keyadded", "ready", "keyerror", "error"].forEach((evt) => {
-      session.addEventListener(evt, onEvent);
-      session.addEventListener(`webkit${evt}`, onEvent);
+      session.addEventListener(evt as keyof MediaKeySessionEventMap, onEvent);
+      session.addEventListener(`webkit${evt}` as keyof MediaKeySessionEventMap, onEvent);
     });
 
     this._unbindSession = () => {
       ["keymessage", "message", "keyadded", "ready", "keyerror", "error"].forEach(
         (evt) => {
-          session.removeEventListener(evt, onEvent);
-          session.removeEventListener(`webkit${evt}`, onEvent);
+          session.removeEventListener(evt as keyof MediaKeySessionEventMap, onEvent);
+          session.removeEventListener(
+            `webkit${evt}` as keyof MediaKeySessionEventMap,
+            onEvent,
+          );
         },
       );
     };
   }
 }
 
-class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
+class WebKitCustomMediaKeys implements IMediaKeys {
   private _videoElement?: IMediaElement;
   private _mediaKeys?: IWebKitMediaKeys;
   private _serverCertificate?: Uint8Array;
@@ -235,7 +230,7 @@ class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
     return setWebKitMediaKeys(this._videoElement, this._mediaKeys);
   }
 
-  createSession(/* sessionType */): ICustomMediaKeySession {
+  createSession(/* sessionType */): IMediaKeySession {
     if (this._videoElement === undefined || this._mediaKeys === undefined) {
       throw new Error("Video not attached to the MediaKeys");
     }
@@ -246,19 +241,16 @@ class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
     );
   }
 
-  setServerCertificate(serverCertificate: Uint8Array): Promise<void> {
+  setServerCertificate(serverCertificate: Uint8Array): Promise<boolean> {
     this._serverCertificate = serverCertificate;
-    return Promise.resolve();
+    return Promise.resolve(true);
   }
 }
 
 export default function getWebKitMediaKeysCallbacks(): {
   isTypeSupported: (keyType: string) => boolean;
   createCustomMediaKeys: (keyType: string) => WebKitCustomMediaKeys;
-  setMediaKeys: (
-    elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
-  ) => Promise<unknown>;
+  setMediaKeys: (elt: IMediaElement, mediaKeys: IMediaKeys | null) => Promise<unknown>;
 } {
   if (WebKitMediaKeysConstructor === undefined) {
     throw new Error("No WebKitMediaKeys API.");
@@ -267,7 +259,7 @@ export default function getWebKitMediaKeysCallbacks(): {
   const createCustomMediaKeys = (keyType: string) => new WebKitCustomMediaKeys(keyType);
   const setMediaKeys = (
     elt: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ): Promise<unknown> => {
     if (mediaKeys === null) {
       return setWebKitMediaKeys(elt, mediaKeys);
diff --git a/src/compat/eme/eme-api-implementation.ts b/src/compat/eme/eme-api-implementation.ts
index 3844781fd5..36c6afd4cf 100644
--- a/src/compat/eme/eme-api-implementation.ts
+++ b/src/compat/eme/eme-api-implementation.ts
@@ -5,7 +5,12 @@ import isNode from "../../utils/is_node";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
 import objectAssign from "../../utils/object_assign";
 import type { CancellationSignal } from "../../utils/task_canceller";
-import type { IMediaElement } from "../browser_compatibility_types";
+import type {
+  IMediaElement,
+  IMediaEncryptedEvent,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../browser_compatibility_types";
 import { isIE11 } from "../browser_detection";
 import type { IEventTargetLike } from "../event_listeners";
 import { createCompatibleEventListener } from "../event_listeners";
@@ -20,10 +25,6 @@ import getMozMediaKeysCallbacks, {
 import getOldKitWebKitMediaKeyCallbacks, {
   isOldWebkitMediaElement,
 } from "./custom_media_keys/old_webkit_media_keys";
-import type {
-  ICustomMediaEncryptedEvent,
-  ICustomMediaKeys,
-} from "./custom_media_keys/types";
 import getWebKitMediaKeysCallbacks from "./custom_media_keys/webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./custom_media_keys/webkit_media_keys_constructor";
 
@@ -53,7 +54,7 @@ export interface IEmeApiImplementation {
   requestMediaKeySystemAccess: (
     keyType: string,
     config: MediaKeySystemConfiguration[],
-  ) => Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+  ) => Promise<IMediaKeySystemAccess | CustomMediaKeySystemAccess>;
 
   /**
    * API allowing to listen for `"encrypted"` events, presumably sent by the
@@ -67,12 +68,12 @@ export interface IEmeApiImplementation {
    */
   onEncrypted: (
     target: IEventTargetLike,
-    listener: (evt: ICustomMediaEncryptedEvent) => void,
+    listener: (evt: IMediaEncryptedEvent) => void,
     cancelSignal: CancellationSignal,
   ) => void;
 
   /**
-   * API allowing to attach a `MediaKeys` instance (or an `ICustomMediaKeys`) to
+   * API allowing to attach a `MediaKeys` instance (or an `IMediaKeys`) to
    * the HTMLMediaElement so it can start decoding.
    * @param {HTMLMediaElement} The HTMLMediaElement on which the content plays.
    * @param {MediaKeys} mediaKeys - The MediaKeys instance to attach.
@@ -82,7 +83,7 @@ export interface IEmeApiImplementation {
    */
   setMediaKeys: (
     mediaElement: IMediaElement,
-    mediaKeys: MediaKeys | ICustomMediaKeys | null,
+    mediaKeys: IMediaKeys | null,
   ) => Promise<unknown>;
 
   /**
@@ -144,7 +145,7 @@ function getEmeApiImplementation(
     implementation = "standard";
   } else {
     let isTypeSupported: (keyType: string) => boolean;
-    let createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
+    let createCustomMediaKeys: (keyType: string) => IMediaKeys;
 
     if (preferredApiType === "webkit" && WebKitMediaKeysConstructor !== undefined) {
       const callbacks = getWebKitMediaKeysCallbacks();
@@ -188,7 +189,7 @@ function getEmeApiImplementation(
         onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
         const MK = globalScope.MediaKeys as unknown as typeof MediaKeys & {
           isTypeSupported?: (keyType: string) => boolean;
-          new (keyType?: string): ICustomMediaKeys;
+          new (keyType?: string): IMediaKeys;
         };
         const checkForStandardMediaKeys = () => {
           if (MK === undefined) {
@@ -222,7 +223,7 @@ function getEmeApiImplementation(
     requestMediaKeySystemAccess = function (
       keyType: string,
       keySystemConfigurations: MediaKeySystemConfiguration[],
-    ): Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess> {
+    ): Promise<IMediaKeySystemAccess> {
       if (!isTypeSupported(keyType)) {
         return Promise.reject(new Error("Unsupported key type"));
       }
@@ -289,7 +290,7 @@ function createOnEncryptedForWebkit(): IEmeApiImplementation["onEncrypted"] {
   );
   const onEncrypted = (
     target: IEventTargetLike,
-    listener: (event: ICustomMediaEncryptedEvent) => void,
+    listener: (event: IMediaEncryptedEvent) => void,
     cancelSignal: CancellationSignal,
   ) => {
     compatibleEventListener(
@@ -315,11 +316,12 @@ function createOnEncryptedForWebkit(): IEmeApiImplementation["onEncrypted"] {
  */
 function defaultSetMediaKeys(
   elt: IMediaElement,
-  mediaKeys: MediaKeys | ICustomMediaKeys | null,
+  mediaKeys: IMediaKeys | null,
 ): Promise<unknown> {
   try {
     let ret: unknown;
     if (typeof elt.setMediaKeys === "function") {
+      // eslint-disable-next-line @typescript-eslint/no-restricted-types
       ret = elt.setMediaKeys(mediaKeys as MediaKeys);
     }
 
diff --git a/src/compat/eme/generate_key_request.ts b/src/compat/eme/generate_key_request.ts
index 280eb7a744..bd51c1db8d 100644
--- a/src/compat/eme/generate_key_request.ts
+++ b/src/compat/eme/generate_key_request.ts
@@ -17,8 +17,8 @@
 import log from "../../log";
 import { getNextBoxOffsets } from "../../parsers/containers/isobmff";
 import { be4toi, concat } from "../../utils/byte_parsing";
+import type { IMediaKeySession } from "../browser_compatibility_types";
 import { PSSH_TO_INTEGER } from "./constants";
-import type { ICustomMediaKeySession } from "./custom_media_keys";
 
 /**
  * Modify "initialization data" sent to a `generateKeyRequest` EME call to
@@ -129,7 +129,7 @@ export function patchInitData(initData: Uint8Array): Uint8Array {
  * @returns {Promise} - Emit when done. Errors if fails.
  */
 export default function generateKeyRequest(
-  session: MediaKeySession | ICustomMediaKeySession,
+  session: IMediaKeySession,
   initializationDataType: string | undefined,
   initializationData: Uint8Array,
 ): Promise<unknown> {
diff --git a/src/compat/eme/get_init_data.ts b/src/compat/eme/get_init_data.ts
index 985f3edd1c..6999fe9615 100644
--- a/src/compat/eme/get_init_data.ts
+++ b/src/compat/eme/get_init_data.ts
@@ -19,8 +19,8 @@ import { getPsshSystemID } from "../../parsers/containers/isobmff";
 import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
 import { be4toi } from "../../utils/byte_parsing";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import type { IMediaEncryptedEvent } from "../browser_compatibility_types";
 import { PSSH_TO_INTEGER } from "./constants";
-import type { ICustomMediaEncryptedEvent } from "./custom_media_keys/types";
 
 /** Data recuperated from parsing the payload of an `encrypted` event. */
 export interface IEncryptedEventData {
@@ -147,7 +147,7 @@ function isPSSHAlreadyEncountered(
  * encountered in the given event.
  */
 export default function getInitData(
-  encryptedEvent: ICustomMediaEncryptedEvent,
+  encryptedEvent: IMediaEncryptedEvent,
 ): IEncryptedEventData | null {
   const { initData, initDataType, forceSessionRecreation } = encryptedEvent;
   if (isNullOrUndefined(initData)) {
diff --git a/src/compat/eme/index.ts b/src/compat/eme/index.ts
index b5d13ea619..5f529b9e75 100644
--- a/src/compat/eme/index.ts
+++ b/src/compat/eme/index.ts
@@ -15,8 +15,6 @@
  */
 
 import closeSession from "./close_session";
-import type { ICustomMediaKeySystemAccess } from "./custom_key_system_access";
-import type { ICustomMediaKeys, ICustomMediaKeySession } from "./custom_media_keys";
 import type {
   IEmeApiImplementation,
   IPreferredEmeApiType,
@@ -28,12 +26,5 @@ import getInitData from "./get_init_data";
 import loadSession from "./load_session";
 
 export default defaultEmeImplementation;
-export type {
-  IEmeApiImplementation,
-  IPreferredEmeApiType,
-  ICustomMediaKeySession,
-  ICustomMediaKeySystemAccess,
-  ICustomMediaKeys,
-  IEncryptedEventData,
-};
+export type { IEmeApiImplementation, IPreferredEmeApiType, IEncryptedEventData };
 export { closeSession, generateKeyRequest, getInitData, loadSession };
diff --git a/src/compat/eme/load_session.ts b/src/compat/eme/load_session.ts
index 13efbbe6d0..c737d465ec 100644
--- a/src/compat/eme/load_session.ts
+++ b/src/compat/eme/load_session.ts
@@ -15,7 +15,7 @@
  */
 
 import log from "../../log";
-import type { ICustomMediaKeySession } from "./custom_media_keys";
+import type { IMediaKeySession } from "../browser_compatibility_types";
 
 const EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
 
@@ -33,7 +33,7 @@ const EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
  * @returns {Promise.<boolean>}
  */
 export default async function loadSession(
-  session: MediaKeySession | ICustomMediaKeySession,
+  session: IMediaKeySession,
   sessionId: string,
 ): Promise<boolean> {
   log.info("DRM: Load persisted session", sessionId);
@@ -48,10 +48,7 @@ export default async function loadSession(
   // MediaKeySession would not be populated directly as the load answer but
   // asynchronously after.
   return new Promise((resolve) => {
-    (session as MediaKeySession).addEventListener(
-      "keystatuseschange",
-      resolveWithLoadedStatus,
-    );
+    session.addEventListener("keystatuseschange", resolveWithLoadedStatus);
     const timeout = setTimeout(
       resolveWithLoadedStatus,
       EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES,
@@ -64,10 +61,7 @@ export default async function loadSession(
 
     function cleanUp() {
       clearTimeout(timeout);
-      (session as MediaKeySession).removeEventListener(
-        "keystatuseschange",
-        resolveWithLoadedStatus,
-      );
+      session.removeEventListener("keystatuseschange", resolveWithLoadedStatus);
     }
   });
 }
diff --git a/src/compat/eme/set_media_keys.ts b/src/compat/eme/set_media_keys.ts
index d8b33d970b..990e8ec119 100644
--- a/src/compat/eme/set_media_keys.ts
+++ b/src/compat/eme/set_media_keys.ts
@@ -1,8 +1,7 @@
 import log from "../../log";
 import sleep from "../../utils/sleep";
-import type { IMediaElement } from "../browser_compatibility_types";
+import type { IMediaElement, IMediaKeys } from "../browser_compatibility_types";
 import shouldAwaitSetMediaKeys from "../should_await_set_media_keys";
-import type { ICustomMediaKeys } from "./custom_media_keys";
 import type { IEmeApiImplementation } from "./eme-api-implementation";
 
 /**
@@ -14,7 +13,7 @@ import type { IEmeApiImplementation } from "./eme-api-implementation";
 export function setMediaKeys(
   emeImplementation: IEmeApiImplementation,
   mediaElement: IMediaElement,
-  mediaKeys: MediaKeys | ICustomMediaKeys | null,
+  mediaKeys: IMediaKeys | null,
 ): Promise<unknown> {
   const prom = emeImplementation
     .setMediaKeys(mediaElement, mediaKeys)
diff --git a/src/compat/event_listeners.ts b/src/compat/event_listeners.ts
index 29bbe31f62..0ed7718996 100644
--- a/src/compat/event_listeners.ts
+++ b/src/compat/event_listeners.ts
@@ -29,8 +29,8 @@ import type {
   ICompatPictureInPictureWindow,
   IEventTarget,
   IMediaElement,
+  IMediaEncryptedEvent,
 } from "./browser_compatibility_types";
-import type { ICustomMediaEncryptedEvent } from "./eme/custom_media_keys/types";
 
 const BROWSER_PREFIXES = ["", "webkit", "moz", "ms"];
 
@@ -112,7 +112,7 @@ function createCompatibleEventListener(
   prefixes?: string[],
 ): (
   element: IEventTargetLike,
-  listener: (event: ICustomMediaEncryptedEvent) => void,
+  listener: (event: IMediaEncryptedEvent) => void,
   cancelSignal: CancellationSignal,
 ) => void;
 
diff --git a/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts b/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts
index 6821016fc4..05eb09c0b3 100644
--- a/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts
+++ b/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts
@@ -1,5 +1,5 @@
 import { describe, beforeEach, afterEach, it, expect, vi } from "vitest";
-import type { ICustomMediaKeySystemAccess } from "../../../../compat/eme";
+import type { IMediaKeySystemAccess } from "../../../../compat/browser_compatibility_types";
 import type { IKeySystemOption } from "../../../../public_types";
 import type IContentDecryptor from "../../content_decryptor";
 import {
@@ -13,7 +13,7 @@ import {
 function requestMediaKeySystemAccessNoMediaKeys(
   keySystem: string,
   config: MediaKeySystemConfiguration[],
-): Promise<ICustomMediaKeySystemAccess> {
+): Promise<IMediaKeySystemAccess> {
   if (config.length === 0) {
     throw new Error("requestMediaKeySystemAccessNoMediaKeys: no config given");
   }
diff --git a/src/main_thread/decrypt/attach_media_keys.ts b/src/main_thread/decrypt/attach_media_keys.ts
index 55c15c2467..f7617cc191 100644
--- a/src/main_thread/decrypt/attach_media_keys.ts
+++ b/src/main_thread/decrypt/attach_media_keys.ts
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../compat/browser_compatibility_types";
 import type {
-  ICustomMediaKeys,
-  ICustomMediaKeySystemAccess,
-  IEmeApiImplementation,
-} from "../../compat/eme";
+  IMediaElement,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../../compat/browser_compatibility_types";
+import type { IEmeApiImplementation } from "../../compat/eme";
 import eme from "../../compat/eme";
 import { setMediaKeys } from "../../compat/eme/set_media_keys";
 import { EncryptedMediaError } from "../../errors";
@@ -108,9 +108,9 @@ export interface IMediaKeysState {
   /** LoadedSessionsStore associated to the MediaKeys instance. */
   loadedSessionsStore: LoadedSessionsStore;
   /** The MediaKeySystemAccess allowing to create MediaKeys instances. */
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
   /** The MediaKeys instance to attach to the media element. */
-  mediaKeys: MediaKeys | ICustomMediaKeys;
+  mediaKeys: IMediaKeys;
   /**
    * The MediaKeySystemConfiguration that has been provided to the
    * `requestMediaKeySystemAccess` API.
diff --git a/src/main_thread/decrypt/content_decryptor.ts b/src/main_thread/decrypt/content_decryptor.ts
index b1e275b5dd..aacd0f2228 100644
--- a/src/main_thread/decrypt/content_decryptor.ts
+++ b/src/main_thread/decrypt/content_decryptor.ts
@@ -14,8 +14,11 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../compat/browser_compatibility_types";
-import type { ICustomMediaKeys, ICustomMediaKeySystemAccess } from "../../compat/eme";
+import type {
+  IMediaElement,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../../compat/browser_compatibility_types";
 import eme, { getInitData } from "../../compat/eme";
 import config from "../../config";
 import { EncryptedMediaError, OtherError } from "../../errors";
@@ -987,7 +990,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
  * @returns {Boolean}
  */
 function canCreatePersistentSession(
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess,
+  mediaKeySystemAccess: IMediaKeySystemAccess,
 ): boolean {
   const { sessionTypes } = mediaKeySystemAccess.getConfiguration();
   return sessionTypes !== undefined && arrayIncludes(sessionTypes, "persistent-license");
@@ -1363,9 +1366,9 @@ interface IActiveSessionInfo {
  */
 interface IAttachedMediaKeysData {
   /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
   /** The MediaKeys instance. */
-  mediaKeys: MediaKeys | ICustomMediaKeys;
+  mediaKeys: IMediaKeys;
   stores: IMediaKeySessionStores;
   options: IKeySystemOption;
 }
diff --git a/src/main_thread/decrypt/create_or_load_session.ts b/src/main_thread/decrypt/create_or_load_session.ts
index 8bb8cfaab8..666d4f0077 100644
--- a/src/main_thread/decrypt/create_or_load_session.ts
+++ b/src/main_thread/decrypt/create_or_load_session.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../compat/eme";
+import type { IMediaKeySession } from "../../compat/browser_compatibility_types";
 import log from "../../log";
 import type { CancellationSignal } from "../../utils/task_canceller";
 import createSession from "./create_session";
@@ -49,7 +49,7 @@ export default async function createOrLoadSession(
   cancelSignal: CancellationSignal,
 ): Promise<ICreateOrLoadSessionResult> {
   /** Store previously-loaded compatible MediaKeySession, if one. */
-  let previousLoadedSession: MediaKeySession | ICustomMediaKeySession | null = null;
+  let previousLoadedSession: IMediaKeySession | null = null;
 
   const { loadedSessionsStore, persistentSessionsStore } = stores;
   const entry = loadedSessionsStore.reuse(initializationData);
@@ -111,7 +111,7 @@ export default async function createOrLoadSession(
 /** Information concerning a MediaKeySession. */
 export interface IMediaKeySessionContext {
   /** The MediaKeySession itself. */
-  mediaKeySession: MediaKeySession | ICustomMediaKeySession;
+  mediaKeySession: IMediaKeySession;
   /** The type of MediaKeySession (e.g. "temporary"). */
   sessionType: MediaKeySessionType;
   /** `KeySessionRecord` assiociated to this MediaKeySession. */
diff --git a/src/main_thread/decrypt/create_session.ts b/src/main_thread/decrypt/create_session.ts
index 0a4b2c7371..e9de0bf758 100644
--- a/src/main_thread/decrypt/create_session.ts
+++ b/src/main_thread/decrypt/create_session.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../compat/eme";
+import type { IMediaKeySession } from "../../compat/browser_compatibility_types";
 import log from "../../log";
 import type { CancellationSignal } from "../../utils/task_canceller";
 import type { IProcessedProtectionData, IMediaKeySessionStores } from "./types";
@@ -193,7 +193,7 @@ async function createAndTryToRetrievePersistentSession(
 export interface INewSessionCreatedEvent {
   type: MediaKeySessionLoadingType.Created;
   value: {
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession;
+    mediaKeySession: IMediaKeySession;
     sessionType: MediaKeySessionType;
     keySessionRecord: KeySessionRecord;
   };
@@ -202,7 +202,7 @@ export interface INewSessionCreatedEvent {
 export interface IPersistentSessionRecoveryEvent {
   type: MediaKeySessionLoadingType.LoadedPersistentSession;
   value: {
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession;
+    mediaKeySession: IMediaKeySession;
     sessionType: MediaKeySessionType;
     keySessionRecord: KeySessionRecord;
   };
diff --git a/src/main_thread/decrypt/find_key_system.ts b/src/main_thread/decrypt/find_key_system.ts
index dfe573bb04..e000377fb1 100644
--- a/src/main_thread/decrypt/find_key_system.ts
+++ b/src/main_thread/decrypt/find_key_system.ts
@@ -14,9 +14,11 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../compat/browser_compatibility_types";
+import type {
+  IMediaElement,
+  IMediaKeySystemAccess,
+} from "../../compat/browser_compatibility_types";
 import { canRelyOnRequestMediaKeySystemAccess } from "../../compat/can_rely_on_request_media_key_system_access";
-import type { ICustomMediaKeySystemAccess } from "../../compat/eme";
 import eme from "../../compat/eme";
 import {
   generatePlayReadyInitData,
@@ -44,7 +46,7 @@ export type ICodecSupportList = Array<{
 
 export interface IMediaKeySystemAccessInfos {
   /** `MediaKeySystemAccess` to use to create `MediaKeys` instances. */
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
   /**
    * The MediaKeySystemConfiguration that has been provided to the
    * `requestMediaKeySystemAccess` API.
@@ -97,12 +99,12 @@ interface IKeySystemType {
 function checkCachedMediaKeySystemAccess(
   keySystem: IKeySystemOption,
   askedConfiguration: MediaKeySystemConfiguration,
-  currentKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess,
+  currentKeySystemAccess: IMediaKeySystemAccess,
   currentKeySystemOptions: IKeySystemOption,
 ): null | {
   keySystemOptions: IKeySystemOption;
   askedConfiguration: MediaKeySystemConfiguration;
-  keySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  keySystemAccess: IMediaKeySystemAccess;
 } {
   const mksConfiguration = currentKeySystemAccess.getConfiguration();
   if (shouldRenewMediaKeySystemAccess() || isNullOrUndefined(mksConfiguration)) {
diff --git a/src/main_thread/decrypt/get_media_keys.ts b/src/main_thread/decrypt/get_media_keys.ts
index a1149f35cc..c85141cccb 100644
--- a/src/main_thread/decrypt/get_media_keys.ts
+++ b/src/main_thread/decrypt/get_media_keys.ts
@@ -14,9 +14,12 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../compat/browser_compatibility_types";
+import type {
+  IMediaElement,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../../compat/browser_compatibility_types";
 import canReuseMediaKeys from "../../compat/can_reuse_media_keys";
-import type { ICustomMediaKeys, ICustomMediaKeySystemAccess } from "../../compat/eme";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import type { IKeySystemOption } from "../../public_types";
@@ -50,14 +53,14 @@ function createPersistentSessionsStorage(
 /** Object returned by `getMediaKeysInfos`. */
 export interface IMediaKeysInfos {
   /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
   /**
    * The MediaKeySystemConfiguration that has been provided to the
    * `requestMediaKeySystemAccess` API.
    */
   askedConfiguration: MediaKeySystemConfiguration;
   /** The MediaKeys instance. */
-  mediaKeys: MediaKeys | ICustomMediaKeys;
+  mediaKeys: IMediaKeys;
   /** Stores allowing to create and retrieve MediaKeySessions. */
   stores: IMediaKeySessionStores;
   /** IKeySystemOption compatible to the created MediaKeys instance. */
@@ -145,8 +148,8 @@ export default async function getMediaKeysInfos(
  * @returns {Promise.<MediaKeys>}
  */
 async function createMediaKeys(
-  mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess,
-): Promise<MediaKeys | ICustomMediaKeys> {
+  mediaKeySystemAccess: IMediaKeySystemAccess,
+): Promise<IMediaKeys> {
   log.info("DRM: Calling createMediaKeys on the MediaKeySystemAccess");
   try {
     const mediaKeys = await mediaKeySystemAccess.createMediaKeys();
diff --git a/src/main_thread/decrypt/session_events_listener.ts b/src/main_thread/decrypt/session_events_listener.ts
index 96d075ba38..77a50726c0 100644
--- a/src/main_thread/decrypt/session_events_listener.ts
+++ b/src/main_thread/decrypt/session_events_listener.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../compat/eme";
+import type { IMediaKeySession } from "../../compat/browser_compatibility_types";
 import {
   onKeyError,
   onKeyMessage,
@@ -40,7 +40,7 @@ import checkKeyStatuses from "./utils/check_key_statuses";
  * @param {Object} cancelSignal
  */
 export default function SessionEventsListener(
-  session: MediaKeySession | ICustomMediaKeySession,
+  session: IMediaKeySession,
   keySystemOptions: IKeySystemOption,
   keySystem: string,
   callbacks: ISessionEventListenerCallbacks,
@@ -286,7 +286,7 @@ function formatGetLicenseError(error: unknown): IPlayerError {
  * @returns {Promise}
  */
 async function updateSessionWithMessage(
-  session: MediaKeySession | ICustomMediaKeySession,
+  session: IMediaKeySession,
   message: BufferSource,
 ): Promise<void> {
   log.info("DRM: Updating MediaKeySession with message");
diff --git a/src/main_thread/decrypt/set_server_certificate.ts b/src/main_thread/decrypt/set_server_certificate.ts
index 6336e9c7cf..46b2dbc97d 100644
--- a/src/main_thread/decrypt/set_server_certificate.ts
+++ b/src/main_thread/decrypt/set_server_certificate.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeys } from "../../compat/eme";
+import type { IMediaKeys } from "../../compat/browser_compatibility_types";
 import { EncryptedMediaError, isKnownError } from "../../errors";
 import log from "../../log";
 import type { IPlayerError } from "../../public_types";
@@ -35,11 +35,11 @@ import ServerCertificateStore from "./utils/server_certificate_store";
  * @returns {Promise}
  */
 async function setServerCertificate(
-  mediaKeys: ICustomMediaKeys | MediaKeys,
+  mediaKeys: IMediaKeys,
   serverCertificate: BufferSource,
 ): Promise<unknown> {
   try {
-    const res = await (mediaKeys as MediaKeys).setServerCertificate(serverCertificate);
+    const res = await mediaKeys.setServerCertificate(serverCertificate);
     // Note: Even if `setServerCertificate` technically should return a
     // Promise.<boolean>, this is not technically always true.
     // Thus we prefer to return unknown here.
@@ -63,7 +63,7 @@ async function setServerCertificate(
  * @returns {Promise.<Object>}
  */
 export default async function trySettingServerCertificate(
-  mediaKeys: ICustomMediaKeys | MediaKeys,
+  mediaKeys: IMediaKeys,
   serverCertificate: BufferSource,
 ): Promise<
   | { type: "success"; value: unknown }
diff --git a/src/main_thread/decrypt/utils/check_key_statuses.ts b/src/main_thread/decrypt/utils/check_key_statuses.ts
index c97e0c863f..039630abe1 100644
--- a/src/main_thread/decrypt/utils/check_key_statuses.ts
+++ b/src/main_thread/decrypt/utils/check_key_statuses.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../../compat/eme";
+import type { IMediaKeySession } from "../../../compat/browser_compatibility_types";
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
 import log from "../../../log";
@@ -83,7 +83,7 @@ type IKeyStatusesForEach = (
  * @returns {Object} - Warnings to send, whitelisted and blacklisted key ids.
  */
 export default function checkKeyStatuses(
-  session: MediaKeySession | ICustomMediaKeySession,
+  session: IMediaKeySession,
   options: IKeyStatusesCheckingOptions,
   keySystem: string,
 ): {
diff --git a/src/main_thread/decrypt/utils/is_session_usable.ts b/src/main_thread/decrypt/utils/is_session_usable.ts
index 129d3be4d2..f83e1b2727 100644
--- a/src/main_thread/decrypt/utils/is_session_usable.ts
+++ b/src/main_thread/decrypt/utils/is_session_usable.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../../compat/eme";
+import type { IMediaKeySession } from "../../../compat/browser_compatibility_types";
 import log from "../../../log";
 import arrayIncludes from "../../../utils/array_includes";
 
@@ -25,9 +25,7 @@ import arrayIncludes from "../../../utils/array_includes";
  * @param {MediaKeySession} loadedSession
  * @returns {MediaKeySession}
  */
-export default function isSessionUsable(
-  loadedSession: MediaKeySession | ICustomMediaKeySession,
-): boolean {
+export default function isSessionUsable(loadedSession: IMediaKeySession): boolean {
   if (loadedSession.sessionId === "") {
     return false;
   }
diff --git a/src/main_thread/decrypt/utils/loaded_sessions_store.ts b/src/main_thread/decrypt/utils/loaded_sessions_store.ts
index 888768ecec..537151e997 100644
--- a/src/main_thread/decrypt/utils/loaded_sessions_store.ts
+++ b/src/main_thread/decrypt/utils/loaded_sessions_store.ts
@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeys, ICustomMediaKeySession } from "../../../compat/eme";
+import type {
+  IMediaKeySession,
+  IMediaKeys,
+} from "../../../compat/browser_compatibility_types";
 import { closeSession, generateKeyRequest, loadSession } from "../../../compat/eme";
 import log from "../../../log";
 import assert from "../../../utils/assert";
@@ -32,7 +35,7 @@ import KeySessionRecord from "./key_session_record";
  */
 export default class LoadedSessionsStore {
   /** MediaKeys instance on which the MediaKeySessions are created. */
-  private readonly _mediaKeys: MediaKeys | ICustomMediaKeys;
+  private readonly _mediaKeys: IMediaKeys;
 
   /** Store unique MediaKeySession information per initialization data. */
   private _storage: IStoredSessionEntry[];
@@ -42,7 +45,7 @@ export default class LoadedSessionsStore {
    * loaded MediaKeySessions on the given MediaKeys instance.
    * @param {MediaKeys} mediaKeys
    */
-  constructor(mediaKeys: MediaKeys | ICustomMediaKeys) {
+  constructor(mediaKeys: IMediaKeys) {
     this._mediaKeys = mediaKeys;
     this._storage = [];
   }
@@ -128,7 +131,7 @@ export default class LoadedSessionsStore {
    * @returns {Object|null}
    */
   public getEntryForSession(
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession,
+    mediaKeySession: IMediaKeySession,
   ): IStoredSessionEntry | null {
     for (let i = this._storage.length - 1; i >= 0; i--) {
       const stored = this._storage[i];
@@ -144,14 +147,14 @@ export default class LoadedSessionsStore {
    * to the LoadedSessionsStore that a license-request is pending so
    * session-closing orders are properly scheduled after it is done.
    * @param {Object} mediaKeySession
-   * @param {string} initializationDataType - Initialization data type given
-   * e.g. by the "encrypted" event for the corresponding request.
+   * @param {string|undefined} initializationDataType - Initialization data type
+   * given e.g. by the "encrypted" event for the corresponding request.
    * @param {Uint8Array} initializationData - Initialization data given e.g. by
    * the "encrypted" event for the corresponding request.
    * @returns {Promise}
    */
   public async generateLicenseRequest(
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession,
+    mediaKeySession: IMediaKeySession,
     initializationDataType: string | undefined,
     initializationData: Uint8Array,
   ): Promise<unknown> {
@@ -212,7 +215,7 @@ export default class LoadedSessionsStore {
    * @returns {Promise}
    */
   public async loadPersistentSession(
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession,
+    mediaKeySession: IMediaKeySession,
     sessionId: string,
   ): Promise<boolean> {
     let entry: IStoredSessionEntry | undefined;
@@ -266,9 +269,7 @@ export default class LoadedSessionsStore {
    * @param {Object} mediaKeySession
    * @returns {Promise}
    */
-  public async closeSession(
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession,
-  ): Promise<boolean> {
+  public async closeSession(mediaKeySession: IMediaKeySession): Promise<boolean> {
     let entry: IStoredSessionEntry | undefined;
     for (const stored of this._storage) {
       if (stored.mediaKeySession === mediaKeySession) {
@@ -333,9 +334,7 @@ export default class LoadedSessionsStore {
    * @param {MediaKeySession} mediaKeySession
    * @returns {boolean}
    */
-  public removeSessionWithoutClosingIt(
-    mediaKeySession: MediaKeySession | ICustomMediaKeySession,
-  ): boolean {
+  public removeSessionWithoutClosingIt(mediaKeySession: IMediaKeySession): boolean {
     assert(
       mediaKeySession.sessionId === "",
       "Initialized `MediaKeySession`s should always be properly closed",
@@ -433,7 +432,7 @@ export interface IStoredSessionEntry {
   keySessionRecord: KeySessionRecord;
 
   /** The MediaKeySession created. */
-  mediaKeySession: MediaKeySession | ICustomMediaKeySession;
+  mediaKeySession: IMediaKeySession;
 
   /**
    * The MediaKeySessionType (e.g. "temporary" or "persistent-license") with
@@ -494,7 +493,7 @@ export interface IStoredSessionEntry {
  * @returns {Promise}
  */
 async function safelyCloseMediaKeySession(
-  mediaKeySession: MediaKeySession | ICustomMediaKeySession,
+  mediaKeySession: IMediaKeySession,
 ): Promise<void> {
   log.debug("DRM: Trying to close a MediaKeySession", mediaKeySession.sessionId);
   try {
diff --git a/src/main_thread/decrypt/utils/media_keys_infos_store.ts b/src/main_thread/decrypt/utils/media_keys_infos_store.ts
index d7fc83bb67..49e24b7f86 100644
--- a/src/main_thread/decrypt/utils/media_keys_infos_store.ts
+++ b/src/main_thread/decrypt/utils/media_keys_infos_store.ts
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-import type { IMediaElement } from "../../../compat/browser_compatibility_types";
 import type {
-  ICustomMediaKeys,
-  ICustomMediaKeySystemAccess,
-  IEmeApiImplementation,
-} from "../../../compat/eme";
+  IMediaElement,
+  IMediaKeySystemAccess,
+  IMediaKeys,
+} from "../../../compat/browser_compatibility_types";
+import type { IEmeApiImplementation } from "../../../compat/eme";
 import type { IKeySystemOption } from "../../../public_types";
 import type LoadedSessionsStore from "./loaded_sessions_store";
 
@@ -40,10 +40,10 @@ export interface IMediaElementMediaKeysInfos {
    * Last MediaKeySystemAccess used to create a MediaKeys bound to that
    * HTMLMediaElement.
    */
-  mediaKeySystemAccess: ICustomMediaKeySystemAccess | MediaKeySystemAccess;
+  mediaKeySystemAccess: IMediaKeySystemAccess;
 
   /** Last MediaKeys instance bound to that HTMLMediaElement. */
-  mediaKeys: MediaKeys | ICustomMediaKeys;
+  mediaKeys: IMediaKeys;
 
   /**
    * Store containing information about every MediaKeySession active on the
diff --git a/src/main_thread/decrypt/utils/persistent_sessions_store.ts b/src/main_thread/decrypt/utils/persistent_sessions_store.ts
index b57f76c52b..74e2e73d3f 100644
--- a/src/main_thread/decrypt/utils/persistent_sessions_store.ts
+++ b/src/main_thread/decrypt/utils/persistent_sessions_store.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeySession } from "../../../compat/eme";
+import type { IMediaKeySession } from "../../../compat/browser_compatibility_types";
 import log from "../../../log";
 import type {
   IPersistentLicenseConfig,
@@ -99,7 +99,6 @@ export default class PersistentSessionsStore {
   /**
    * Retrieve an entry based on its initialization data.
    * @param {Object}  initData
-   * @param {string|undefined} initDataType
    * @returns {Object|null}
    */
   public get(initData: IProcessedProtectionData): IPersistentSessionInfo | null {
@@ -114,8 +113,7 @@ export default class PersistentSessionsStore {
    * re-used to then be able to implement a caching replacement algorithm based
    * on the least-recently-used values by just evicting the first values
    * returned by `getAll`.
-   * @param {Uint8Array} initData
-   * @param {string|undefined} initDataType
+   * @param {Object} initData
    * @returns {*}
    */
   public getAndReuse(initData: IProcessedProtectionData): IPersistentSessionInfo | null {
@@ -130,14 +128,14 @@ export default class PersistentSessionsStore {
 
   /**
    * Add a new entry in the PersistentSessionsStore.
-   * @param {Uint8Array}  initData
-   * @param {string|undefined} initDataType
+   * @param {Object}  initData
+   * @param {Array.<Uint8Array>|undefined} keyIds
    * @param {MediaKeySession} session
    */
   public add(
     initData: IProcessedProtectionData,
     keyIds: Uint8Array[] | undefined,
-    session: MediaKeySession | ICustomMediaKeySession,
+    session: IMediaKeySession,
   ): void {
     if (isNullOrUndefined(session) || !isNonEmptyString(session.sessionId)) {
       log.warn("DRM-PSS: Invalid Persisten Session given.");
diff --git a/src/main_thread/decrypt/utils/server_certificate_store.ts b/src/main_thread/decrypt/utils/server_certificate_store.ts
index 78e3fb1e59..c9e121e61c 100644
--- a/src/main_thread/decrypt/utils/server_certificate_store.ts
+++ b/src/main_thread/decrypt/utils/server_certificate_store.ts
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { ICustomMediaKeys } from "../../../compat/eme";
+import type { IMediaKeys } from "../../../compat/browser_compatibility_types";
 import hashBuffer from "../../../utils/hash_buffer";
 
 /**
@@ -31,7 +31,7 @@ import hashBuffer from "../../../utils/hash_buffer";
  * EME APIs failed or had an unexpected behavior).
  */
 const serverCertificateHashesMap = new WeakMap<
-  MediaKeys | ICustomMediaKeys,
+  IMediaKeys,
   { hash: number; serverCertificate: Uint8Array } | null
 >();
 
@@ -49,7 +49,7 @@ export default {
    * server certificate attached to this MediaKeys is for now invalid.
    * @param {MediaKeys | Object} mediaKeys
    */
-  prepare(mediaKeys: MediaKeys | ICustomMediaKeys): void {
+  prepare(mediaKeys: IMediaKeys): void {
     serverCertificateHashesMap.set(mediaKeys, null);
   },
 
@@ -64,10 +64,7 @@ export default {
    * @param {MediaKeys | Object} mediaKeys
    * @param {ArrayBufferView | BufferSource} serverCertificate
    */
-  set(
-    mediaKeys: MediaKeys | ICustomMediaKeys,
-    serverCertificate: ArrayBufferView | BufferSource,
-  ): void {
+  set(mediaKeys: IMediaKeys, serverCertificate: ArrayBufferView | BufferSource): void {
     const formattedServerCertificate: Uint8Array =
       serverCertificate instanceof Uint8Array
         ? serverCertificate
@@ -92,7 +89,7 @@ export default {
    * @param {MediaKeys} mediaKeys
    * @returns {Boolean|undefined}
    */
-  hasOne(mediaKeys: MediaKeys | ICustomMediaKeys): boolean | undefined {
+  hasOne(mediaKeys: IMediaKeys): boolean | undefined {
     const currentServerCertificate = serverCertificateHashesMap.get(mediaKeys);
     if (currentServerCertificate === undefined) {
       return false;
@@ -111,10 +108,7 @@ export default {
    * @param {ArrayBufferView | BufferSource} serverCertificate
    * @returns {boolean}
    */
-  has(
-    mediaKeys: MediaKeys | ICustomMediaKeys,
-    serverCertificate: ArrayBufferView | BufferSource,
-  ): boolean {
+  has(mediaKeys: IMediaKeys, serverCertificate: ArrayBufferView | BufferSource): boolean {
     const serverCertificateHash = serverCertificateHashesMap.get(mediaKeys);
     if (serverCertificateHash === undefined || serverCertificateHash === null) {
       return false;
diff --git a/src/parsers/containers/isobmff/extract_complete_chunks.ts b/src/parsers/containers/isobmff/extract_complete_chunks.ts
index cb7a4e87aa..836a756d8e 100644
--- a/src/parsers/containers/isobmff/extract_complete_chunks.ts
+++ b/src/parsers/containers/isobmff/extract_complete_chunks.ts
@@ -21,7 +21,7 @@ import findCompleteBox from "./find_complete_box";
  * Take a chunk of ISOBMFF data and extract complete `moof`+`mdat` subsegments
  * which are ready to be decoded.
  * Returns a tuple of two containing first an array of those subsegments
- * followed by tha last un-decodable part.
+ * followed by the last un-decodable part.
  * @param {Uint8Array} buffer
  * @returns {Array}
  */