@amazon/vinyl 1.0.0

package/dist/types/ts4.1/track/Track.d.ts

@@ -0,0 +1,153 @@
+import type { AnyRecord, Disposable, LogTarget, ReadonlyEventHost, ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
+import type { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import type { 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/ts4.1/track/TrackBase.d.ts

@@ -0,0 +1,110 @@
+import type { ObjectSchema } from '@amazon/vinyl-validation';
+import type { Maybe, ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import type { PlaybackController } from '../playback/PlaybackController';
+import type { Track, TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from './Track';
+import type { DrmController } from '../drm/DrmController';
+import type { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import type { 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

package/dist/types/ts4.1/track/TrackController.d.ts

@@ -0,0 +1,243 @@
+import type { AnyRecord, Disposable, Maybe, ReadonlyEventHost } from '@amazon/vinyl-util';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import type { PlaybackController } from '../playback/PlaybackController';
+import type { ReadonlyTrack, TrackUri } from '../track/Track';
+import type { TrackFactory, TrackLoadOptions } from '../track/TrackFactory';
+import type { ChangeEvent } from '../event/ChangeEvent';
+export interface TrackControllerEventMap<TrackLoadOptionsType extends TrackLoadOptions> {
+    /**
+     * Emitted when the current track is changing.
+     * This is emitted before the previous track has been deactivated and
+     * new track has been activated.
+     */
+    readonly currentTrackChanging: ChangeEvent<ReadonlyTrack | null>;
+    /**
+     * Emitted when the current track has changed.
+     * If there is a queue change, the currentTrackChange event is always emitted first.
+     * This is emitted after the previous track has been deactivated and
+     * new track has been activated.
+     */
+    readonly currentTrackChange: ChangeEvent<ReadonlyTrack | null>;
+    /**
+     * Dispatched when the queue has changed.
+     */
+    readonly queueChange: ChangeEvent<readonly TrackLoadOptionsType[]>;
+    /**
+     * Emitted when the last track of the playback queue has ended.
+     * When the last track in a queue has ended, the track will not change and therefore a `currentTrackChange`
+     * event will not be emitted.
+     */
+    readonly queueEnded: AnyRecord;
+}
+export declare const ALL_TRACK_CONTROLLER_EVENTS: readonly [
+    "currentTrackChanging",
+    "currentTrackChange",
+    "queueChange",
+    "queueEnded"
+];
+/**
+ * A readonly interface to the track controller.
+ */
+export interface ReadonlyTrackController<TrackLoadOptionsType extends TrackLoadOptions> extends ReadonlyEventHost<TrackControllerEventMap<TrackLoadOptionsType>> {
+    /**
+     * Returns the current track.
+     */
+    readonly currentTrack: ReadonlyTrack | null;
+    /**
+     * Returns the current queue of TrackLoadOptions.
+     * Observe 'queueChange' for changes to this queue.
+     */
+    readonly queue: readonly TrackLoadOptionsType[];
+    /**
+     * Returns true if there is at least one track in the queue.
+     */
+    hasNext(): boolean;
+    /**
+     * Returns true if the track with the given URI is cached.
+     */
+    isTrackCached(uri: TrackUri): boolean;
+    /**
+     * Returns the cached track for the given URI, or null if the track is not cached.
+     */
+    getCachedTrack(uri: TrackUri): ReadonlyTrack | null;
+    /**
+     * Returns an iterator of currently cached tracks.
+     */
+    getCachedTracks(): IterableIterator<ReadonlyTrack>;
+}
+/**
+ * Responsible for queuing track load configurations.
+ * This is the authority for which is the current track.
+ */
+export interface TrackController<TrackLoadOptionsType extends TrackLoadOptions> extends ReadonlyTrackController<TrackLoadOptionsType> {
+    /**
+     * Preloads the given list of tracks.
+     * The tracks provided will not be enqueued.
+     * The track controller's cache size will automatically increase to accommodate the request.
+     *
+     * Prefetch priority note:
+     * Tracks have a prefetch priority, later calls to preload will have a higher precedence than previous calls.
+     * Previous tracks given to `preload` will drop off when they are evicted from the cache. This is dependent on
+     * cache size.
+     *
+     * @param loadOptionsList
+     */
+    preload(...loadOptionsList: readonly TrackLoadOptionsType[]): void;
+    /**
+     * Sets the current queue to the provided track list.
+     * When the track ends, the next will be played.
+     *
+     * `load` does not begin playback. Call `play()` after a load to start playback.
+     * Browser autoplay policies may require the first call to `play()` to be in response to a user interaction
+     * such as a click, touch, keypress, or voice event.
+     *
+     * Note that if the current track is the first track provided in the list, that track will be restarted.
+     * To set the queue without unloading the current track, use {@link clearQueue} followed by {@link enqueue}.
+     *
+     * @param loadOptionsList A list of load configuration objects to set as a playback queue.
+     */
+    load(...loadOptionsList: readonly TrackLoadOptionsType[]): void;
+    /**
+     * Unloads the active track and clears the queue.
+     * This is the same as calling {@link load} with zero parameters.
+     */
+    unload(): void;
+    /**
+     * Appends the given tracks to the current queue.
+     *
+     * @param loadOptionsList The track load configurations to append.
+     */
+    enqueue(...loadOptionsList: readonly TrackLoadOptionsType[]): void;
+    /**
+     * Activates the next track in the queue.
+     * If the media is not paused the next track will begin playing automatically.
+     *
+     * @see ReadonlyTrackController.hasNext
+     */
+    next(): void;
+    /**
+     * Clears all fetched fragments and source buffers.
+     * Playback will be interrupted, and streaming will resume again when data has been fetched and buffered.
+     * 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.
+     *
+     * Does not unload manifests.
+     */
+    clearPrefetch(): void;
+    /**
+     * Clears the track cache and unloads the current track.
+     */
+    clearTrackCache(): void;
+    /**
+     * Clears the current queue.
+     * Does not stop the current track or affect the prefetched cache.
+     */
+    clearQueue(): void;
+    /**
+     * Resets the current track's error state.
+     */
+    reset(): void;
+}
+export interface TrackControllerImplDeps<TrackLoadOptionsType extends TrackLoadOptions> {
+    readonly trackFactory: TrackFactory<TrackLoadOptionsType>;
+    readonly playbackController: PlaybackController;
+}
+export interface TrackControllerImplOptions {
+    /**
+     * When tracks are queued, the number of tracks to prefetch ahead of the current track.
+     * Default: 2
+     */
+    readonly trackPrefetchCount: number;
+    /**
+     * The number of seconds before load calls will time out if the first track's metadata is not loaded within
+     * this time.
+     * Default: 60
+     */
+    readonly loadTimeout: number;
+    /**
+     * The number of tracks that may be preloaded at one time (not counting queue prefetch).
+     * This extends the track cache capacity and allows a certain number of tracks no longer in the queue to remain
+     * cached.
+     *
+     * Default: 2
+     */
+    readonly preloadCapacity: number;
+}
+/**
+ * Track priority will be assigned based on calls to `preload`.
+ * Segment background prefetching is shared if there are multiple players instances (in the rare case there would be
+ * multiple players). Having a global incrementing trackPriority prevents one player from starving another.
+ */
+export declare const trackPriority: {
+    value: number;
+};
+export declare class TrackControllerImpl<TrackLoadOptionsType extends TrackLoadOptions> extends EventHostImpl<TrackControllerEventMap<TrackLoadOptionsType>> implements TrackController<TrackLoadOptionsType>, Disposable {
+    private readonly deps;
+    get [Symbol.toStringTag](): string;
+    private _autoPreloadCapacity;
+    private readonly trackCache;
+    private _queue;
+    private _current;
+    private readonly disposer;
+    private _options;
+    private trackEndedTimeoutId;
+    constructor(deps: TrackControllerImplDeps<TrackLoadOptionsType>, initialOptions?: Partial<TrackControllerImplOptions>);
+    private clearTrackEndedTimeout;
+    get options(): TrackControllerImplOptions;
+    /**
+     * Configures this track queue from the provided partial options.
+     *
+     * @param options
+     */
+    configure(options: Maybe<Partial<TrackControllerImplOptions>>): void;
+    /**
+     * Checks if the cache capacity needs to be changed.
+     */
+    private checkCacheCapacity;
+    get queue(): readonly TrackLoadOptionsType[];
+    /**
+     * Returns the subset of the queue that should be prefetched.
+     * @private
+     */
+    private get prefetched();
+    isTrackCached(uri: TrackUri): boolean;
+    getCachedTrack(uri: TrackUri): ReadonlyTrack | null;
+    getCachedTracks(): IterableIterator<ReadonlyTrack>;
+    get preloadCapacity(): number;
+    private validateLoadOptions;
+    preload(...loadOptionsList: readonly TrackLoadOptionsType[]): void;
+    private _preload;
+    load(...loadOptionsList: readonly TrackLoadOptionsType[]): void;
+    unload(): void;
+    enqueue(...loadOptionsList: readonly TrackLoadOptionsType[]): void;
+    hasNext(): boolean;
+    next(): void;
+    clearTrackCache(): void;
+    clearPrefetch(): void;
+    clearQueue(): void;
+    /**
+     * If the given track id is the current track or in the cache, returns that track.
+     * Otherwise, constructs a new track, adds it to the cache, and returns it.
+     *
+     * @param uri The unique resource identifier.
+     * @param loadOptions
+     * @private
+     */
+    private getOrCreateTrack;
+    /**
+     * Get the current track from cache or create a new track, then activates that track.
+     */
+    private activateCurrent;
+    private _currentTrack;
+    get currentTrack(): (ReadonlyTrack | null);
+    /**
+     * Sets the current track. If the given track is already current, it will be de-activated and re-activated and
+     * the currentTrackChange event will still be emitted.
+     * The same track may be in the queue multiple times.
+     */
+    private setCurrentTrack;
+    private clearCurrentTrack;
+    reset(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=TrackController.d.ts.map

package/dist/types/ts4.1/track/TrackFactory.d.ts

@@ -0,0 +1,50 @@
+import type { AnyRecord, Maybe, ReadonlyRecord } from '@amazon/vinyl-util';
+import type { ObjectSchema } from '@amazon/vinyl-validation';
+import type { Track, TrackTypeId, TrackUri } from '../track/Track';
+export interface TrackLoadOptions {
+    /**
+     * The track type, used to map to a track factory.
+     */
+    readonly type: TrackTypeId;
+    /**
+     * The track identifier.
+     */
+    readonly uri: TrackUri;
+    /**
+     * The track configuration.
+     */
+    readonly config?: Maybe<AnyRecord>;
+}
+export declare const trackLoadOptionsValidator: ObjectSchema<TrackLoadOptions>;
+/**
+ * Produces a new Track for the given configuration options.
+ */
+export interface TrackFactory<TrackLoadOptionsType extends TrackLoadOptions> {
+    /**
+     * Throws a validation error if the track options are invalid.
+     */
+    validate(options: TrackLoadOptionsType): void;
+    /**
+     * Constructs a new track from the provided load options.
+     */
+    createTrack(options: TrackLoadOptionsType): Track;
+}
+export type InferLoadOptionsFromFactory<T extends TrackFactory<any>> = T extends TrackFactory<infer LoadOptions> ? LoadOptions : never;
+export type CombinedTrackFactoryOptions<T extends ReadonlyRecord<TrackTypeId, TrackFactory<TrackLoadOptions>>> = InferLoadOptionsFromFactory<T[keyof T]>;
+export type TrackFactoryRecord = ReadonlyRecord<TrackTypeId, TrackFactory<TrackLoadOptions>>;
+/**
+ * Validates that the keys of the track factory record match the track type
+ * for the track factory.
+ */
+export type ValidTrackFactoryRecord<T extends TrackFactoryRecord> = {
+    readonly [K in keyof T]: K extends InferLoadOptionsFromFactory<T[K]>['type'] ? T[K] : never;
+};
+/**
+ * Given a map of TrackTypeId => TrackFactory, returns a track factory
+ * that supports any of the provided track types.
+ * The factory will be mapped by the track load options `type` property.
+ *
+ * @param factories
+ */
+export declare function createTrackFactory<T extends TrackFactoryRecord>(factories: ValidTrackFactoryRecord<T>): TrackFactory<CombinedTrackFactoryOptions<T>>;
+//# sourceMappingURL=TrackFactory.d.ts.map

package/dist/types/ts4.1/track/createSegmentDataProvider.d.ts

@@ -0,0 +1,18 @@
+import type { Maybe, RequestInitOptions, RequestInterceptor } from '@amazon/vinyl-util';
+import type { ByteRange } from '@amazon/vinyl-mpd-parser';
+import type { SegmentDataProvider } from '../streaming/SegmentDataSlot';
+export interface CreateSegmentDataProviderDeps {
+    readonly requestInterceptor: RequestInterceptor;
+    readonly segmentRequestInit: Maybe<RequestInitOptions>;
+}
+export interface CreateSegmentDataProviderOptions {
+    readonly url: string;
+    readonly mediaRange?: Maybe<ByteRange>;
+    readonly serviceId?: Maybe<string>;
+    /**
+     * If true, reports downlink transfer speeds to network metrics.
+     */
+    readonly reportDownlinkMetrics: boolean;
+}
+export declare function createSegmentDataProvider(deps: CreateSegmentDataProviderDeps, options: CreateSegmentDataProviderOptions): SegmentDataProvider;
+//# sourceMappingURL=createSegmentDataProvider.d.ts.map

package/dist/types/ts4.1/track/createVinylTrackFactories.d.ts

@@ -0,0 +1,19 @@
+import type { SourceObjectTrackDeps, SourceObjectTrackLoadOptions } from '../track/source/SourceObjectTrack';
+import type { SourceTrackDeps, SourceTrackLoadOptions } from '../track/source/SourceTrack';
+import type { TrackFactory } from '../track/TrackFactory';
+import type { DashTrackFactoryDeps, DashTrackLoadOptions } from '../track/dash/DashTrack';
+import type { HlsTrackFactoryDeps, HlsTrackLoadOptions } from '../track/hls/HlsTrack';
+export interface VinylTrackFactoryDeps extends SourceTrackDeps, SourceObjectTrackDeps, DashTrackFactoryDeps, HlsTrackFactoryDeps {
+}
+export type VinylTrackLoadOptions = SourceObjectTrackLoadOptions | SourceTrackLoadOptions | DashTrackLoadOptions | HlsTrackLoadOptions;
+/**
+ * Provides a map of track type id to their respective loaders.
+ * @param deps
+ */
+export declare function createVinylTrackFactories(deps: VinylTrackFactoryDeps): {
+    readonly src: TrackFactory<SourceTrackLoadOptions>;
+    readonly srcObject: TrackFactory<SourceObjectTrackLoadOptions>;
+    readonly dash: TrackFactory<DashTrackLoadOptions>;
+    readonly hls: TrackFactory<HlsTrackLoadOptions>;
+};
+//# sourceMappingURL=createVinylTrackFactories.d.ts.map

package/dist/types/ts4.1/track/dash/DashManifestController.d.ts

@@ -0,0 +1,39 @@
+import type { DashManifestData, DashManifestProvider } from '../../track/dash/DashManifestProvider';
+import type { ManifestController } from '../../streaming/ManifestController';
+export type DashManifestController = ManifestController<Promise<DashManifestData>>;
+export interface DashManifestControllerImplDeps {
+    /**
+     * Resolves the untransformed manifest.
+     */
+    readonly manifestProvider: DashManifestProvider;
+}
+export declare class DashManifestControllerImpl implements DashManifestController {
+    readonly deps: DashManifestControllerImplDeps;
+    get [Symbol.toStringTag](): string;
+    get logPrefix(): string;
+    private readonly _data;
+    private _error;
+    private readonly abortSlot;
+    private readonly disposer;
+    constructor(deps: DashManifestControllerImplDeps);
+    get error(): (Error | null);
+    /**
+     * Reloads the manifest. Aborts any in-flight request and clears any
+     * previous error before starting a new fetch.
+     */
+    refresh(): void;
+    /**
+     * If the manifest is in an error state, triggers a refresh.
+     */
+    reset(): void;
+    get value(): Promise<DashManifestData>;
+    get changeId(): number;
+    getValue(): Promise<DashManifestData>;
+    onData(callback: (value: Promise<DashManifestData>, previous: Promise<DashManifestData> | undefined) => void): import("@amazon/vinyl-util").Unsubscribe;
+    map<U>(transform: (value: Promise<DashManifestData>) => U): import("@amazon/vinyl-observable").MutableValue<U>;
+    pick<K extends keyof NonNullable<Promise<DashManifestData>>>(prop: K): import("@amazon/vinyl-observable").MutableValue<Promise<DashManifestData>[K]>;
+    private abort;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=DashManifestController.d.ts.map

package/dist/types/ts4.1/track/dash/DashManifestProvider.d.ts

@@ -0,0 +1,19 @@
+import type { ReadonlyAbort } from '@amazon/vinyl-util';
+import type { DashManifest } from '@amazon/vinyl-mpd-parser';
+/**
+ * Provides a dash manifest.
+ */
+export type DashManifestProvider = (abort?: ReadonlyAbort) => Promise<DashManifestData>;
+export interface DashManifestData {
+    /**
+     * The Dash manifest.
+     */
+    readonly manifest: DashManifest;
+    /**
+     * The URL to be used for relative requests. Guaranteed to be absolute.
+     *
+     * Media with relative paths in the manifests will be resolved relative to this URL.
+     */
+    readonly baseUrl: string;
+}
+//# sourceMappingURL=DashManifestProvider.d.ts.map