@amazon/vinyl 1.0.0

package/dist/types/ts3.7/streaming/buffering/MediaSourceController.d.ts

@@ -0,0 +1,103 @@
+import { AnyRecord, Disposable, EventHostImpl, Json, LogTarget, ReadonlyEventHost, ReportableError } from '@amazon/vinyl-util';
+import { ContentTypesValue } from '../../streaming/ContentTypesValue';
+import { BasicErrorEvent } from '../../event/BasicErrorEvent';
+import { ContentType } from '../../streaming/MediaQualityMetadata';
+export interface SourceBufferRef extends Disposable {
+    /**
+     * The source buffer.
+     */
+    readonly value: SourceBuffer;
+}
+export interface MediaSourceControllerEventMap {
+    /**
+     * The media source has entered a 'closed' state.
+     */
+    readonly sourceClose: AnyRecord;
+    /**
+     * The media source has entered an 'ended' state.
+     */
+    readonly sourceEnded: AnyRecord;
+    /**
+     * The media source has entered an 'open' state.
+     */
+    readonly sourceOpen: AnyRecord;
+    /**
+     * All source buffers have been created and data may be appended.
+     */
+    readonly readyToAppend: AnyRecord;
+    /**
+     * An error has occurred.
+     */
+    readonly error: BasicErrorEvent;
+}
+export interface ReadonlyMediaSourceController extends ReadonlyEventHost<MediaSourceControllerEventMap> {
+    /**
+     * Returns the parent media source ready state.
+     */
+    readonly readyState: ReadyState;
+    /**
+     * Gets the media source's duration.
+     */
+    readonly duration: number;
+    /**
+     * True if all source buffers have been created and data may be appended.
+     */
+    readonly readyToAppend: boolean;
+}
+export interface MediaSourceController extends ReadonlyMediaSourceController {
+    /**
+     * Sets/gets the media source's duration.
+     */
+    duration: number;
+    /**
+     * Constructs a new SourceBuffer with the given content type and mime type.
+     */
+    createSourceBuffer(contentType: ContentType, mimeType: string): SourceBufferRef;
+    /**
+     * Signals the end of the stream.
+     * @param error A string representing an error to throw when the end of the stream is reached.
+     */
+    endOfStream(error?: EndOfStreamError): void;
+    /**
+     * Creates an Object URL to use as the source for this stream.
+     */
+    createUrl(): string;
+}
+export interface MediaSourceControllerImplDeps {
+    /**
+     * Creates a new media source.
+     */
+    readonly mediaSourceFactory: () => MediaSource;
+    /**
+     * Provides the streams that must be created before appending.
+     */
+    readonly contentTypesValue: ContentTypesValue;
+}
+export declare class MediaSourceControllerImpl extends EventHostImpl<MediaSourceControllerEventMap> implements MediaSourceController, LogTarget {
+    get [Symbol.toStringTag](): string;
+    private sourceBufferCount;
+    private readonly mediaSource;
+    private readonly disposer;
+    private contentTypes;
+    constructor(deps: MediaSourceControllerImplDeps);
+    private initializeEvents;
+    get duration(): number;
+    set duration(value: number);
+    get readyState(): ReadyState;
+    createSourceBuffer(contentType: ContentType, mimeType: string): SourceBufferRef;
+    /**
+     * Emits a 'readyToAppend' event if all source buffers have been created.
+     */
+    private readonly checkReady;
+    endOfStream(error?: EndOfStreamError): void;
+    createUrl(): string;
+    get readyToAppend(): boolean;
+    dispose(): void;
+}
+export declare class MediaSourceError extends ReportableError {
+    private readonly reason;
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, reason: Error);
+    toJSON(): Json;
+}
+//# sourceMappingURL=MediaSourceController.d.ts.map

package/dist/types/ts3.7/streaming/buffering/SourceBufferController.d.ts

@@ -0,0 +1,91 @@
+import { Disposable, LogTarget, ReadonlyRanges, Task } from '@amazon/vinyl-util';
+import { MediaSourceController } from './MediaSourceController';
+import { ContentType } from '../../streaming/MediaQualityMetadata';
+export declare const APPEND_WINDOW_START_OFFSET = 0.05;
+export declare const APPEND_WINDOW_END_OFFSET = 0.01;
+export declare const READY_TO_APPEND_TIMEOUT = 30;
+export type SourceBufferControllerFactory = () => SourceBufferController;
+export interface SourceBufferController extends Disposable {
+    readonly buffered: ReadonlyRanges;
+    /**
+     * Returns true if an operation is currently running.
+     */
+    isBusy(): boolean;
+    /**
+     * Enqueues an operation.
+     * Guaranteed to be invoked when the source buffer is not updating.
+     */
+    enqueue<T = void>(task: Task<T>): Promise<T>;
+    /**
+     * Enqueues appending an initialization segment, reinitializing the decoder.
+     */
+    appendInit(data: ArrayBuffer, mimeType: string): Promise<void>;
+    /**
+     * Enqueues appending a media segment.
+     * An `appendInit` call must precede appending media segments.
+     * A promise is returned that will resolve when the task is complete.
+     */
+    append(data: ArrayBuffer): Promise<void>;
+    /**
+     * Sets the timestampOffset on the backing source buffer.
+     */
+    setTimestampOffset(timestampOffset: number): Promise<void>;
+    /**
+     * Sets the append window on the backing source buffer.
+     * Keyframes outside this range will be discarded.
+     */
+    setAppendWindow(appendWindowStart?: number, appendWindowEnd?: number): Promise<void>;
+    /**
+     * Removes media segments within a specific time range from the SourceBuffer.
+     */
+    remove(startTime: number, endTime: number): Promise<void>;
+    /**
+     * Aborts any pending buffers and clears all buffered ranges.
+     */
+    clear(): Promise<void>;
+}
+export interface SourceBufferControllerImplDeps {
+    /**
+     * Produces the source buffer for appending.
+     */
+    readonly mediaSourceController: MediaSourceController;
+}
+/**
+ * The SourceBufferController manages a single source buffer. It provides queued commands for appending and clearing
+ * data.
+ */
+export declare class SourceBufferControllerImpl implements LogTarget, SourceBufferController, Disposable {
+    readonly contentType: ContentType;
+    get [Symbol.toStringTag](): string;
+    private sourceBufferRef;
+    private mimeType;
+    private queue;
+    readonly logPrefix: string;
+    private readonly mediaSourceController;
+    constructor(deps: SourceBufferControllerImplDeps, contentType: ContentType);
+    private get sourceBuffer();
+    private _buffered;
+    get buffered(): ReadonlyRanges;
+    /**
+     * Clears the cached buffered ranges. They will be recreated next access.
+     */
+    private clearBufferedCache;
+    isBusy(): boolean;
+    enqueue<T = void>(task: Task<T>): Promise<T>;
+    appendInit(data: ArrayBuffer, mimeType: string): Promise<void>;
+    append(data: ArrayBuffer): Promise<void>;
+    setTimestampOffset(timestampOffset: number): Promise<void>;
+    setAppendWindow(appendWindowStart?: number, appendWindowEnd?: number): Promise<void>;
+    remove(startTime: number, endTime: number): Promise<void>;
+    /**
+     * Returns a promise that resolves when the source buffer is no longer updating.
+     * @private
+     */
+    private nextIdle;
+    clear(): Promise<void>;
+    /**
+     * Aborts any pending operations and disposes the backed SourceBuffer.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=SourceBufferController.d.ts.map

package/dist/types/ts3.7/streaming/buffering/error/SourceBufferError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from '@amazon/vinyl-util';
+/**
+ * An error emitted from the SourceBuffer.
+ */
+export declare class SourceBufferError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message?: string, origin?: string);
+}
+//# sourceMappingURL=SourceBufferError.d.ts.map

package/dist/types/ts3.7/streaming/createDefaultMediaTimelineTransformer.d.ts

@@ -0,0 +1,18 @@
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { Capabilities } from '../client/Capabilities';
+import { DrmController } from '../drm/DrmController';
+import { MediaTimeline } from '../streaming/MediaTimeline';
+export interface DefaultMediaTimelineTransformerDeps {
+    readonly capabilities: Capabilities;
+    readonly drmController: DrmController;
+    readonly mediaTimeline: ObservableValue<Promise<MediaTimeline>>;
+    readonly options: ObservableValue<{
+        readonly preferredAudioLanguage: string | null;
+    }>;
+}
+/**
+ * The default media timeline transformer filters out unplayable qualities
+ * and applies language preferences. Shared by Dash and HLS.
+ */
+export declare function createDefaultMediaTimelineTransformer(deps: DefaultMediaTimelineTransformerDeps): ObservableValue<Promise<MediaTimeline>>;
+//# sourceMappingURL=createDefaultMediaTimelineTransformer.d.ts.map

package/dist/types/ts3.7/streaming/mediaTimelineFilter.d.ts

@@ -0,0 +1,18 @@
+import { MediaTimeline } from '../streaming/MediaTimeline';
+import { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { FilterPredicate, FilterPredicateAsync, Maybe } from '@amazon/vinyl-util';
+/**
+ * Filters qualities in a MediaTimeline using a synchronous predicate.
+ * If filtering would remove all qualities from any period, throws via `throwError`.
+ */
+export declare function filterTimelineQualities(filter: Maybe<FilterPredicate<MediaQualityMetadata>>, throwError: () => never, timeline: MediaTimeline): MediaTimeline;
+/**
+ * Filters qualities in a MediaTimeline using an asynchronous predicate.
+ * If filtering would remove all qualities from any period, throws via `throwError`.
+ */
+export declare function filterTimelineQualitiesAsync(filter: FilterPredicateAsync<MediaQualityMetadata>, throwError: () => never, timeline: MediaTimeline): Promise<MediaTimeline>;
+/**
+ * Creates a language filter predicate for use with filterTimelineQualities.
+ */
+export { createLanguageFilter } from '../streaming/mediaTimelineLanguageFilter';
+//# sourceMappingURL=mediaTimelineFilter.d.ts.map

package/dist/types/ts3.7/streaming/mediaTimelineLanguageFilter.d.ts

@@ -0,0 +1,14 @@
+import { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { FilterPredicate } from '@amazon/vinyl-util';
+/**
+ * Creates a filter predicate that keeps qualities matching the preferred language.
+ * The best language match is computed per period (per unique array reference),
+ * so periods with different available languages are handled independently.
+ *
+ * Qualities not matching the content type or without a language tag are always kept.
+ *
+ * @param preferredLanguage BCP 47 language tag, or null to keep all.
+ * @param contentType Only filter qualities matching this content type (e.g. 'audio').
+ */
+export declare function createLanguageFilter(preferredLanguage: string | null, contentType: string): FilterPredicate<MediaQualityMetadata> | null;
+//# sourceMappingURL=mediaTimelineLanguageFilter.d.ts.map

package/dist/types/ts3.7/streaming/util/segment.d.ts

@@ -0,0 +1,28 @@
+import { MediaSegmentMetadata } from '../../streaming/SegmentReference';
+/**
+ * Returns the segment whose range covers `time` (`startTime <= time < endTime`), or
+ * — when `affordance > 0` — the next segment if `time` falls within `affordance`
+ * seconds before its `startTime`. Returns `null` if neither applies.
+ *
+ * Note: with `affordance > 0`, when `time` lies in the last `affordance` seconds of a
+ * segment that does cover it, the *next* segment is returned instead. This is
+ * deliberate — callers use `affordance` to absorb sub-second boundary differences
+ * across qualities — but it means the result is not strictly the segment containing
+ * `time`. Callers needing exact containment should pass `affordance = 0`.
+ *
+ * @param time Lookup time, in seconds.
+ * @param segments Segments sorted by `startTime` ascending.
+ * @param affordance Forward-snap tolerance in seconds: if `time` falls just before a
+ * segment's `startTime` (within `affordance`), that segment is returned. The original
+ * `time` is still compared against `endTime`, so coverage never extends past it.
+ */
+export declare function getSegmentAtTime<T extends MediaSegmentMetadata>(time: number, segments: readonly T[], affordance?: number): T | null;
+/**
+ * Returns the count of segments whose `startTime <= time` — i.e. the index at which a
+ * segment with that `startTime` would be inserted to keep the array sorted ascending.
+ *
+ * @param time Lookup time, in seconds.
+ * @param segments Segments sorted by `startTime` ascending.
+ */
+export declare function getSegmentInsertionIndexAtTime(time: number, segments: readonly MediaSegmentMetadata[]): number;
+//# sourceMappingURL=segment.d.ts.map

package/dist/types/ts3.7/track/AutoResetController.d.ts

@@ -0,0 +1,83 @@
+import { AnyRecord, Clearable, Disposable, EventHostImpl, ReadonlyEventHost } from '@amazon/vinyl-util';
+import { PlaybackController } from '../playback/PlaybackController';
+export interface AutoResetControllerEventMap {
+    /**
+     * Notifies that playback errors should be reset and retried.
+     */
+    readonly reset: AnyRecord;
+}
+/**
+ * Notifies when playback should be reset and retried.
+ *
+ * The controller monitors for retry opportunities after an error is set:
+ * - Immediately on network 'online' events
+ * - After a timeout interval if online
+ * - Immediately on user playback actions (play, pause, seeking, playing)
+ *
+ * Each error triggers a single timeout. If another error occurs after a reset,
+ * setError() should be called again to schedule the next retry attempt.
+ */
+export interface AutoResetController extends ReadonlyEventHost<AutoResetControllerEventMap>, Clearable {
+    /**
+     * Sets the current playback error and begins monitoring for retry opportunities.
+     *
+     * Only SERVICE_INTERNAL ReportableErrors are monitored. Subsequent calls while
+     * an error is already set are ignored until the error is cleared via reset or clear().
+     *
+     * After a reset, if another error occurs, this method should be called again
+     * to schedule the next retry attempt.
+     *
+     * @param error The error to monitor for retry opportunities
+     */
+    setError(error: Error): void;
+}
+export interface AutoResetControllerImplDeps {
+    readonly playbackController: PlaybackController;
+}
+export interface AutoResetControllerImplOptions {
+    /**
+     * If false, disables auto reset behavior.
+     * default: true
+     */
+    readonly enabled: boolean;
+    /**
+     * The total number of times to reset when there has not been successful
+     * playback.
+     *
+     * E.g. a retryInterval of 30 and maxRetries of 30 will retry for 15 minutes before stopping.
+     *
+     * default: 30
+     */
+    readonly maxRetries: number;
+    /**
+     * The number of seconds between retries.
+     *
+     * When an error is set, a single timeout is scheduled for this interval.
+     * If the retry limit hasn't been reached and the device is online, a reset
+     * event is emitted. For subsequent errors after reset, setError() must be
+     * called again to schedule the next retry timeout.
+     */
+    readonly retryInterval: number;
+}
+export declare const defaultResetControllerOptions: {
+    readonly enabled: true;
+    readonly maxRetries: 30;
+    readonly retryInterval: 30;
+};
+export declare class AutoResetControllerImpl extends EventHostImpl<AutoResetControllerEventMap> implements AutoResetController, Disposable {
+    readonly deps: AutoResetControllerImplDeps;
+    get [Symbol.toStringTag](): string;
+    private readonly options;
+    private _error;
+    private watchSub;
+    private currentRetry;
+    private disposer;
+    constructor(deps: AutoResetControllerImplDeps, options?: Partial<AutoResetControllerImplOptions>);
+    setError(error: Error): void;
+    private setWatching;
+    private reset;
+    clear(): void;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=AutoResetController.d.ts.map

package/dist/types/ts3.7/track/Track.d.ts

@@ -0,0 +1,153 @@
+import { AnyRecord, Disposable, LogTarget, ReadonlyEventHost, ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
+import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { StreamingEventMap } from '../streaming/StreamingEventMap';
+/**
+ * All events a track may emit.
+ * Streaming-related events are separated as they will be bubbled by the player.
+ */
+export type TrackEventMap = StreamingEventMap;
+/**
+ * An identifier for a Track, used for referencing a track.
+ */
+export type TrackUri = string;
+/**
+ * A track type identifier. Used to match a track type to its registered factory function.
+ */
+export type TrackTypeId = string;
+/**
+ * Track prefetch configuration provided by the track controller.
+ */
+export interface TrackPreloadOptions {
+    /**
+     * Track priority for prefetching.
+     * Higher values take precedence.
+     */
+    readonly prefetchPriority: number;
+}
+/**
+ * Represents the streaming-related state for a single track.
+ *
+ * Provides read-only access to:
+ * - The currently fetched media time ranges
+ * - The current streaming, buffering, and playback quality metadata
+ *
+ * To observe changes over time, listen to events defined in {@link StreamingEventMap},
+ * including:
+ * - `streamingQualityChange`
+ * - `bufferingQualityChange`
+ * - `playbackQualityChange`
+ */
+export interface ReadonlyStreamingState extends ReadonlyEventHost<StreamingEventMap> {
+    /**
+     * The time ranges the track has fetched.
+     * This will be a snapshot of the fetched ranges at the time this property is accessed.
+     */
+    readonly fetchedRanges: ReadonlyRanges;
+    /**
+     * The current content types for the active streams, e.g. Set(['audio', 'video'])
+     */
+    readonly contentTypes: ReadonlySet<ContentType>;
+    /**
+     * The available qualities for the current period, after filtering.
+     * Null if the timeline is not yet available.
+     */
+    readonly qualities: readonly MediaQualityMetadata[] | null;
+    /**
+     * The available unfiltered qualities for the current period.
+     * Null if the timeline is not yet available.
+     */
+    readonly qualitiesUnfiltered: readonly MediaQualityMetadata[] | null;
+    /**
+     * The currently streaming media quality for the given content stream.
+     * This is set when a new quality is being requested.
+     *
+     * Quality metadata progresses as follows:
+     * streamingQuality -> bufferingQuality -> playbackQuality
+     *
+     * Listen to {@link TrackEventMap.streamingQualityChange} events for changes.
+     * @param contentType 'video' | 'audio' | 'text'
+     */
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    /**
+     * The currently buffering media quality for the given content stream.
+     * This is set immediately before a segment of a new quality is appended.
+     *
+     * Listen to {@link TrackEventMap.bufferingQualityChange} events for changes.
+     * @param contentType 'video' | 'audio' | 'text'
+     */
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    /**
+     * When this track is active, provides the currently playing media metadata
+     * for the given content type.
+     *
+     * Listen to {@link TrackEventMap.playbackQualityChange} events for changes.
+     * @param contentType 'video' | 'audio' | 'text'
+     */
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+}
+export interface StreamingState extends ReadonlyStreamingState {
+    /**
+     * Clears any buffered or prefetched data, if applicable.
+     */
+    clearPrefetch(): void;
+    /**
+     * Resets the track to recover from error states.
+     * This will reset failed segments and clear error conditions to allow streaming to resume.
+     */
+    reset(): void;
+}
+export interface ReadonlyTrack extends ReadonlyStreamingState, LogTarget {
+    /**
+     * The track identifier.
+     */
+    readonly uri: TrackUri;
+    /**
+     * The type of track.
+     */
+    readonly type: TrackTypeId;
+    /**
+     * True if the track is the currently playing track.
+     */
+    readonly active: boolean;
+    /**
+     * True if the track has been disposed.
+     */
+    readonly disposed: boolean;
+    /**
+     * Returns the `extra` object from the load configuration's `config` when
+     * this track is active, or null if this track is not active.
+     */
+    readonly extra: any;
+    /**
+     * The last error that occurred in this track, or null if no error.
+     */
+    readonly error: Error | null;
+}
+/**
+ * One track is active on the track controller at a time.
+ */
+export interface Track<LoadOptionsType extends AnyRecord = AnyRecord> extends ReadonlyTrack, StreamingState, Disposable {
+    /**
+     * Provides configuration to the track and begins preloading (if applicable).
+     *
+     * @param trackOptions Configuration provided by the TrackController.
+     * @param loadOptions Configuration from `TrackLoadOptions.config`, provided by the Application.
+     */
+    preload(trackOptions: TrackPreloadOptions, loadOptions: LoadOptionsType): void;
+    /**
+     * Sets this track as active, deactivating any currently active track.
+     * This should set sources on the playback source and add any listeners needed for shared
+     * resources.
+     *
+     * @param loadOptions Configuration from `TrackLoadOptions.config`, provided by the Application.
+     */
+    activate(loadOptions: LoadOptionsType): void;
+    /**
+     * Sets this track as inactive.
+     * This should unset sources, and remove any listeners. Tracks do not implement disposable,
+     * when they are deactivated they are expected to be free for garbage collection if there
+     * are no longer references to the track.
+     */
+    deactivate(): void;
+}
+//# sourceMappingURL=Track.d.ts.map

package/dist/types/ts3.7/track/TrackBase.d.ts

@@ -0,0 +1,109 @@
+import { ObjectSchema } from '@amazon/vinyl-validation';
+import { EventHostImpl, Maybe, ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
+import { PlaybackController } from '../playback/PlaybackController';
+import { Track, TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from './Track';
+import { DrmController } from '../drm/DrmController';
+import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { DrmOptions } from '../drm/DrmOptions';
+/**
+ * Dependencies for TrackBase.
+ */
+export interface TrackBaseDeps {
+    /**
+     * When the track is activated, playback will seek to the track's start time.
+     */
+    readonly playbackController: PlaybackController;
+    /**
+     * DrmController manages track encryption.
+     */
+    readonly drmController: DrmController;
+}
+/**
+ * General configuration for tracks set in track load options.
+ */
+export interface TrackBaseOptions {
+    /**
+     * The time to seek to when the track has been activated.
+     * For MSE tracks this will affect pre-fetching.
+     */
+    readonly startTime?: Maybe<number>;
+    /**
+     * Extra application data to associate with the track.
+     */
+    readonly extra?: any;
+    /**
+     * DRM Configuration overrides for this track.
+     */
+    readonly drm?: Partial<DrmOptions>;
+}
+export declare const trackBaseOptionsValidator: ObjectSchema<TrackBaseOptions>;
+/**
+ * A base class for all tracks.
+ */
+export declare abstract class TrackBase<EventMap extends TrackEventMap = TrackEventMap, LoadOptionsType extends TrackBaseOptions = TrackBaseOptions> extends EventHostImpl<EventMap> implements Track<LoadOptionsType> {
+    /**
+     * The identifier of this track, used as the key in the track cache.
+     */
+    readonly uri: TrackUri;
+    /**
+     * The track type.
+     */
+    readonly type: TrackTypeId;
+    protected readonly deps: TrackBaseDeps;
+    get [Symbol.toStringTag](): string;
+    /**
+     * The current load options, if this is an active track.
+     */
+    protected loadOptions: LoadOptionsType | null;
+    protected readonly errorHandler: (error: any) => void;
+    protected readonly disposer: import("@amazon/vinyl-util").Disposer;
+    protected drmSessionAbort: import("@amazon/vinyl-util").AbortSlot;
+    get fetchedRanges(): ReadonlyRanges;
+    abstract get contentTypes(): ReadonlySet<ContentType>;
+    abstract get qualities(): (readonly MediaQualityMetadata[] | null);
+    abstract get qualitiesUnfiltered(): (readonly MediaQualityMetadata[] | null);
+    abstract getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    abstract getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    abstract getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    /**
+     * Sets on handleError, cleared on 'reset'.
+     */
+    protected _error: Error | null;
+    private _active;
+    protected constructor(
+    /**
+     * The identifier of this track, used as the key in the track cache.
+     */
+    uri: TrackUri, 
+    /**
+     * The track type.
+     */
+    type: TrackTypeId, deps: TrackBaseDeps);
+    get error(): (Error | null);
+    preload(_trackOptions: TrackPreloadOptions, _loadOptions: LoadOptionsType): void;
+    get extra(): any;
+    get active(): boolean;
+    get disposed(): boolean;
+    activate(loadOptions: LoadOptionsType): void;
+    /**
+     * The track has been activated.
+     * Operations on shared resources such as the playback controller may only be done while the
+     * track is currently active. For example if there is a loading operation before the
+     * playback source is set, isActive must be checked before the property is changed.
+     */
+    abstract onActivated(loadOptions: LoadOptionsType): void;
+    deactivate(): void;
+    abstract onDeactivated(): void;
+    toString(): string;
+    protected closeDrmSessions(): void;
+    abstract clearPrefetch(): void;
+    /**
+     * Resets the track to recover from error states.
+     * Base implementation does nothing.
+     *
+     * Overrides should dispatch 'reset' after resetting error state.
+     */
+    reset(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=TrackBase.d.ts.map