@amazon/vinyl 1.0.0

package/dist/types/ts4.1/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, ValueSchema } from '@amazon/vinyl-validation';
+import { DrmKeySystem } from './DrmKeySystem';
+import type { LicenseProvider, 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.1/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.
+    */
+    readonly 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.1/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.1/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.1/drm/commonEme/MsCommonEme.d.ts

@@ -0,0 +1,70 @@
+import type { Disposable, Unsubscribe } from '@amazon/vinyl-util';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import type { CommonEme, CommonMediaKeys, CommonMediaKeySession, CommonMediaKeySessionEventMap, CommonMediaKeySystemAccess } from './CommonEme';
+import { 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

package/dist/types/ts4.1/drm/commonEme/StandardCommonEme.d.ts

@@ -0,0 +1,55 @@
+import type { Disposable, Unsubscribe } from '@amazon/vinyl-util';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import type { CommonEme, CommonMediaEncryptedEvent, CommonMediaKeys, CommonMediaKeySession, CommonMediaKeySessionEventMap, CommonMediaKeySystemAccess } from './CommonEme';
+import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import type { EncryptedInitData } from './EncryptedInitData';
+import type { DrmInitDataType } from '../../streaming/DrmInitDataType';
+/**
+ * A CommonEme implementation of unprefixed Encrypted Media Extensions.
+ */
+export declare class StandardCommonEme implements CommonEme {
+    requestMediaKeySystemAccess(keySystem: DrmKeySystem, supportedConfigurations: readonly MediaKeySystemConfiguration[]): Promise<CommonMediaKeySystemAccess>;
+    addEncryptedListener(element: HTMLMediaElement, handler: (event: CommonMediaEncryptedEvent) => void): Unsubscribe;
+}
+/**
+ * CommonMediaKeySystemAccess for unprefixed EME implementations.
+ */
+export declare class StandardCommonMediaKeySystemAccess implements CommonMediaKeySystemAccess {
+    readonly keySystem: DrmKeySystem;
+    private readonly access;
+    constructor(keySystem: DrmKeySystem, access: MediaKeySystemAccess);
+    /**
+     * @return {Promise<CommonMediaKeys>}
+     */
+    createMediaKeys(): Promise<CommonMediaKeys>;
+}
+/**
+ * CommonMediaKeys for unprefixed EME implementations.
+ */
+export declare class StandardCommonMediaKeys implements CommonMediaKeys {
+    readonly keySystem: DrmKeySystem;
+    private readonly mediaKeys;
+    constructor(keySystem: DrmKeySystem, mediaKeys: MediaKeys);
+    setOnElement(element: HTMLMediaElement): Promise<void>;
+    clearFromElement(element: HTMLMediaElement): Promise<void>;
+    setServerCertificate(certificate: BufferSource): Promise<boolean>;
+    createSession(mimeType: string, initDataType: DrmInitDataType, initData: EncryptedInitData): CommonMediaKeySession;
+}
+/**
+ * CommonMediaKeySession for unprefixed EME implementations.
+ */
+export declare class StandardCommonMediaKeySession extends EventHostImpl<CommonMediaKeySessionEventMap> implements CommonMediaKeySession, Disposable {
+    private readonly session;
+    readonly mimeType: string;
+    readonly initDataType: DrmInitDataType;
+    readonly initData: EncryptedInitData;
+    get [Symbol.toStringTag](): string;
+    private _disposed;
+    private readonly messageHandler;
+    constructor(session: MediaKeySession, mimeType: string, initDataType: DrmInitDataType, initData: EncryptedInitData);
+    private generateRequest;
+    update(key: ArrayBufferLike): Promise<void>;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=StandardCommonEme.d.ts.map

package/dist/types/ts4.1/drm/commonEme/WebKitCommonEme.d.ts

@@ -0,0 +1,64 @@
+import type { Unsubscribe } from '@amazon/vinyl-util';
+import type { Disposable } from '@amazon/vinyl-util';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import type { CommonEme, CommonMediaEncryptedEvent, CommonMediaKeys, CommonMediaKeySession, CommonMediaKeySessionEventMap, CommonMediaKeySystemAccess } from './CommonEme';
+import { MediaKeySessionErrorType } from './CommonEme';
+import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import type { EncryptedInitData } from '../../drm/commonEme/EncryptedInitData';
+import type { DrmInitDataType } from '../../streaming/DrmInitDataType';
+declare global {
+    interface HTMLMediaElementEventMap extends HTMLElementEventMap {
+        readonly webkitneedkey: WebKitMediaKeyNeededEvent;
+    }
+    interface WebKitMediaKeyNeededEvent extends Event {
+        readonly initDataType: string;
+        readonly initData: Uint8Array | null;
+    }
+}
+/**
+ * A CommonEme implementation of WebKit-prefixed Encrypted Media Extensions.
+ */
+export declare class WebKitCommonEme implements CommonEme {
+    requestMediaKeySystemAccess(keySystem: DrmKeySystem, supportedConfigurations: readonly MediaKeySystemConfiguration[]): Promise<CommonMediaKeySystemAccess>;
+    addEncryptedListener(element: HTMLMediaElement, handler: (event: CommonMediaEncryptedEvent) => void): Unsubscribe;
+}
+export declare class WebKitCommonMediaKeySystemAccess implements CommonMediaKeySystemAccess {
+    readonly keySystem: DrmKeySystem;
+    constructor(keySystem: DrmKeySystem);
+    createMediaKeys(): Promise<CommonMediaKeys>;
+}
+/** @private */
+export declare class WebKitCommonMediaKeys implements CommonMediaKeys {
+    readonly keySystem: DrmKeySystem;
+    readonly mediaKeys: WebKitMediaKeys;
+    constructor(keySystem: DrmKeySystem, mediaKeys: WebKitMediaKeys);
+    /**
+     * 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 WebKitCommonMediaKeySession extends EventHostImpl<CommonMediaKeySessionEventMap> implements CommonMediaKeySession, Disposable {
+    private readonly session;
+    readonly mimeType: string;
+    readonly initDataType: DrmInitDataType;
+    readonly initData: EncryptedInitData;
+    private _disposed;
+    constructor(session: WebKitMediaKeySession, 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 webkitErrorCodeToStr(code: number): MediaKeySessionErrorType;
+//# sourceMappingURL=WebKitCommonEme.d.ts.map

package/dist/types/ts4.1/drm/commonEme/createDrmErrorHandler.d.ts

@@ -0,0 +1,3 @@
+import { ErrorLevel } from '@amazon/vinyl-util';
+export declare function createDrmErrorHandler(level?: ErrorLevel): (error: Error) => never;
+//# sourceMappingURL=createDrmErrorHandler.d.ts.map

package/dist/types/ts4.1/drm/dom/HTMLMediaElement.d.ts

@@ -0,0 +1,8 @@
+export {};
+declare global {
+    interface HTMLMediaElement {
+        webkitSetMediaKeys?(mediaKeys: WebKitMediaKeys | null): void;
+        msSetMediaKeys?(mediaKeys: MSMediaKeys | null): void;
+    }
+}
+//# sourceMappingURL=HTMLMediaElement.d.ts.map

package/dist/types/ts4.1/drm/dom/MSMediaKeys.d.ts

@@ -0,0 +1,46 @@
+import type { Maybe } from '@amazon/vinyl-util';
+/**
+ * API for MS-prefixed EME.
+ *
+ * @module
+ */
+declare global {
+    class MSMediaKeys {
+        readonly keySystem: string;
+        constructor(keySystem: string);
+        static isTypeSupported(keySystem: string, type?: Maybe<string>): boolean;
+        createSession(type: string, initData: Uint8Array): MSMediaKeySession;
+    }
+    class MSMediaKeyError {
+        static readonly MS_MEDIA_KEYERR_CLIENT: number;
+        static readonly MS_MEDIA_KEYERR_DOMAIN: number;
+        static readonly MS_MEDIA_KEYERR_HARDWARECHANGE: number;
+        static readonly MS_MEDIA_KEYERR_OUTPUT: number;
+        static readonly MS_MEDIA_KEYERR_SERVICE: number;
+        static readonly MS_MEDIA_KEYERR_UNKNOWN: number;
+        readonly code: number;
+        readonly systemCode: number;
+    }
+    interface MSMediaKeySession extends EventTarget {
+        readonly error: MSMediaKeyError | null;
+        readonly keySystem: string;
+        onmskeyadded: EventListener | null;
+        onmskeyerror: EventListener | null;
+        onmskeymessage: EventListener | null;
+        sessionId: string;
+        close(): void;
+        update(key: Uint8Array): void;
+        addEventListener<K extends keyof MSMediaKeySessionEventMap>(type: K, listener: (this: MSMediaKeySession, ev: MSMediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof MSMediaKeySessionEventMap>(type: K, listener: (this: MSMediaKeySession, ev: MSMediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+    }
+}
+export interface MSMediaKeySessionEventMap {
+    readonly mskeymessage: MSMediaKeyMessageEvent;
+    readonly mskeyerror: Event;
+}
+export interface MSMediaKeyMessageEvent extends Event {
+    readonly message: Uint8Array;
+}
+//# sourceMappingURL=MSMediaKeys.d.ts.map

package/dist/types/ts4.1/drm/dom/WebKitMediaKeys.d.ts

@@ -0,0 +1,50 @@
+import type { Maybe } from '@amazon/vinyl-util';
+/**
+ * API for WebKit-prefixed EME.
+ * WebKitPrefixed EME is supported from iOS/iPadOS 11.3 and macOS 10.10.3
+ *
+ * Modern unprefixed EME for WebKit is supported starting iOS/iPadOS 12.2 and macOS 10.14.4
+ *
+ * https://developer.apple.com/documentation/webkitjs/webkitmediakeys
+ * @module
+ */
+declare global {
+    class WebKitMediaKeys {
+        readonly keySystem: string;
+        constructor(keySystem: string);
+        static isTypeSupported(keySystem: string, type?: Maybe<string>): boolean;
+        createSession(type: string, initData: Uint8Array): WebKitMediaKeySession;
+    }
+    class WebKitMediaKeyError {
+        static readonly MEDIA_KEYERR_UNKNOWN: number;
+        static readonly MEDIA_KEYERR_CLIENT: number;
+        static readonly MEDIA_KEYERR_SERVICE: number;
+        static readonly MEDIA_KEYERR_OUTPUT: number;
+        static readonly MEDIA_KEYERR_HARDWARECHANGE: number;
+        static readonly MEDIA_KEYERR_DOMAIN: number;
+        readonly code: number;
+        readonly systemCode: number;
+    }
+    interface WebKitMediaKeySession extends EventTarget {
+        readonly error: WebKitMediaKeyError | null;
+        readonly keySystem: string;
+        onwebkitkeyadded: EventListener | null;
+        onwebkitkeyerror: EventListener | null;
+        onwebkitkeymessage: EventListener | null;
+        sessionId: string;
+        close(): void;
+        update(key: Uint8Array): void;
+        addEventListener<K extends keyof WebKitMediaKeySessionEventMap>(type: K, listener: (this: WebKitMediaKeySession, ev: WebKitMediaKeySessionEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof WebKitMediaKeySessionEventMap>(type: K, listener: (this: WebKitMediaKeySession, ev: WebKitMediaKeySessionEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+    }
+}
+export interface WebKitMediaKeySessionEventMap {
+    readonly webkitkeymessage: WebKitMediaKeyMessageEvent;
+    readonly webkitkeyerror: Event;
+}
+export interface WebKitMediaKeyMessageEvent extends Event {
+    readonly message: Uint8Array;
+}
+//# sourceMappingURL=WebKitMediaKeys.d.ts.map

package/dist/types/ts4.1/drm/error/DrmError.d.ts

@@ -0,0 +1,16 @@
+import type { Json } from '@amazon/vinyl-util';
+import { ErrorLevel, ReportableError } from '@amazon/vinyl-util';
+/**
+ * An error originating from the DrmController.
+ * If an error comes from a key session, `extra.error` will be set with the original error and origin will be DRM.
+ */
+export declare class DrmError<ExtraType = any> extends ReportableError {
+    readonly message: string;
+    private readonly extra;
+    readonly origin: string;
+    readonly level: ErrorLevel;
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, extra?: ExtraType | null, origin?: string, level?: ErrorLevel);
+    toJSON(): Json;
+}
+//# sourceMappingURL=DrmError.d.ts.map

package/dist/types/ts4.1/drm/licenseProvider/LicenseProvider.d.ts

@@ -0,0 +1,38 @@
+import type { Maybe, ReadonlyAbort } from '@amazon/vinyl-util';
+import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import type { ObjectSchema } from '@amazon/vinyl-validation';
+/**
+ * LicenseProvider handles requesting DRM licenses for specific key systems.
+ */
+export type LicenseProvider = (keySystem: DrmKeySystem, serverOptions: LicenseServerOptions, challenge: ArrayBuffer, abort?: ReadonlyAbort) => Promise<ArrayBuffer>;
+/**
+ * Basic license server configuration.
+ * The license provider is given the matching configuration for the selected
+ * key system.
+ */
+export interface LicenseServerOptions {
+    /**
+     * The license server URL.
+     * This is required when using the default license provider.
+     */
+    readonly url?: Maybe<string | URL>;
+    /**
+     * License request init options.
+     */
+    readonly init?: Maybe<RequestInit>;
+    /**
+     * If set, provides the server certificate.
+     * An ArrayBufferLike object containing the server certificate.
+     * The contents are Key System-specific.
+     * If a `string` is provided, the value will be considered to be Base 64.
+     */
+    readonly serverCertificate?: Maybe<ServerCertificate>;
+}
+/**
+ * An ArrayBufferLike object containing the server certificate.
+ * The contents are Key System-specific.
+ * If a `string` is provided, the value will be considered to be Base 64.
+ */
+export type ServerCertificate = ArrayBuffer | string;
+export declare const licenseServerOptionsValidator: ObjectSchema<LicenseServerOptions>;
+//# sourceMappingURL=LicenseProvider.d.ts.map

package/dist/types/ts4.1/drm/licenseProvider/defaultLicenseProvider.d.ts

@@ -0,0 +1,15 @@
+import type { LicenseProvider } from './LicenseProvider';
+/**
+ * A basic LicenseProvider which uses the configuration set for the current key system,
+ * transmits a challenge as the body, and returns an array buffer.
+ *
+ * @param keySystem The key system for the current license challenge.
+ * @param serverOptions The resolved configuration. The default DrmController
+ * implementation provides this from the `drm` configuration set when creating
+ * a new player.
+ * @param challenge The license challenge, provided by the CDM (Content Decryption
+ * Module)
+ * @param abort (optional) When aborted, should cancel any active requests.
+ */
+export declare const defaultLicenseProvider: LicenseProvider;
+//# sourceMappingURL=defaultLicenseProvider.d.ts.map

package/dist/types/ts4.1/drm/util/createFairPlaySessionInitData.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Create the payload for EME media key session from `encrypted` / `*needkey` event data and DRM
+ * certificate.
+ * Note: This code is taken from the official FairPlay SDK example.
+ *
+ * @param initData
+ * @param contentId
+ * @param certificateData certificate data as a Uint8Array
+ */
+export declare function createFairPlaySessionInitData(initData: Uint8Array, contentId: string, certificateData: Uint8Array): Uint8Array;
+//# sourceMappingURL=createFairPlaySessionInitData.d.ts.map