@amazon/vinyl 1.0.0

package/dist/types/ts4.7/drm/DrmController.d.ts

@@ -0,0 +1,103 @@
+import { type AnyRecord, type Maybe, type ReadonlyAbort, type ReadonlyEventHost } from '@amazon/vinyl-util';
+import type { DrmInitDataType } from '../streaming/DrmInitDataType';
+import type { DrmKeySystem } from '../drm/DrmKeySystem';
+import type { MediaFormatMetadata } from '../streaming/MediaQualityMetadata';
+import type { BasicErrorEvent } from '../event/BasicErrorEvent';
+import type { DrmOptions } from '../drm/DrmOptions';
+export interface DrmControllerEventMap {
+    /**
+     * A DRM error occurred.
+     */
+    readonly error: BasicErrorEvent;
+    /**
+     * Emitted when the error state has been reset.
+     */
+    readonly reset: AnyRecord;
+    /**
+     * The media keys have been created and set.
+     *
+     * This will happen after the first call to `initialize` or after the first 'encrypted' event is handled.
+     */
+    readonly mediaKeysSet: MediaKeysSetEvent;
+    /**
+     * Dispatched after a key session has been created.
+     */
+    readonly sessionCreate: KeySessionEvent;
+    /**
+     * Dispatched after a key session has been closed.
+     */
+    readonly sessionClose: KeySessionEvent;
+}
+export interface MediaKeysSetEvent {
+    readonly keySystem: DrmKeySystem;
+}
+export interface KeySessionEvent {
+    readonly mimeType: string;
+    readonly initDataType: DrmInitDataType;
+}
+/**
+ * DrmController manages media keys and sessions, provides tracks a way to declare their content protections.
+ */
+export interface DrmController extends ReadonlyEventHost<DrmControllerEventMap> {
+    /**
+     * The last error emitted.
+     * Use `reset` to reset error state.
+     */
+    readonly error: Error | null;
+    /**
+     * Configures this DrmController for the current track.
+     * This will override any player-level configuration.
+     * @param options
+     */
+    configure(options: Maybe<Partial<DrmOptions>>): void;
+    /**
+     * Returns true if Encrypted Media Extensions are supported.
+     */
+    isEmeSupported(): boolean;
+    /**
+     * Resolves to true if the given encryption metadata is supported.
+     * @param drmInfo
+     */
+    isSupported(drmInfo: MediaFormatMetadata): Promise<DrmKeySystemSupport>;
+    /**
+     * Initializes media keys if they have not yet been created and attached, creates a key session if the
+     * selected `DrmProtection` contains PSSH data.
+     *
+     * The first supported key system will be used.
+     * Once a key system has been set, it cannot be changed, all future content protections will be
+     * expected to contain the supported key system.
+     *
+     * @param drmInfo Format metadata for the representation. May contain content protections.
+     * @param abort If aborted, the created session will be closed.
+     */
+    initializeForPlayback(drmInfo: MediaFormatMetadata | null, abort?: ReadonlyAbort): void;
+    /**
+     * Sets content protection data on drm controller for the currently buffering media.
+     *
+     * The key session will be created on the 'encrypted' event when the decoder has been initialized.
+     *
+     * @param drmInfo Format metadata for the representation. May contain content protections.
+     * @param abort If aborted, the created session from an 'encrypted' event will be closed.
+     */
+    setBufferingDrmInfo(drmInfo: MediaFormatMetadata | null, abort?: ReadonlyAbort): void;
+    /**
+     * Clears all active DRM sessions.
+     * This should not be called unless the audio source has been cleared.
+     */
+    closeSessions(): void;
+    /**
+     * Resets the error state.
+     */
+    reset(): void;
+}
+export type DrmKeySystemSupport = {
+    /**
+     * True if the key system is supported.
+     */
+    readonly supported: boolean;
+    /**
+     * True if the key system and persistent state is supported.
+     */
+    readonly persistentState: boolean;
+};
+//# sourceMappingURL=DrmController.d.ts.map

package/dist/types/ts4.7/drm/DrmControllerImpl.d.ts

@@ -0,0 +1,112 @@
+import { EventHostImpl, type Maybe, type ReadonlyAbort } from '@amazon/vinyl-util';
+import { type DrmOptions } from '../drm/DrmOptions';
+import type { DrmController, DrmControllerEventMap, DrmKeySystemSupport } from '../drm/DrmController';
+import type { CommonEme, CommonMediaKeyMessageEvent, CommonMediaKeys, CommonMediaKeySession } from '../drm/commonEme/CommonEme';
+import type { MediaFormatMetadata } from '../streaming/MediaQualityMetadata';
+/**
+ * The number of seconds a license request will be allowed before timing out.
+ * This should be higher than the network timeout.
+ *
+ * In practice, network requests will time out before this, and a license timeout
+ * indicates a stalled promise result from the license provider.
+ */
+export declare const LICENSE_TIMEOUT = 90;
+/**
+ * Dependencies for creating DrmController.
+ */
+export interface DrmControllerImplDeps {
+    readonly media: HTMLMediaElement;
+    readonly commonEme: CommonEme | null;
+}
+export interface DrmControllerMessageProps {
+    readonly mediaKeys: CommonMediaKeys;
+    readonly session: CommonMediaKeySession;
+    readonly event: CommonMediaKeyMessageEvent;
+}
+export declare class DrmControllerImpl extends EventHostImpl<DrmControllerEventMap> implements DrmController {
+    private readonly deps;
+    get [Symbol.toStringTag](): string;
+    private readonly optionsBase;
+    private options;
+    private mediaKeys;
+    private mediaKeysPromise;
+    private readonly sessions;
+    private _error;
+    private drmInfo;
+    private sessionAbort;
+    private pendingMessageProps;
+    private readonly disposer;
+    constructor(deps: DrmControllerImplDeps, options?: Maybe<Partial<DrmOptions>>);
+    configure(options: Maybe<Partial<DrmOptions>>): void;
+    private get licenseProvider();
+    get error(): Error | null;
+    isEmeSupported(): boolean;
+    isSupported(drmInfo: MediaFormatMetadata): Promise<DrmKeySystemSupport>;
+    private checkIsSupportedCached;
+    private readonly handleEncryptedEvent;
+    /**
+     * Resolves to media keys attached to the element.
+     * The media keys will only be created and set once until `clearMediaKeys` is next called.
+     */
+    private attachMediaKeys;
+    /**
+     * Creates a session for the given initialization data if none currently exists.
+     * This will be done either after an 'encrypted' event or when drm metadata contains initialization data.
+     * The new session will be added to the current sessions list.
+     */
+    private maybeCreateSession;
+    initializeForPlayback(drmInfo: MediaFormatMetadata | null, abort?: ReadonlyAbort): void;
+    setBufferingDrmInfo(drmInfo: MediaFormatMetadata | null, abort?: ReadonlyAbort): void;
+    /**
+     * If the drm metadata contains initialization data for the current key system, create a new session.
+     * Otherwise, wait for the 'encrypted' event for the initialization data.
+     */
+    private createSessionFromInitData;
+    /**
+     * Creates a CommonMediaKeySystemAccess object from the given content protection settings.
+     */
+    private createAccess;
+    /**
+     * Creates a list of the MediaKeySystemAccess configurations to try for the given media format options.
+     */
+    private createMediaKeySystemAccessParams;
+    private getMediaKeySystemOptions;
+    /**
+     * Creates a new key session and adds a message handler.
+     */
+    private createNewSession;
+    /**
+     * Invoked when the content decryption module needs to interact with the license server.
+     */
+    private messageHandler;
+    /**
+     * Closes all active DRM sessions.
+     * This should not be called unless the audio source has been cleared.
+     */
+    closeSessions(): void;
+    private closeSession;
+    /**
+     * A handler which dispatches an error event.
+     * Only one error event will be emitted per unique PSSH.
+     * When track protections is set again, another error event may be emitted.
+     */
+    private readonly handleError;
+    /**
+     * Returns the number of currently active sessions.
+     */
+    get activeSessions(): number;
+    /**
+     * Clears the media keys from the element if they were set.
+     */
+    private clearMediaKeys;
+    protected abortIfDisposed(): void;
+    reset(): void;
+    get disposed(): boolean;
+    dispose(): void;
+    private getSessionByInitData;
+    /**
+     * Sort the key systems first by their priority, then by the presence of a license uri.
+     */
+    private readonly keySystemComparator;
+}
+//# sourceMappingURL=DrmControllerImpl.d.ts.map

package/dist/types/ts4.7/drm/DrmKeySystem.d.ts

@@ -0,0 +1,61 @@
+import type { ValueSchema } from '@amazon/vinyl-validation';
+export declare enum DrmKeySystem {
+    /**
+     * Plain text encryption.
+     */
+    CLEAR_KEY = "org.w3.clearkey",
+    /**
+     * Google's Widevine.
+     */
+    WIDEVINE = "com.widevine.alpha",
+    /**
+     * Microsoft's PlayReady.
+     *
+     * - Deprecated.
+     * - Will be removed in a future release.
+     * - Non-compliant with any version of the EME specification.
+     */
+    PLAY_READY = "com.microsoft.playready",
+    /**
+     * Microsoft's PlayReady for Chromecast.
+     *
+     * - Deprecated.
+     * - Will be removed in a future release.
+     * - Non-compliant with any version of the EME specification.
+     */
+    PLAY_READY_CHROMECAST = "com.chromecast.playready",
+    /**
+     * Microsoft's PlayReady.
+     *
+     * - Security Level 2000.
+     * - Best effort compliance with latest EME specification.
+     */
+    PLAY_READY_RECOMMENDATION = "com.microsoft.playready.recommendation",
+    /**
+     * Microsoft's PlayReady.
+     *
+     * - Supported on devices with required hardware.
+     * - Security Level 3000.
+     * - Best effort compliance with latest EME specification.
+     */
+    PLAY_READY_3000 = "com.microsoft.playready.recommendation.3000",
+    /**
+     * Apple's Fairplay for modern EME.
+     */
+    FAIR_PLAY = "com.apple.fps",
+    /**
+     * Apple's Fairplay for legacy Apple Media Keys.
+     */
+    FAIR_PLAY_1_0 = "com.apple.fps.1_0"
+}
+/**
+ * Validates that the key system value is a string.
+ * While DrmKeySystem is an enum to be useful for providing known key systems,
+ * avoid strict validation to allow for unknown key systems.
+ */
+export declare const drmKeySystemValidator: ValueSchema<DrmKeySystem>;
+export declare const PLAY_READY_KEY_SYSTEMS: readonly DrmKeySystem[];
+export declare function isPlayReady(keySystem: DrmKeySystem): boolean;
+export declare const FAIR_PLAY_KEY_SYSTEMS: readonly DrmKeySystem[];
+export declare function isFairPlay(keySystem: DrmKeySystem): boolean;
+//# sourceMappingURL=DrmKeySystem.d.ts.map

package/dist/types/ts4.7/drm/DrmKeySystemResolver.d.ts

@@ -0,0 +1,12 @@
+import { type ReadonlyRecord } from '@amazon/vinyl-util';
+import { DrmKeySystem } from '../drm/DrmKeySystem';
+/**
+ * Given a ContentProtection schemeIdUri, returns the {@link DrmKeySystem} it represents.
+ * Not all scheme ids will match to a DrmKeySystem. If none are matched, null is returned.
+ * For example, CENC 'urn:mpeg:dash:mp4protection:2011' has no key system and shouldn't be used
+ * to create a key session.
+ */
+export type DrmKeySystemResolver = (schemeIdUri: string) => readonly DrmKeySystem[];
+export declare function getDefaultSchemeToKeySystem(): ReadonlyRecord<string, readonly DrmKeySystem[]>;
+export declare const defaultDrmKeySystemResolver: DrmKeySystemResolver;
+//# sourceMappingURL=DrmKeySystemResolver.d.ts.map

package/dist/types/ts4.7/drm/DrmOptions.d.ts

@@ -0,0 +1,92 @@
+import type { ReadonlyRecord, ValueProvider } from '@amazon/vinyl-util';
+import type { DrmInitDataType } from '../streaming/DrmInitDataType';
+import type { MediaFormatMetadata } from '../streaming/MediaQualityMetadata';
+import { type ObjectSchema, type ValueSchema } from '@amazon/vinyl-validation';
+import { DrmKeySystem } from './DrmKeySystem';
+import { type LicenseProvider, type LicenseServerOptions } from '../drm/licenseProvider/LicenseProvider';
+/**
+ * DrmRobustness is the requested security level for audio or video decryption.
+ */
+export declare enum DrmRobustness {
+    SW_SECURE_CRYPTO = "SW_SECURE_CRYPTO",
+    SW_SECURE_DECODE = "SW_SECURE_DECODE",
+    HW_SECURE_CRYPTO = "HW_SECURE_CRYPTO",
+    HW_SECURE_DECODE = "HW_SECURE_DECODE",
+    HW_SECURE_ALL = "HW_SECURE_ALL"
+}
+/**
+ * DrmConfig configures DrmController and LicenseProvider.
+ */
+export interface DrmOptions {
+    readonly keySystems: {
+        readonly [p in DrmKeySystem]?: DrmKeySystemOptions;
+    } & {
+        readonly [DrmKeySystem.CLEAR_KEY]?: DrmClearKeySystemOptions;
+    } & {
+        /**
+         * A wildcard to match any key system when there wasn't a match.
+         */
+        readonly ['*']?: DrmKeySystemOptions;
+    };
+    /**
+     *
+     * If not set, the license provider from the player dependencies will
+     * be used.
+     */
+    readonly licenseProvider?: LicenseProvider;
+}
+/**
+ * Clear key system options that extend base DRM key system options with clear
+ * key mappings. Used for unencrypted content or testing scenarios where keys
+ * are provided in plain text.
+ */
+export type DrmClearKeySystemOptions = DrmKeySystemOptions & {
+    readonly keys: ReadonlyRecord<string, string>;
+};
+export interface DrmKeySystemOptions {
+    /**
+     * License server configuration used to make license requests.
+     */
+    readonly licenseServer?: ValueProvider<LicenseServerOptions>;
+    /**
+     * Audio-specific DRM configuration.
+     */
+    readonly audio?: DrmMediaKeySystemOptions;
+    /**
+     * Video-specific DRM configuration.
+     */
+    readonly video?: DrmMediaKeySystemOptions;
+    /**
+     * Key systems with a higher priority take precedence.
+     * If two key systems have equal priority, the order will be as it appears
+     * in DrmInfo (provided by the manifest).
+     */
+    readonly priority?: number;
+    /**
+     * Transform applied to init data before session creation.
+     * Always invoked for every key system. The default implementation
+     * handles {@link DrmKeySystem.FAIR_PLAY_1_0} by packing the init data,
+     * content ID, and server certificate into the format expected by
+     * WebKit-prefixed EME. For all other key systems, returns init data
+     * unchanged.
+     */
+    readonly initDataTransformer?: InitDataTransformer;
+}
+/**
+ * Transforms raw init data before it is passed to the CDM for session creation.
+ *
+ * @param initData - The raw initialization data.
+ * @param initDataType - The initialization data type (e.g. 'cenc', 'skd').
+ * @param drmInfo - The media format metadata for the current content.
+ * @returns The transformed init data to pass to the CDM.
+ */
+export type InitDataTransformer = (initData: Uint8Array, initDataType: DrmInitDataType, drmInfo: MediaFormatMetadata) => Uint8Array;
+export interface DrmMediaKeySystemOptions {
+    readonly robustness?: DrmRobustness;
+}
+export declare const drmRobustnessValidator: ValueSchema<DrmRobustness>;
+export declare const drmMediaKeySystemOptionsValidator: ObjectSchema<DrmMediaKeySystemOptions>;
+export declare const drmKeySystemOptionsValidator: ObjectSchema<DrmKeySystemOptions>;
+export declare const drmClearKeySystemOptionsValidator: ObjectSchema<DrmClearKeySystemOptions>;
+export declare const drmOptionsValidator: ObjectSchema<DrmOptions>;
+//# sourceMappingURL=DrmOptions.d.ts.map

package/dist/types/ts4.7/drm/commonEme/CommonEme.d.ts

@@ -0,0 +1,150 @@
+/**
+ * An common interface to unify multiple EME implementations.
+ * @module
+ */
+import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import type { Json, ReadonlyEventHost, Unsubscribe } from '@amazon/vinyl-util';
+import { ReportableError } from '@amazon/vinyl-util';
+import type { EncryptedInitData } from '../../drm/commonEme/EncryptedInitData';
+import type { DrmInitDataType } from '../../streaming/DrmInitDataType';
+import type { BasicErrorEvent } from '../../event/BasicErrorEvent';
+/**
+ * Top-level Common EME methods for initiating encrypted audio session.
+ *
+ * Created to unify standard and non-standard EME interfaces.
+ */
+export interface CommonEme {
+    requestMediaKeySystemAccess(keySystem: DrmKeySystem, supportedConfigurations: readonly MediaKeySystemConfiguration[]): Promise<CommonMediaKeySystemAccess>;
+    addEncryptedListener(element: HTMLMediaElement, handler: (event: CommonMediaEncryptedEvent) => void): Unsubscribe;
+}
+export interface CommonMediaEncryptedEvent {
+    /**
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaEncryptedEvent/initData)
+     */
+    readonly initData: EncryptedInitData | null;
+    /**
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaEncryptedEvent/initDataType)
+     */
+    readonly initDataType: string;
+}
+/**
+ * This provides a common interface for MediaKeySystemAccess EME implementations.
+ */
+export interface CommonMediaKeySystemAccess {
+    readonly keySystem: DrmKeySystem;
+    createMediaKeys(): Promise<CommonMediaKeys>;
+}
+/**
+ * This provides a common interface for MediaKeys EME implementations.
+ */
+export interface CommonMediaKeys {
+    readonly keySystem: DrmKeySystem;
+    /**
+     * Sets the media keys on the given element.
+     * @param element
+     */
+    setOnElement(element: HTMLMediaElement): Promise<void>;
+    /**
+     * Clears the media keys from the given element.
+     * This is only allowed if the element's src isn't set.
+     *   https://bugs.chromium.org/p/chromium/issues/detail?id=462365#c7
+     * @param element
+     */
+    clearFromElement(element: HTMLMediaElement): Promise<void>;
+    /**
+     * Sets the server certificate on the media keys.
+     *
+     * A Promise that resolves to a boolean. If the Key System implementation
+     * represented by this object's content decryption module's implementation
+     * value does not support server certificates, return a promise resolved
+     * with false.
+     *
+     * @param certificate The server certificate data.
+     */
+    setServerCertificate(certificate: BufferSource): Promise<boolean>;
+    /**
+     * Creates the key session.
+     *
+     * @param mimeType
+     * @param initDataType
+     * @param initData The initialization data from the 'encrypted' event.
+     */
+    createSession(mimeType: string, initDataType: DrmInitDataType, initData: EncryptedInitData): CommonMediaKeySession;
+}
+/**
+ * Common media key session events
+ */
+export interface CommonMediaKeySessionEventMap {
+    /**
+     * Dispatched when a message is generated by the content decryption module.
+     */
+    readonly message: CommonMediaKeyMessageEvent;
+    /**
+     * Dispatched when an error occurs.
+     */
+    readonly error: BasicErrorEvent;
+    /**
+     * Dispatched when the session is forcibly closed by the CDM.
+     */
+    readonly closed: CommonMediaKeySessionClosedEvent;
+}
+/**
+ * This provides a common interface for MediaKeySession EME implementations.
+ */
+export interface CommonMediaKeySession extends ReadonlyEventHost<CommonMediaKeySessionEventMap> {
+    readonly mimeType: string;
+    readonly initDataType: DrmInitDataType;
+    readonly initData: EncryptedInitData;
+    /**
+     * Updates the session with the license data.
+     * @param key
+     */
+    update(key: ArrayBuffer): Promise<void>;
+    /**
+     * Returns true if the session has been disposed.
+     */
+    get disposed(): boolean;
+    /**
+     * Closes the session, and removes session handling and event listeners, freeing this session
+     * handler for GC.
+     *
+     * Note: The audio source should be cleared first.
+     */
+    dispose(): void;
+}
+/**
+ * A media key session error, translated from the specific media key session implementation.
+ */
+export declare class CommonMediaKeySessionError extends ReportableError {
+    readonly code: number;
+    readonly codeStr: MediaKeySessionErrorType;
+    readonly systemCode: number;
+    readonly systemCodeStr: MediaKeySessionErrorType;
+    get [Symbol.toStringTag](): string;
+    constructor(code: number, codeStr: MediaKeySessionErrorType, systemCode: number, systemCodeStr: MediaKeySessionErrorType);
+    toJSON(): Json;
+}
+/**
+ * Common media key message event body.
+ */
+export interface CommonMediaKeyMessageEvent {
+    readonly message: ArrayBuffer;
+}
+export interface CommonMediaKeySessionClosedEvent {
+    /**
+     * The reason the session was closed.
+     */
+    readonly reason: MediaKeySessionClosedReason;
+}
+/**
+ * String representations of session error codes.
+ */
+export declare enum MediaKeySessionErrorType {
+    CLIENT = "CLIENT",
+    DOMAIN = "DOMAIN",
+    HARDWARECHANGE = "HARDWARECHANGE",
+    OUTPUT = "OUTPUT",
+    SERVICE = "SERVICE",
+    UNKNOWN = "UNKNOWN"
+}
+//# sourceMappingURL=CommonEme.d.ts.map

package/dist/types/ts4.7/drm/commonEme/CommonEmeFactory.d.ts

@@ -0,0 +1,28 @@
+import type { CommonEme } from '../../drm/commonEme/CommonEme';
+/**
+ * Common EME Factory provides the first supported implementation of CommonEme.
+ * The priority is WebKit, Standard, then MS.
+ *
+ * Note: WebKit if present is currently prioritized over standard for legacy reasons. This may be an obsolete
+ * requirement. https://jira.music.amazon.dev/browse/PLAYBACK-6072 ticket to investigate.
+ */
+export declare function commonEmeFactory(): CommonEme | null;
+/**
+ * Tests for Standard Eme support.
+ */
+export declare function supportsStandardEme(): boolean;
+/**
+ * Tests for WebKitEme support.
+ */
+export declare function supportsWebKitEme(): boolean;
+/**
+ * Tests for MsEme support.
+ */
+export declare function supportsMsEme(): boolean;
+export type MediaKeySupport = {
+    readonly standardEme: boolean;
+    readonly webkitEme: boolean;
+    readonly msEme: boolean;
+};
+export declare const mediaKeySupportRef: import("@amazon/vinyl-util").GlobalRef<MediaKeySupport>;
+//# sourceMappingURL=CommonEmeFactory.d.ts.map

package/dist/types/ts4.7/drm/commonEme/EncryptedInitData.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This represents the initialization data from the encrypted event.
+ *
+ * - msneedkey: Uint8Array
+ * - webkitneedkey: ArrayBuffer
+ * - encrypted: ArrayBuffer
+ */
+export type EncryptedInitData = ArrayBuffer | Uint8Array;
+//# sourceMappingURL=EncryptedInitData.d.ts.map

package/dist/types/ts4.7/drm/commonEme/MsCommonEme.d.ts

@@ -0,0 +1,68 @@
+import { type Disposable, EventHostImpl, type Unsubscribe } from '@amazon/vinyl-util';
+import { type CommonEme, type CommonMediaKeys, type CommonMediaKeySession, type CommonMediaKeySessionEventMap, type CommonMediaKeySystemAccess, MediaKeySessionErrorType } from './CommonEme';
+import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import { type EncryptedInitData } from './EncryptedInitData';
+import type { DrmInitDataType } from '../../streaming/DrmInitDataType';
+declare global {
+    interface HTMLMediaElementEventMap extends HTMLElementEventMap {
+        readonly msneedkey: MSMediaKeyNeededEvent;
+    }
+    interface MSMediaKeyNeededEvent extends Event {
+        readonly initDataType: string;
+        readonly initData: Uint8Array | null;
+    }
+}
+/**
+ * A CommonEme implementation of MS prefixed Encrypted Media Extensions as supported by IE11/Edge.
+ */
+export declare class MsCommonEme implements CommonEme {
+    requestMediaKeySystemAccess(keySystem: DrmKeySystem, supportedConfigurations: readonly MediaKeySystemConfiguration[]): Promise<CommonMediaKeySystemAccess>;
+    /**
+     * Listens to the element for an encrypted event, returning a disposable handle.
+     */
+    addEncryptedListener(element: HTMLMediaElement, handler: (event: MediaEncryptedEvent) => void): Unsubscribe;
+}
+export declare class MsCommonMediaKeySystemAccess implements CommonMediaKeySystemAccess {
+    readonly keySystem: DrmKeySystem;
+    constructor(keySystem: DrmKeySystem);
+    createMediaKeys(): Promise<CommonMediaKeys>;
+}
+/**
+ * @private
+ */
+export declare class MsCommonMediaKeys implements CommonMediaKeys {
+    readonly keySystem: DrmKeySystem;
+    readonly mediaKeys: MSMediaKeys;
+    constructor(keySystem: DrmKeySystem, mediaKeys: MSMediaKeys);
+    /**
+     * Sets the media keys on the given element.
+     */
+    setOnElement(element: HTMLMediaElement): Promise<void>;
+    /**
+     * Clears the media keys from the given element.
+     */
+    clearFromElement(element: HTMLMediaElement): Promise<void>;
+    setServerCertificate(_certificate: BufferSource): Promise<boolean>;
+    createSession(mimeType: string, initDataType: DrmInitDataType, initData: EncryptedInitData): CommonMediaKeySession;
+}
+/**
+ * @private
+ */
+export declare class MsCommonMediaKeySession extends EventHostImpl<CommonMediaKeySessionEventMap> implements CommonMediaKeySession, Disposable {
+    private readonly session;
+    readonly mimeType: string;
+    readonly initDataType: DrmInitDataType;
+    readonly initData: EncryptedInitData;
+    private _disposed;
+    constructor(session: MSMediaKeySession, mimeType: string, initDataType: DrmInitDataType, initData: EncryptedInitData);
+    private readonly messageHandler;
+    private readonly errorHandler;
+    update(key: ArrayBuffer): Promise<void>;
+    get disposed(): boolean;
+    dispose(): void;
+}
+/**
+ * Returns a string for the WebKit media key error.
+ */
+export declare function msErrorCodeToStr(code: number): MediaKeySessionErrorType;
+//# sourceMappingURL=MsCommonEme.d.ts.map