@amazon/vinyl 1.0.0

package/dist/types/current/vinyl/createVinylFactories.js

@@ -0,0 +1,57 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CapabilitiesImpl } from '../client/CapabilitiesImpl';
+import { mergeDeep, noop } from '@amazon/vinyl-util';
+import { patchMediaElement } from '../patch/media/patchMediaElement';
+import { PlaybackControllerImpl } from '../playback/PlaybackControllerImpl';
+import { PlaybackSourceImpl } from '../playback/PlaybackSourceImpl';
+import { createVinylTrackFactories, } from '../track/createVinylTrackFactories';
+import { TrackControllerImpl } from '../track/TrackController';
+import { createTrackFactory } from '../track/TrackFactory';
+import { defaultPatchOptions } from './VinylPatchOptions';
+import { createDashFactories } from '../track/dash/createDashFactories';
+import { createHlsFactories } from '../track/hls/createHlsFactories';
+import { commonEmeFactory } from '../drm/commonEme/CommonEmeFactory';
+import { DrmControllerImpl, } from '../drm/DrmControllerImpl';
+import { defaultDrmKeySystemResolver } from '../drm/DrmKeySystemResolver';
+import { LoudnessNormalizationControllerImpl } from '../playback/loudness/LoudnessNormalizationControllerImpl';
+import { AutoResetControllerImpl, } from '../track/AutoResetController';
+import { validateFactories } from '@amazon/vinyl-di';
+import { defaultVinylOptions, vinylOptionsValidator, } from '../vinyl/VinylOptions';
+import { playerConfigFactory } from '../vinyl/playerConfigFactory';
+/**
+ * Creates the dependency factories for a standard player.
+ *
+ * @param options
+ */
+export function createVinylFactories(options) {
+    const patches = mergeDeep([
+        defaultPatchOptions.value,
+        options.patches ?? {},
+    ]);
+    return validateFactories({
+        options: playerConfigFactory(defaultVinylOptions, vinylOptionsValidator),
+        patchedMedia: () => {
+            // Patches the media element if necessary.
+            return patchMediaElement(options.media, patches.media);
+        },
+        media: (deps) => deps.patchedMedia.patched,
+        playbackController: (deps) => new PlaybackControllerImpl(deps, options.playbackController),
+        playbackSource: (deps) => new PlaybackSourceImpl(deps),
+        loudnessNormalizationController: (deps) => new LoudnessNormalizationControllerImpl({
+            options: deps.options.pick('loudnessNormalization'),
+        }),
+        capabilities: (deps) => new CapabilitiesImpl(deps),
+        requestInterceptor: () => noop,
+        trackFactory: (deps) => createTrackFactory(createVinylTrackFactories(deps)),
+        trackController: (deps) => new TrackControllerImpl(deps, options.trackController),
+        drmKeySystemResolver: () => defaultDrmKeySystemResolver,
+        drmController: (deps) => new DrmControllerImpl(deps, options.drm),
+        commonEme: commonEmeFactory,
+        autoResetController: (deps) => new AutoResetControllerImpl(deps, options.autoReset),
+        createDashFactories: createDashFactories(options),
+        createHlsFactories: createHlsFactories(options),
+    });
+}

package/dist/types/current/vinyl/playerConfigFactory.d.ts

@@ -0,0 +1,5 @@
+import { type MutableValue } from '@amazon/vinyl-observable';
+import type { AddDisposable, AnyRecord } from '@amazon/vinyl-util';
+import type { Validator } from '@amazon/vinyl-validation';
+export declare function playerConfigFactory<T>(defaults: T, validator: Validator<T>): (_deps: AnyRecord, add: AddDisposable) => MutableValue<T>;
+//# sourceMappingURL=playerConfigFactory.d.ts.map

package/dist/types/current/vinyl/playerConfigFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playerConfigFactory.d.ts","sourceRoot":"","sources":["../../../../src/vinyl/playerConfigFactory.ts"],"names":[],"mappings":"AAKA,OAAO,EAAQ,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAEzD,wBAAgB,mBAAmB,CAAC,CAAC,EACjC,QAAQ,EAAE,CAAC,EACX,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,GACxB,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,aAAa,KAAK,YAAY,CAAC,CAAC,CAAC,CAW3D"}

package/dist/types/current/vinyl/playerConfigFactory.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { data } from '@amazon/vinyl-observable';
+export function playerConfigFactory(defaults, validator) {
+    return (_deps, add) => {
+        const config = data(defaults);
+        add(config.onData((data) => {
+            // Throws if data does not pass validation
+            validator.assert(data);
+        }));
+        return config;
+    };
+}

package/dist/types/ts3.7/client/Capabilities.d.ts

@@ -0,0 +1,73 @@
+import { DrmKeySystem } from '../drm/DrmKeySystem';
+import { DrmKeySystemSupport } from '../drm/DrmController';
+export declare enum CanPlayTypeResult {
+    /**
+     * The media cannot be played on the current device.
+     */
+    NO = "no",
+    /**
+     * There is not enough information to determine whether the media can play.
+     */
+    MAYBE = "maybe",
+    /**
+     * The media is probably playable on this device.
+     */
+    PROBABLY = "probably"
+}
+/**
+ * Detected capabilities of the device.
+ */
+export interface Capabilities {
+    /**
+     * Returns true if Media Source Extensions are supported.
+     *
+     * Note that this does not test DRM or any DRM key systems.
+     */
+    readonly mse: boolean;
+    /**
+     * Returns true if Encrypted Media Extensions are supported.
+     */
+    readonly eme: boolean;
+    /**
+     * Returns true if native Dynamic Adaptive Streaming is supported.
+     *
+     * (Legacy Edge 12-18 and XBox One)
+     * Note that this is not the same as supporting a dash track.
+     */
+    readonly dash: boolean;
+    /**
+     * Returns true if native HTTP Live Streaming is supported.
+     *
+     * iOS 7.0+, Safari 8.0+
+     * Note that this does not do FairPlay detection.
+     */
+    readonly hls: boolean;
+    /**
+     * Returns the sample rate, in samples per second, that this platform supports.
+     * Returns null if the sample rate cannot be determined.
+     */
+    readonly sampleRate: number | null;
+    /**
+     * Returns a string that specifies whether the client can play a given media resource type for progressive
+     * content.
+     *
+     * @param type A string specifying the MIME type of the media and (optionally) a codecs
+     * parameter containing a comma-separated list of the supported codecs.
+     */
+    canPlayType(type: string): CanPlayTypeResult;
+    /**
+     * Returns a boolean that specifies whether the client can play a given media resource type for streaming
+     * content with media source extensions.
+     *
+     * @param type A string specifying the MIME type of the media and (optionally) a codecs
+     * parameter containing a comma-separated list of the supported codecs.
+     */
+    canPlayTypeMse(type: string): boolean;
+    /**
+     * Returns a promise describing support for the given key system.
+     *
+     * @param keySystem
+     */
+    supportsKeySystem(keySystem: DrmKeySystem): Promise<DrmKeySystemSupport>;
+}
+//# sourceMappingURL=Capabilities.d.ts.map

package/dist/types/ts3.7/client/CapabilitiesImpl.d.ts

@@ -0,0 +1,27 @@
+import { DrmKeySystem } from '../drm/DrmKeySystem';
+import { Capabilities } from './Capabilities';
+import { CanPlayTypeResult } from './Capabilities';
+import { DrmController, DrmKeySystemSupport } from '../drm/DrmController';
+/**
+ * Dependencies for CapabilitiesImpl.
+ */
+export interface CapabilitiesImplDeps {
+    readonly media: HTMLMediaElement;
+    readonly drmController: DrmController;
+}
+/**
+ * Client support detection.
+ */
+export declare class CapabilitiesImpl implements Capabilities {
+    private readonly deps;
+    constructor(deps: CapabilitiesImplDeps);
+    get mse(): boolean;
+    get dash(): boolean;
+    get hls(): boolean;
+    get eme(): boolean;
+    get sampleRate(): (number | null);
+    canPlayType(type: string): CanPlayTypeResult;
+    canPlayTypeMse(type: string): boolean;
+    supportsKeySystem(keySystem: DrmKeySystem): Promise<DrmKeySystemSupport>;
+}
+//# sourceMappingURL=CapabilitiesImpl.d.ts.map

package/dist/types/ts3.7/client/Client.d.ts

@@ -0,0 +1,11 @@
+import { Capabilities } from './Capabilities';
+/**
+ * Provides information about the client, such as device and browser capabilities.
+ */
+export interface Client {
+    /**
+     * Browser and platform capabilities.
+     */
+    readonly capabilities: Capabilities;
+}
+//# sourceMappingURL=Client.d.ts.map

package/dist/types/ts3.7/drm/CencEncryptionScheme.d.ts

@@ -0,0 +1,37 @@
+import { Maybe } from '@amazon/vinyl-util';
+/**
+ * https://www.w3.org/TR/encrypted-media-2/#dom-mediakeysystemmediacapability-encryptionscheme
+ */
+export type CencEncryptionScheme = 
+/**
+ * AES-CTR mode full sample and video NAL subsample encryption.
+ */
+'cenc'
+/**
+ * AES-CBC mode partial video NAL pattern encryption. For video, the spec allows various encryption patterns.
+ */
+ | 'cbcs'
+/**
+ * The same as "cbcs" mode, but with a specific encrypt:skip pattern of 1:9 for video.
+ */
+ | 'cbcs-1-9' | string;
+export interface CencEncryptionSchemeAndVersion {
+    readonly scheme: CencEncryptionScheme;
+    readonly version: number | null;
+}
+/**
+ * 5.8.5.2.2 The MP4 Protection Scheme
+ *
+ * For Representations based on ISO/IEC 14496-12, the following URI is defined to indicate protection
+ * schemes identified by the Scheme Type within the Scheme Type Box of the Protection Scheme
+ * Information Box of the file:
+ * urn:mpeg:dash:mp4protection:2011
+ * In this scheme, the `value` attribute shall present and shall be the 4CC contained in the Scheme Type
+ * Box, suitably percent-encoded according to IETF RFC 8141, and may include the version number. The
+ * 4CC and the version number, if present, shall be separated by a ":". The version number shall be encoded
+ * as up to 8 hexadecimal digits, where the leading '0's may be omitted.
+ *
+ * @param value
+ */
+export declare function parseCencEncryptionScheme(value: Maybe<string>): CencEncryptionSchemeAndVersion | null;
+//# sourceMappingURL=CencEncryptionScheme.d.ts.map

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

@@ -0,0 +1,103 @@
+import { AnyRecord, Maybe, ReadonlyAbort, ReadonlyEventHost } from '@amazon/vinyl-util';
+import { DrmInitDataType } from '../streaming/DrmInitDataType';
+import { DrmKeySystem } from '../drm/DrmKeySystem';
+import { MediaFormatMetadata } from '../streaming/MediaQualityMetadata';
+import { BasicErrorEvent } from '../event/BasicErrorEvent';
+import { 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/ts3.7/drm/DrmControllerImpl.d.ts

@@ -0,0 +1,109 @@
+import { EventHostImpl, Maybe, ReadonlyAbort } from '@amazon/vinyl-util';
+import { DrmOptions } from '../drm/DrmOptions';
+import { DrmController, DrmControllerEventMap, DrmKeySystemSupport } from '../drm/DrmController';
+import { CommonEme, CommonMediaKeyMessageEvent, CommonMediaKeys, CommonMediaKeySession } from '../drm/commonEme/CommonEme';
+import { 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;
+    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/ts3.7/drm/DrmKeySystem.d.ts

@@ -0,0 +1,61 @@
+import { 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/ts3.7/drm/DrmKeySystemResolver.d.ts

@@ -0,0 +1,12 @@
+import { 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/ts3.7/drm/DrmOptions.d.ts

@@ -0,0 +1,92 @@
+import { ReadonlyRecord, ValueProvider } from '@amazon/vinyl-util';
+import { DrmInitDataType } from '../streaming/DrmInitDataType';
+import { MediaFormatMetadata } from '../streaming/MediaQualityMetadata';
+import { ObjectSchema, ValueSchema } from '@amazon/vinyl-validation';
+import { DrmKeySystem } from './DrmKeySystem';
+import { 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