@amazon/vinyl 1.0.0

package/dist/types/ts4.7/track/hls/index.d.ts

@@ -0,0 +1,10 @@
+export * from './HlsManifestProvider';
+export * from './createUrlHlsManifestProvider';
+export * from './HlsManifestController';
+export * from './HlsMediaQualityMetadataResolver';
+export * from './createHlsContentTypesValue';
+export * from './createHlsFactories';
+export * from './createHlsContentStreamFactories';
+export * from './HlsTrack';
+export * from './util/hlsSegmentTime';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ts4.7/track/hls/util/hlsByteRangeToMediaRange.d.ts

@@ -0,0 +1,5 @@
+import type { ByteRange } from '@amazon/vinyl-mpd-parser';
+import type { HlsByteRange } from '@amazon/vinyl-hls-parser';
+/** Converts an HLS byte range (`{offset, length}`) to a `ByteRange` (`[start, end]`). */
+export declare function hlsByteRangeToMediaRange(byteRange: HlsByteRange): ByteRange;
+//# sourceMappingURL=hlsByteRangeToMediaRange.d.ts.map

package/dist/types/ts4.7/track/hls/util/hlsSegmentTime.d.ts

@@ -0,0 +1,10 @@
+import type { HlsSegment } from '@amazon/vinyl-hls-parser';
+import type { MediaSegmentReference } from '../../../streaming/SegmentReference';
+import type { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
+import { type CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+/**
+ * Builds a timeline of MediaSegmentReferences from an HLS media playlist's
+ * segment list. Cumulative durations are used to compute start/end times.
+ */
+export declare function buildSegmentTimeline(deps: CreateSegmentDataProviderDeps, baseUrl: string, segments: readonly HlsSegment[]): readonly MediaSegmentReference<SegmentDataProvider>[];
+//# sourceMappingURL=hlsSegmentTime.d.ts.map

package/dist/types/ts4.7/track/mse/MseTrack.d.ts

@@ -0,0 +1,85 @@
+import { TrackBase, type TrackBaseDeps, type TrackBaseOptions } from '../../track/TrackBase';
+import { type ReadonlyRanges, type ReadonlySet } from '@amazon/vinyl-util';
+import type { TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/Track';
+import type { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import { type Factories } from '@amazon/vinyl-di';
+import type { ContentStream } from '../../streaming/ContentStream';
+import type { MediaSourceController } from '../../streaming/buffering/MediaSourceController';
+import type { PlaybackSource } from '../../playback/PlaybackSource';
+import type { ContentTypesValue } from '../../streaming/ContentTypesValue';
+import type { ManifestController } from '../../streaming/ManifestController';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { MediaTimeline } from '../../streaming/MediaTimeline';
+export type MseTrackDeps = TrackBaseDeps & {
+    readonly contentTypesValue: ContentTypesValue;
+    readonly contentStreamFactory: (contentType: ContentType) => ContentStream;
+    readonly manifestController: ManifestController<unknown>;
+    readonly mediaSourceController: MediaSourceController;
+    readonly playbackSource: PlaybackSource;
+    readonly mediaTimeline: ObservableValue<Promise<MediaTimeline>>;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+};
+/**
+ * An MseTrack uses media source extensions for streaming.
+ */
+export declare class MseTrack extends TrackBase {
+    get [Symbol.toStringTag](): string;
+    protected readonly deps: MseTrackDeps;
+    private readonly streams;
+    private readonly disposeAbort;
+    private lastPreloadOptions;
+    private activateOptions;
+    private readonly allFetchedRanges;
+    private readonly _fetchedRanges;
+    private _contentTypes;
+    private _qualities;
+    private _qualitiesUnfiltered;
+    private timeUpdateSub;
+    private _cachedPeriod;
+    constructor(uri: TrackUri, type: TrackTypeId, dependencyFactories: Factories<MseTrackDeps>);
+    /**
+     * Updates the cached qualities list from the transformed timeline for the current period.
+     */
+    private updateQualities;
+    /**
+     * Updates the cached unfiltered qualities list from the raw timeline for the current period.
+     */
+    private updateQualitiesUnfiltered;
+    /**
+     * Creates and adds a content stream for the given content type.
+     *
+     * @param contentType
+     */
+    protected createStream(contentType: ContentType): void;
+    preload(trackOptions: TrackPreloadOptions, loadOptions: TrackBaseOptions): void;
+    get contentTypes(): ReadonlySet<ContentType>;
+    set contentTypes(value: ReadonlySet<ContentType>);
+    get qualities(): readonly MediaQualityMetadata[] | null;
+    get qualitiesUnfiltered(): readonly MediaQualityMetadata[] | null;
+    get fetchedRanges(): ReadonlyRanges;
+    /**
+     * Clears all fetched fragments and source buffers. Streaming will resume.
+     * This should be called if a change has been made where the user would expect an immediate change,
+     * for example, changing streaming quality from SD to HD.
+     */
+    clearPrefetch(): void;
+    /**
+     * Resets the track to recover from error states.
+     * Resets both the segment controller and buffering controller to clear failed segments and error conditions.
+     */
+    reset(): void;
+    onActivated(loadOptions: TrackBaseOptions): void;
+    onDeactivated(): void;
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    /**
+     * Calls the specified method on all streams with the provided arguments.
+     */
+    private callOnStreams;
+    private getStream;
+    private clearStreams;
+    get bufferingEnded(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=MseTrack.d.ts.map

package/dist/types/ts4.7/track/mse/codec.d.ts

@@ -0,0 +1,16 @@
+import type { ContentType } from '../../streaming/MediaQualityMetadata';
+/**
+ * Returns the ContentType for a single RFC 6381 codec string, or null if
+ * unrecognized.
+ */
+export declare function codecToContentType(codec: string): ContentType | null;
+/**
+ * Splits a comma-separated CODECS attribute value and returns the set of
+ * ContentType values present.
+ */
+export declare function codecsToContentTypes(codecs: string): Set<ContentType>;
+/**
+ * Returns the full MIME type string for a content type, optionally with codecs.
+ */
+export declare function contentTypeToMimeType(contentType: ContentType, codecs: string | null): string;
+//# sourceMappingURL=codec.d.ts.map

package/dist/types/ts4.7/track/source/FixedPlaybackQuality.d.ts

@@ -0,0 +1,38 @@
+import type { TrackEventMap } from '../../track/Track';
+import { EventHostImpl, type ReadonlySet } from '@amazon/vinyl-util';
+import type { PlaybackController } from '../../playback/PlaybackController';
+import type { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+/**
+ * FixedPlaybackQuality has a singular quality for selection.
+ *
+ * streamingQuality will always be the fixed quality.
+ *
+ * bufferingQuality will be the fixed quality when active, otherwise null.
+ *
+ * playbackQuality will be the fixed quality when active and data is buffered, otherwise null.
+ */
+export declare class FixedPlaybackQuality extends EventHostImpl<Pick<TrackEventMap, 'streamingQualityChange' | 'bufferingQualityChange' | 'playbackQualityChange'>> {
+    private readonly deps;
+    private _fixedQuality;
+    private _contentTypes;
+    private _isActive;
+    get active(): boolean;
+    constructor(fixedQuality: MediaQualityMetadata, deps: {
+        readonly playbackController: PlaybackController;
+    });
+    get contentTypes(): ReadonlySet<ContentType>;
+    get fixedQuality(): MediaQualityMetadata;
+    set fixedQuality(value: MediaQualityMetadata);
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    private _bufferingQuality;
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    private set bufferingQuality(value);
+    private _playbackQuality;
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    private set playbackQuality(value);
+    private readyStateChangeSub;
+    activate(): void;
+    deactivate(): void;
+    private onReadyStateChange;
+}
+//# sourceMappingURL=FixedPlaybackQuality.d.ts.map

package/dist/types/ts4.7/track/source/SourceObjectTrack.d.ts

@@ -0,0 +1,33 @@
+import type { PlaybackSource } from '../../playback/PlaybackSource';
+import type { TrackTypeId, TrackUri } from '../../track/Track';
+import { type TrackBaseDeps } from '../../track/TrackBase';
+import { type TrackFactory, type TrackLoadOptions } from '../../track/TrackFactory';
+import { type Maybe } from '@amazon/vinyl-util';
+import { SourceTrackBase, type SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
+/**
+ * Dependencies for a SourceObjectTrack.
+ */
+export interface SourceObjectTrackDeps extends TrackBaseDeps {
+    readonly playbackSource: PlaybackSource;
+}
+export interface SourceObjectTrackLoadOptions extends TrackLoadOptions {
+    readonly type: 'srcObject';
+    /**
+     * A function to produce a MediaStream, or Promise<MediaStream>.
+     */
+    readonly srcObjectProvider: (uri: TrackUri) => Promise<MediaStream> | MediaStream;
+    /**
+     * Configuration options for the SourceObjectTrack.
+     * Will be provided on preload and activate.
+     */
+    readonly config?: Maybe<SourceTrackBaseOptions>;
+}
+export declare function createSourceObjectTrackFactory(deps: SourceObjectTrackDeps): TrackFactory<SourceObjectTrackLoadOptions>;
+export declare class SourceObjectTrack extends SourceTrackBase<MediaStream> {
+    protected readonly deps: SourceObjectTrackDeps;
+    get [Symbol.toStringTag](): string;
+    constructor(uri: TrackUri, type: TrackTypeId, srcObject: Promise<MediaStream>, deps: SourceObjectTrackDeps);
+    protected setSrc(src: MediaStream): void;
+    protected clearSrc(): void;
+}
+//# sourceMappingURL=SourceObjectTrack.d.ts.map

package/dist/types/ts4.7/track/source/SourceTrack.d.ts

@@ -0,0 +1,34 @@
+import type { TrackTypeId, TrackUri } from '../../track/Track';
+import { type TrackBaseDeps } from '../../track/TrackBase';
+import { type TrackFactory, type TrackLoadOptions } from '../../track/TrackFactory';
+import { type Maybe } from '@amazon/vinyl-util';
+import { SourceTrackBase, type SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
+import type { PlaybackSource } from '../../playback/PlaybackSource';
+/**
+ * Dependencies for a SourceTrack.
+ */
+export interface SourceTrackDeps extends TrackBaseDeps {
+    readonly playbackSource: PlaybackSource;
+}
+export interface SourceTrackLoadOptions extends TrackLoadOptions {
+    readonly type: 'src';
+    /**
+     * If set, will be called to provide the track src.
+     * Otherwise, the uri will be used.
+     */
+    readonly srcProvider?: Maybe<(uri: TrackUri) => Promise<string> | string>;
+    /**
+     * Configuration options for the SourceTrack.
+     * Will be provided on preload and activate.
+     */
+    readonly config?: Maybe<SourceTrackBaseOptions>;
+}
+export declare function createSourceTrackFactory(deps: SourceTrackDeps): TrackFactory<SourceTrackLoadOptions>;
+export declare class SourceTrack extends SourceTrackBase<string> {
+    protected readonly deps: SourceTrackDeps;
+    get [Symbol.toStringTag](): string;
+    constructor(uri: TrackUri, type: TrackTypeId, src: Promise<string>, deps: SourceTrackDeps);
+    protected setSrc(src: string): void;
+    protected clearSrc(): void;
+}
+//# sourceMappingURL=SourceTrack.d.ts.map

package/dist/types/ts4.7/track/source/SourceTrackBase.d.ts

@@ -0,0 +1,33 @@
+import { TrackBase, type TrackBaseDeps, type TrackBaseOptions } from '../../track/TrackBase';
+import type { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/Track';
+import { type Maybe, type ReadonlySet } from '@amazon/vinyl-util';
+import { type ContentType, type MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import type { ObjectSchema } from '@amazon/vinyl-validation';
+export interface SourceTrackBaseOptions extends TrackBaseOptions {
+    /**
+     * Quality metadata.
+     * May be used to configure DRM (for native HLS), codec, or other track metadata.
+     */
+    readonly qualityMetadata?: Maybe<Partial<MediaQualityMetadata>>;
+}
+export declare const sourceTrackBaseOptionsValidator: ObjectSchema<SourceTrackBaseOptions>;
+export declare abstract class SourceTrackBase<SrcType, EventMap extends TrackEventMap = TrackEventMap, LoadOptionsType extends SourceTrackBaseOptions = SourceTrackBaseOptions> extends TrackBase<EventMap, LoadOptionsType> {
+    readonly src: Promise<SrcType>;
+    protected readonly deps: TrackBaseDeps;
+    private readonly fixedPlaybackQuality;
+    private _resolvedSrc;
+    protected constructor(uri: TrackUri, type: TrackTypeId, src: Promise<SrcType>, deps: TrackBaseDeps);
+    preload(trackOptions: TrackPreloadOptions, loadOptions: LoadOptionsType): void;
+    get contentTypes(): ReadonlySet<ContentType>;
+    get qualities(): readonly MediaQualityMetadata[] | null;
+    get qualitiesUnfiltered(): readonly MediaQualityMetadata[] | null;
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    onActivated(): void;
+    protected abstract setSrc(src: SrcType): void;
+    protected abstract clearSrc(): void;
+    onDeactivated(): void;
+    clearPrefetch(): void;
+}
+//# sourceMappingURL=SourceTrackBase.d.ts.map

package/dist/types/ts4.7/util/media/getAudioContext.d.ts

@@ -0,0 +1,22 @@
+type MaybeAudioContext = typeof AudioContext | undefined;
+declare global {
+    var webkitAudioContext: MaybeAudioContext;
+}
+/**
+ * Creates a new AudioContext.
+ * Returns null if not supported on this platform.
+ */
+export declare function createAudioContext(): AudioContext | null;
+/**
+ * The audio context global reference.
+ */
+export declare const audioContextRef: import("@amazon/vinyl-util").GlobalRef<AudioContext | null>;
+/**
+ * Returns an AudioContext singleton, or returns null if not supported on this platform.
+ *
+ * If the first time this is called is outside a user gesture, the AudioContext will be unable to start in a
+ * running state.
+ */
+export declare function getAudioContext(): AudioContext | null;
+export {};
+//# sourceMappingURL=getAudioContext.d.ts.map

package/dist/types/ts4.7/util/media/mediaSource.d.ts

@@ -0,0 +1,40 @@
+import type { Unsubscribe } from '@amazon/vinyl-util';
+import type { SignalOptions } from '@amazon/vinyl-util';
+declare global {
+    var ManagedMediaSource: typeof MediaSource | undefined;
+}
+/**
+ * Returns true if the UA supports media source extensions.
+ */
+export declare function supportsMse(): boolean;
+/**
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaSource/isTypeSupported_static)
+ */
+export declare function isTypeSupported(type: string): boolean;
+/**
+ * Constructs a new ManagedMediaSource or MediaSource.
+ */
+export declare function createMediaSource(): MediaSource;
+/**
+ * Throws a MediaUnsupportedError if MSE is not supported.
+ */
+export declare function assertMseSupported(): void;
+/**
+ * Invokes a callback when the media source is open.
+ * The callback will be invoked immediately if already open.
+ */
+export declare function onMediaSourceOpen(mediaSource: MediaSource, callback: () => void, options?: SignalOptions): Unsubscribe;
+/**
+ * Invokes a callback when the media source is next ended.
+ * The callback will be invoked immediately if already ended.
+ */
+export declare function onMediaSourceEnded(mediaSource: MediaSource, callback: () => void, options?: SignalOptions): Unsubscribe;
+/**
+ * Returns a Promise that resolves when the media source is next in an 'ended' state.
+ *
+ * @param mediaSource
+ * @param timeout The number of seconds before rejecting with a TimeoutError.
+ * @param timeoutMessage
+ */
+export declare function nextMediaSourceEnded(mediaSource: MediaSource, timeout?: number, timeoutMessage?: string): Promise<void>;
+//# sourceMappingURL=mediaSource.d.ts.map

package/dist/types/ts4.7/util/media/sourceBuffer.d.ts

@@ -0,0 +1,9 @@
+import type { Maybe } from '@amazon/vinyl-util';
+/**
+ * Returns a promise that resolves when the given source buffer is next idle.
+ * If the source buffer errs, the promise will be rejected with a {@link SourceBufferError}.
+ *
+ * @param sourceBuffer
+ */
+export declare function nextSourceBufferIdle(sourceBuffer: Maybe<SourceBuffer>): Promise<void>;
+//# sourceMappingURL=sourceBuffer.d.ts.map

package/dist/types/ts4.7/vinyl/ReadonlyPlaybackStreamingState.d.ts

@@ -0,0 +1,34 @@
+import type { ReadonlyEventHost } from '@amazon/vinyl-util';
+import type { TrackEventMap, ReadonlyStreamingState } from '../track/Track';
+/**
+ * Represents the streaming state of the currently active track.
+ *
+ * This interface provides access to the current state of streaming, including:
+ * - Fetched data ranges and progress
+ * - Streaming quality transitions (streaming, buffering, playback)
+ *
+ * Consumers can use this interface to monitor streaming progress and quality changes
+ * during playback. All properties are read-only and reflect the current state.
+ *
+ * To react to changes over time, listen to events defined in {@link TrackEventMap}, such as:
+ * - `streamingQualityChange`
+ * - `bufferingQualityChange`
+ * - `playbackQualityChange`
+ */
+export interface ReadonlyPlaybackStreamingState extends ReadonlyEventHost<TrackEventMap>, ReadonlyStreamingState {
+    /**
+     * Returns the time of the prefetch end.
+     * If no data has been prefetched for the current track, 0 will be returned.
+     *
+     * The time given will be in seconds according to the media timeline.
+     * It will represent the ending time of the continuous prefetch range from the current playhead time.
+     */
+    readonly fetchedTime: number;
+    /**
+     * Returns current fetched time as a percent of the total duration.
+     *
+     * @return A number between 0-1
+     */
+    readonly fetchedTimePercent: number;
+}
+//# sourceMappingURL=ReadonlyPlaybackStreamingState.d.ts.map

package/dist/types/ts4.7/vinyl/VinylDeps.d.ts

@@ -0,0 +1,41 @@
+import type { Capabilities } from '../client/Capabilities';
+import type { PlaybackController } from '../playback/PlaybackController';
+import type { PlaybackSource } from '../playback/PlaybackSource';
+import type { VinylTrackLoadOptions } from '../track/createVinylTrackFactories';
+import type { TrackController } from '../track/TrackController';
+import type { TrackLoadOptions } from '../track/TrackFactory';
+import type { DrmController } from '../drm/DrmController';
+import type { AutoResetController } from '../track/AutoResetController';
+import type { MutableValue } from '@amazon/vinyl-observable';
+import type { VinylOptions } from '../vinyl/VinylOptions';
+export interface VinylDeps<TrackLoadOptionsType extends TrackLoadOptions = VinylTrackLoadOptions, OptionsType = VinylOptions> {
+    /**
+     * A mutable provider for configuration options.
+     */
+    readonly options: MutableValue<OptionsType>;
+    /**
+     * Controls playback.
+     */
+    readonly playbackController: PlaybackController;
+    /**
+     * An API to set the media source.
+     */
+    readonly playbackSource: PlaybackSource;
+    /**
+     * Client capabilities.
+     */
+    readonly capabilities: Capabilities;
+    /**
+     * The TrackController, responsible for track queue and activation.
+     */
+    readonly trackController: TrackController<TrackLoadOptionsType>;
+    /**
+     * Digital Rights Management controller.
+     */
+    readonly drmController: DrmController;
+    /**
+     * Notifies when playback can automatically reset after a failure.
+     */
+    readonly autoResetController: AutoResetController;
+}
+//# sourceMappingURL=VinylDeps.d.ts.map

package/dist/types/ts4.7/vinyl/VinylOptions.d.ts

@@ -0,0 +1,19 @@
+import { type QualitySelectorImplOptions } from '../streaming/abr/QualitySelectorImpl';
+import type { ObjectSchema } from '@amazon/vinyl-validation';
+import { type LoudnessNormalizationControllerImplOptions } from '../playback/loudness/LoudnessNormalizationControllerImplOptions';
+export interface VinylOptions {
+    /**
+     * Configuration for the default adaptive bitrate selector.
+     */
+    readonly abr: QualitySelectorImplOptions;
+    readonly loudnessNormalization: LoudnessNormalizationControllerImplOptions;
+    /**
+     * Preferred language for audio content, using a code as defined by RFC 5646 (e.g. 'en', 'ja').
+     * When set, only adaptation sets / variants matching this language (or without a language tag)
+     * are kept. Null means no language preference (all languages are kept).
+     */
+    readonly preferredAudioLanguage: string | null;
+}
+export declare const defaultVinylOptions: VinylOptions;
+export declare const vinylOptionsValidator: ObjectSchema<VinylOptions>;
+//# sourceMappingURL=VinylOptions.d.ts.map

package/dist/types/ts4.7/vinyl/VinylPatchOptions.d.ts

@@ -0,0 +1,10 @@
+import type { MediaElementPatchOptions } from '../patch/media/MediaElementPatchOptions';
+/**
+ * Flags for applying patches.
+ * Default flags will be applied based on user agent, but may be overridden during player creation.
+ */
+export interface VinylPatchOptions {
+    readonly media: MediaElementPatchOptions;
+}
+export declare const defaultPatchOptions: import("@amazon/vinyl-util").Lazy<VinylPatchOptions>;
+//# sourceMappingURL=VinylPatchOptions.d.ts.map

package/dist/types/ts4.7/vinyl/VinylPlayer.d.ts

@@ -0,0 +1,197 @@
+import type { Client } from '../client/Client';
+import { type AnyRecord, type Disposable, EventHostImpl, type ReadonlyRanges, type ReadonlySet } from '@amazon/vinyl-util';
+import { type Factories, type ValidFactoryOverrides } from '@amazon/vinyl-di';
+import type { PlaybackController } from '../playback/PlaybackController';
+import { type PlaybackControllerEventMap, type PlaybackNetworkState, type PlaybackReadyState } from '../playback/ReadonlyPlaybackController';
+import type { VinylTrackLoadOptions } from '../track/createVinylTrackFactories';
+import { type ReadonlyTrack, type TrackUri } from '../track/Track';
+import { type TrackController, type TrackControllerEventMap } from '../track/TrackController';
+import type { InferLoadOptionsFromFactory, TrackLoadOptions } from '../track/TrackFactory';
+import type { DefaultVinylFactories, InferVinylOverrideDependencyType, VinylDependencyOptions } from './createVinylFactories';
+import type { VinylDeps } from './VinylDeps';
+import type { Capabilities } from '../client/Capabilities';
+import { type ContentType, type MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import type { ReadonlyPlaybackStreamingState } from '../vinyl/ReadonlyPlaybackStreamingState';
+import { type StreamingEventMap } from '../streaming/StreamingEventMap';
+import type { InferObservableValueType } from '@amazon/vinyl-observable';
+import type { VinylOptions } from '../vinyl/VinylOptions';
+/**
+ * Events the Vinyl Player emits.
+ */
+export interface VinylPlayerEventMap<TrackLoadOptionsType extends TrackLoadOptions = VinylTrackLoadOptions> extends PlaybackControllerEventMap, TrackControllerEventMap<TrackLoadOptionsType>, StreamingEventMap {
+}
+/**
+ * A Vinyl Media Player.
+ *
+ * Unless custom dependencies need to be provided, use {@link createVinylPlayer} to construct
+ * a new player implementation.
+ */
+export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions = VinylTrackLoadOptions, OptionsType = VinylOptions> extends EventHostImpl<VinylPlayerEventMap<TrackLoadOptionsType>> implements PlaybackController, TrackController<TrackLoadOptionsType>, ReadonlyPlaybackStreamingState, Disposable {
+    get [Symbol.toStringTag](): string;
+    protected readonly deps: VinylDeps<TrackLoadOptionsType, OptionsType>;
+    private get drmController();
+    private get playbackController();
+    private get trackController();
+    /**
+     * Provides information about the client, such as device and browser capabilities.
+     */
+    readonly client: Client;
+    private _error;
+    protected readonly disposer: import("@amazon/vinyl-util").Disposer;
+    /**
+     * Constructs a new VinylPlayer with the given dependency factories.
+     * This constructor is protected, use {@link createVinylPlayer} to construct a new player.
+     *
+     * @param factories
+     * @see createVinylPlayer
+     */
+    protected constructor(factories: Factories<VinylDeps<TrackLoadOptionsType, OptionsType>>);
+    protected redispatchSubControllerEvents(): void;
+    /**
+     * Certain track events are redispatched on the player for the current track.
+     */
+    protected redispatchCurrentTrackEvents(): void;
+    private initializeAutoResetHandling;
+    private initializePreferredLanguageHandling;
+    /**
+     * Returns the current player options.
+     * Use `configure` to set.
+     */
+    get options(): OptionsType;
+    /**
+     * Sets options on this player.
+     * Options will be merged shallowly, for example,
+     * `configure({ abr: { strategy: AbrStrategy.BEST }})` will replace all previous `abr` options, and not
+     * change other options such as `loudnessNormalization`.
+     *
+     * @param options
+     */
+    configure(options: Partial<OptionsType>): void;
+    get capabilities(): Capabilities;
+    get buffered(): ReadonlyRanges;
+    get canPlay(): boolean;
+    get canPlayThrough(): boolean;
+    get currentTime(): number;
+    get currentTimePercent(): number;
+    get defaultPlaybackRate(): number;
+    set defaultPlaybackRate(value: number);
+    get duration(): number;
+    get ended(): boolean;
+    /**
+     * The last error reported.
+     */
+    get error(): Error | null;
+    get hasMetadata(): boolean;
+    get loop(): boolean;
+    set loop(value: boolean);
+    get muted(): boolean;
+    set muted(value: boolean);
+    get networkState(): PlaybackNetworkState;
+    get paused(): boolean;
+    get playbackRate(): number;
+    set playbackRate(value: number);
+    get playIsPending(): boolean;
+    get playing(): boolean;
+    get preservesPitch(): boolean;
+    set preservesPitch(value: boolean);
+    get readyState(): PlaybackReadyState;
+    get seekable(): ReadonlyRanges;
+    get seeking(): boolean;
+    get volume(): number;
+    set volume(value: number);
+    get waiting(): boolean;
+    pause(): void;
+    play(): Promise<void>;
+    seekTo(time: number, tolerance?: number): Promise<void>;
+    reset(): void;
+    get currentTrack(): ReadonlyTrack | null;
+    get queue(): readonly TrackLoadOptionsType[];
+    preload(...loadOptionsList: TrackLoadOptionsType[]): void;
+    load(...loadOptionsList: TrackLoadOptionsType[]): void;
+    enqueue(...loadOptionsList: TrackLoadOptionsType[]): void;
+    unload(): void;
+    hasNext(): boolean;
+    next(): void;
+    isTrackCached(uri: TrackUri): boolean;
+    getCachedTrack(uri: TrackUri): ReadonlyTrack | null;
+    getCachedTracks(): IterableIterator<ReadonlyTrack>;
+    clearPrefetch(): void;
+    clearTrackCache(): void;
+    clearQueue(): void;
+    /**
+     * Returns the fetched ranges of the current track.
+     * If there is no current track, empty ranges will be returned.
+     *
+     * Listen to {@link VinylPlayerEventMap.fetchedRangesChange} for changes.
+     */
+    get fetchedRanges(): ReadonlyRanges;
+    /**
+     * Returns the time of the prefetch end.
+     * If no data has been prefetched for the current track, 0 will be returned.
+     *
+     * The time given will be in seconds according to the media timeline.
+     * It will represent the ending time of the continuous prefetch range from the current playhead time.
+     */
+    get fetchedTime(): number;
+    /**
+     * Returns current fetched time as a percent of the total duration.
+     *
+     * @return A number between 0-1
+     */
+    get fetchedTimePercent(): number;
+    /**
+     * Returns the current content types for active streams.
+     */
+    get contentTypes(): ReadonlySet<ContentType>;
+    /**
+     * The available qualities for the current period of the current track, after filtering.
+     * Null if no track is active or the timeline is not yet available.
+     */
+    get qualities(): readonly MediaQualityMetadata[] | null;
+    /**
+     * The available unfiltered qualities for the current period of the current track.
+     * Null if no track is active or the timeline is not yet available.
+     */
+    get qualitiesUnfiltered(): readonly MediaQualityMetadata[] | null;
+    /**
+     * @deprecated Use `getStreamingQuality('audio')`
+     */
+    get streamingQuality(): MediaQualityMetadata | null;
+    /**
+     * @deprecated Use `getBufferingQuality('audio')
+     */
+    get bufferingQuality(): MediaQualityMetadata | null;
+    /**
+     * @deprecated Use `getPlaybackQuality('audio')
+     */
+    get playbackQuality(): MediaQualityMetadata | null;
+    /**
+     * The streaming quality for the current track.
+     * Note that this does not represent the quality of inactive preloading tracks.
+     */
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    /**
+     * The currently buffering quality, or null if no data is buffered.
+     */
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    /**
+     * The currently playing quality, or null if no media is playing.
+     */
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    /**
+     * Returns true if this player has been disposed.
+     */
+    get disposed(): boolean;
+    /**
+     * Disposes this player and sub-systems.
+     */
+    dispose(): void;
+}
+/**
+ * Constructs a new {@link VinylPlayer}.
+ *
+ * @param options Configuration for default dependencies.
+ * @param factoryOverrides Dependency factory overrides.
+ */
+export declare function createVinylPlayer<DependencyOverridesType extends Factories | undefined>(options: VinylDependencyOptions, factoryOverrides?: ValidFactoryOverrides<VinylDeps<any, AnyRecord>, DefaultVinylFactories, DependencyOverridesType>): VinylPlayer<InferLoadOptionsFromFactory<InferVinylOverrideDependencyType<DependencyOverridesType, 'trackFactory'>>, InferObservableValueType<InferVinylOverrideDependencyType<DependencyOverridesType, 'options'>>>;
+//# sourceMappingURL=VinylPlayer.d.ts.map