@amazon/vinyl 1.0.0

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

@@ -0,0 +1,242 @@
+import { AnyRecord, Disposable, EventHostImpl, Maybe, ReadonlyEventHost } from '@amazon/vinyl-util';
+import { PlaybackController } from '../playback/PlaybackController';
+import { ReadonlyTrack, TrackUri } from '../track/Track';
+import { TrackFactory, TrackLoadOptions } from '../track/TrackFactory';
+import { 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/ts3.7/track/TrackFactory.d.ts

@@ -0,0 +1,50 @@
+import { AnyRecord, Maybe, ReadonlyRecord } from '@amazon/vinyl-util';
+import { ObjectSchema } from '@amazon/vinyl-validation';
+import { 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/ts3.7/track/createSegmentDataProvider.d.ts

@@ -0,0 +1,18 @@
+import { Maybe, RequestInitOptions, RequestInterceptor } from '@amazon/vinyl-util';
+import { ByteRange } from '@amazon/vinyl-mpd-parser';
+import { 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/ts3.7/track/createVinylTrackFactories.d.ts

@@ -0,0 +1,19 @@
+import { SourceObjectTrackDeps, SourceObjectTrackLoadOptions } from '../track/source/SourceObjectTrack';
+import { SourceTrackDeps, SourceTrackLoadOptions } from '../track/source/SourceTrack';
+import { TrackFactory } from '../track/TrackFactory';
+import { DashTrackFactoryDeps, DashTrackLoadOptions } from '../track/dash/DashTrack';
+import { 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/ts3.7/track/dash/DashManifestController.d.ts

@@ -0,0 +1,39 @@
+import { DashManifestData, DashManifestProvider } from '../../track/dash/DashManifestProvider';
+import { 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/ts3.7/track/dash/DashManifestProvider.d.ts

@@ -0,0 +1,19 @@
+import { ReadonlyAbort } from '@amazon/vinyl-util';
+import { 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

package/dist/types/ts3.7/track/dash/DashMediaQualityMetadataResolver.d.ts

@@ -0,0 +1,43 @@
+import { ContentProtection, PeriodType, RepresentationType } from '@amazon/vinyl-mpd-parser';
+import { ContentType, DrmProtection, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
+/**
+ * DASH supplemental property scheme URI for adaptation set switching.
+ * @see https://dashif.org/docs/DASH-IF-IOP-v4.3.pdf Section 3.8
+ */
+export declare const ADAPTATION_SET_SWITCHING_SCHEME = "urn:mpeg:dash:adaptation-set-switching:2016";
+/**
+ * Creates abstract MediaQualityMetadata from a Dash Representation.
+ */
+export type DashMediaQualityMetadataResolver = (representation: RepresentationType) => MediaQualityMetadata;
+/**
+ * Returns a dash metadata resolver that calculates media encoding metadata from the representation.
+ * The most recently used representations will return cached results.
+ */
+export declare function createDefaultDashMediaQualityMetadataResolver(deps: DashMediaQualityMetadataResolverDeps): DashMediaQualityMetadataResolver;
+export interface DashMediaQualityMetadataResolverDeps {
+    readonly drmKeySystemResolver: DrmKeySystemResolver;
+}
+export declare function createMediaQualityMetadataFromDashRepresentation(representation: RepresentationType, deps: DashMediaQualityMetadataResolverDeps): MediaQualityMetadata;
+/**
+ * Estimates the total bandwidth a representation would use when paired with
+ * proportionally matched qualities from sibling content types.
+ *
+ * For each sibling content type, the representation's relative position within its own
+ * content type's sorted bandwidth list is mapped to the corresponding position in the
+ * sibling's list. This produces realistic pairings — e.g. with video [v1,v2,v3,v4] and
+ * audio [a1,a2], v1 pairs with a1, v2 with a1, v3 with a2, v4 with a2.
+ */
+export declare function estimatePeakBandwidth(representation: RepresentationType, contentType: ContentType): number;
+/**
+ * Returns sorted (descending) bandwidth arrays per content type for a period.
+ * Bandwidths within 10% of an existing entry are collapsed to reduce noise
+ * from near-duplicate quality tiers.
+ * Cached by period reference.
+ */
+export declare const getPeriodSortedBandwidths: import("@amazon/vinyl-util").MemoizedFunction & ((period: PeriodType) => ReadonlyMap<ContentType, readonly number[]>);
+/**
+ * Converts a Dash ContentProtection element to a list of DrmProtection metadata.
+ */
+export declare function contentProtectionToMetadata(contentProtection: ContentProtection, deps: DashMediaQualityMetadataResolverDeps): readonly DrmProtection[];
+//# sourceMappingURL=DashMediaQualityMetadataResolver.d.ts.map

package/dist/types/ts3.7/track/dash/DashTrack.d.ts

@@ -0,0 +1,46 @@
+import { TrackBaseOptions } from '../../track/TrackBase';
+import { DashManifestProvider, DashManifestData } from './DashManifestProvider';
+import { DashManifestController } from './DashManifestController';
+import { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { Maybe, RequestInitOptions } from '@amazon/vinyl-util';
+import { Factories } from '@amazon/vinyl-di';
+import { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
+import { MseTrackDeps } from '../../track/mse/MseTrack';
+import { MediaTimeline } from '../../streaming/MediaTimeline';
+export interface DashTrackLoadOptions extends TrackLoadOptions {
+    readonly type: 'dash';
+    /**
+     * If set, will be used to resolve the dash manifest.
+     * Otherwise, the uri will be assumed to represent a URL to an MPD.
+     * The manifest provider is not expected to cache results.
+     */
+    readonly manifestProvider?: Maybe<DashManifestProvider>;
+    /**
+     * If a manifest provider is not set, the uri will be used to fetch a manifest.
+     * This can be set to provide Request initialization options such as headers or request method.
+     */
+    readonly requestInit?: Maybe<RequestInitOptions>;
+    /**
+     * Request initialization options for segment requests, such as headers.
+     * Range headers set by the player for byte-range requests will not be overridden.
+     */
+    readonly segmentRequestInit?: Maybe<RequestInitOptions>;
+    /**
+     * Configuration options for the DashTrack.
+     * Will be set before the track is activated.
+     */
+    readonly config?: Maybe<TrackBaseOptions>;
+}
+export type DashTrackFactoryDeps = {
+    readonly createDashFactories: (loadOptions: DashTrackLoadOptions) => Factories<DashTrackDeps>;
+};
+export declare function createDashTrackFactory(deps: DashTrackFactoryDeps): TrackFactory<DashTrackLoadOptions>;
+export interface DashTrackDeps extends MseTrackDeps {
+    readonly manifestController: DashManifestController;
+    readonly mediaQualityMetadataResolver: DashMediaQualityMetadataResolver;
+    readonly manifestTransformed: ObservableValue<Promise<DashManifestData>>;
+    readonly mediaTimeline: ObservableValue<Promise<MediaTimeline>>;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+}
+//# sourceMappingURL=DashTrack.d.ts.map

package/dist/types/ts3.7/track/dash/buildDashMediaTimeline.d.ts

@@ -0,0 +1,9 @@
+import { DashManifestData } from '../../track/dash/DashManifestProvider';
+import { MediaTimeline } from '../../streaming/MediaTimeline';
+import { DashSegmentProviderDeps } from '../../track/dash/timeline/DashRepresentationSegmentProvider';
+export type BuildDashMediaTimelineDeps = DashSegmentProviderDeps;
+/**
+ * Builds a MediaTimeline from a Dash manifest.
+ */
+export declare function buildDashMediaTimeline(deps: BuildDashMediaTimelineDeps, data: DashManifestData): MediaTimeline;
+//# sourceMappingURL=buildDashMediaTimeline.d.ts.map

package/dist/types/ts3.7/track/dash/createDashContentStreamFactories.d.ts

@@ -0,0 +1,33 @@
+import { MediaSourceController } from '../../streaming/buffering/MediaSourceController';
+import { PlaybackController } from '../../playback/PlaybackController';
+import { QualitySelector } from '../../streaming/abr/QualitySelector';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { ContentType } from '../../streaming/MediaQualityMetadata';
+import { SourceBufferControllerImpl, SourceBufferControllerImplDeps } from '../../streaming/buffering/SourceBufferController';
+import { BufferingControllerImpl, BufferingControllerImplDeps } from '../../streaming/buffering/BufferingController';
+import { SegmentControllerImpl, SegmentControllerImplDeps } from '../../streaming/SegmentControllerImpl';
+import { Maybe } from '@amazon/vinyl-util';
+import { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
+import { MediaTimeline } from '../../streaming/MediaTimeline';
+/**
+ * Dependencies needed for a new content stream provided by the dash track.
+ */
+export interface DashContentStreamTrackDeps {
+    readonly mediaSourceController: MediaSourceController;
+    readonly playbackController: PlaybackController;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+    readonly qualitySelector: QualitySelector;
+}
+/**
+ * Returns a function to produce the Factories needed for a new ContentStreamImpl.
+ */
+export declare function createDashContentStreamFactories(options: Maybe<ContentStreamingOptions>): (deps: DashContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: ContentType) => {
+    sourceBufferControllerFactory: (deps: SourceBufferControllerImplDeps) => () => SourceBufferControllerImpl;
+    bufferingController: (deps: BufferingControllerImplDeps) => BufferingControllerImpl;
+    segmentController: (deps: SegmentControllerImplDeps) => SegmentControllerImpl;
+    mediaSourceController: import("@amazon/vinyl-di").Factory<MediaSourceController>;
+    playbackController: import("@amazon/vinyl-di").Factory<PlaybackController>;
+    mediaTimelineTransformed: import("@amazon/vinyl-di").Factory<ObservableValue<Promise<MediaTimeline>>>;
+    qualitySelector: import("@amazon/vinyl-di").Factory<QualitySelector>;
+});
+//# sourceMappingURL=createDashContentStreamFactories.d.ts.map

package/dist/types/ts3.7/track/dash/createDashContentTypesValue.d.ts

@@ -0,0 +1,14 @@
+import { DashManifestData } from '../../track/dash/DashManifestProvider';
+import { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
+import { ContentTypesValue } from '../../streaming/ContentTypesValue';
+import { ObservableValue } from '@amazon/vinyl-observable';
+export interface DashContentTypesValueDeps {
+    readonly manifestTransformed: ObservableValue<Promise<DashManifestData>>;
+    readonly mediaQualityMetadataResolver: DashMediaQualityMetadataResolver;
+}
+/**
+ * Creates an ObservableValue for the types of streams that are available in the
+ * filtered dash manifest.
+ */
+export declare function createDashContentTypesValue(deps: DashContentTypesValueDeps): ContentTypesValue;
+//# sourceMappingURL=createDashContentTypesValue.d.ts.map

package/dist/types/ts3.7/track/dash/createDashFactories.d.ts

@@ -0,0 +1,84 @@
+import { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import { Maybe, RequestInterceptor } from '@amazon/vinyl-util';
+import { createDefaultDashManifestTransformer } from '../../track/dash/createDefaultDashManifestTransformer';
+import { createMediaSource } from '../../util/media/mediaSource';
+import { DashMediaQualityMetadataResolverDeps } from '../../track/dash/DashMediaQualityMetadataResolver';
+import { MediaSourceControllerImpl, MediaSourceControllerImplDeps } from '../../streaming/buffering/MediaSourceController';
+import { PlaybackController } from '../../playback/PlaybackController';
+import { DashManifestController, DashManifestControllerImplDeps } from '../../track/dash/DashManifestController';
+import { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
+import { DrmController } from '../../drm/DrmController';
+import { Capabilities } from '../../client/Capabilities';
+import { QualitySelectorImpl, QualitySelectorImplOptions } from '../../streaming/abr/QualitySelectorImpl';
+import { PlaybackSource } from '../../playback/PlaybackSource';
+import { createContentStreamFactory } from '../../streaming/ContentStream';
+import { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
+import { createDashContentTypesValue } from '../../track/dash/createDashContentTypesValue';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { VinylOptions } from '../../vinyl/VinylOptions';
+import { BuildDashMediaTimelineDeps } from '../../track/dash/buildDashMediaTimeline';
+import { createDefaultMediaTimelineTransformer } from '../../streaming/createDefaultMediaTimelineTransformer';
+import { DashManifestData } from '../../track/dash/DashManifestProvider';
+/**
+ * Player-level dependencies needed for the Dash-specific factories.
+ */
+export interface DashFactoryDeps {
+    readonly options: ObservableValue<{
+        readonly abr: QualitySelectorImplOptions;
+        readonly preferredAudioLanguage: string | null;
+    }>;
+    readonly playbackController: PlaybackController;
+    readonly playbackSource: PlaybackSource;
+    readonly drmKeySystemResolver: DrmKeySystemResolver;
+    readonly requestInterceptor: RequestInterceptor;
+    readonly drmController: DrmController;
+    readonly capabilities: Capabilities;
+}
+export type DashInitOptions = {
+    readonly streaming?: Maybe<ContentStreamingOptions>;
+};
+/**
+ * Returns a function that provides default dependency factories required for
+ * a new DashTrack.
+ */
+export declare function createDashFactories(options: Maybe<DashInitOptions>): (deps: DashFactoryDeps) => (loadOptions: DashTrackLoadOptions) => {
+    contentTypesValue: typeof createDashContentTypesValue;
+    baseUrlSelector: () => import("../../track/dash/util/uriResolution").BaseUrlSelector;
+    segmentRequestInit: () => Maybe<Readonly<Omit<RequestInit, "signal">>>;
+    manifestProvider: (deps: {
+        readonly requestInterceptor: RequestInterceptor;
+    }) => import("../../track/dash/DashManifestProvider").DashManifestProvider;
+    manifestController: (deps: DashManifestControllerImplDeps) => DashManifestController;
+    mediaSourceFactory: () => typeof createMediaSource;
+    mediaQualityMetadataResolver: (deps: DashMediaQualityMetadataResolverDeps) => import("../../track/dash/DashMediaQualityMetadataResolver").DashMediaQualityMetadataResolver;
+    mediaSourceController: (deps: MediaSourceControllerImplDeps) => MediaSourceControllerImpl;
+    createContentStreamFactories: (deps: import("../../track/dash/createDashContentStreamFactories").DashContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: import("../..").ContentType) => {
+        sourceBufferControllerFactory: (deps: import("../..").SourceBufferControllerImplDeps) => () => import("../..").SourceBufferControllerImpl;
+        bufferingController: (deps: import("../..").BufferingControllerImplDeps) => import("../..").BufferingControllerImpl;
+        segmentController: (deps: import("../..").SegmentControllerImplDeps) => import("../..").SegmentControllerImpl;
+        mediaSourceController: import("@amazon/vinyl-di").Factory<import("../../streaming/buffering/MediaSourceController").MediaSourceController>;
+        playbackController: import("@amazon/vinyl-di").Factory<PlaybackController>;
+        mediaTimelineTransformed: import("@amazon/vinyl-di").Factory<ObservableValue<Promise<import("../..").MediaTimeline>>>;
+        qualitySelector: import("@amazon/vinyl-di").Factory<import("../..").QualitySelector>;
+    });
+    contentStreamFactory: typeof createContentStreamFactory;
+    qualitySelector: (deps: {
+        options: ObservableValue<Pick<VinylOptions, "abr">>;
+    }) => QualitySelectorImpl;
+    manifestTransformed: typeof createDefaultDashManifestTransformer;
+    mediaTimeline: (deps: BuildDashMediaTimelineDeps & {
+        readonly manifestTransformed: ObservableValue<Promise<DashManifestData>>;
+    }) => ObservableValue<Promise<import("../..").MediaTimeline>>;
+    mediaTimelineTransformed: typeof createDefaultMediaTimelineTransformer;
+    options: import("@amazon/vinyl-di").Factory<ObservableValue<{
+        readonly abr: QualitySelectorImplOptions;
+        readonly preferredAudioLanguage: string | null;
+    }>>;
+    playbackController: import("@amazon/vinyl-di").Factory<PlaybackController>;
+    playbackSource: import("@amazon/vinyl-di").Factory<PlaybackSource>;
+    drmKeySystemResolver: import("@amazon/vinyl-di").Factory<DrmKeySystemResolver>;
+    requestInterceptor: import("@amazon/vinyl-di").Factory<RequestInterceptor>;
+    drmController: import("@amazon/vinyl-di").Factory<DrmController>;
+    capabilities: import("@amazon/vinyl-di").Factory<Capabilities>;
+};
+//# sourceMappingURL=createDashFactories.d.ts.map

package/dist/types/ts3.7/track/dash/createDashManifestProvider.d.ts

@@ -0,0 +1,12 @@
+import { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import { RequestInterceptor } from '@amazon/vinyl-util';
+/**
+ * Creates a DashManifestProvider which uses the manifestProvider set on the loadOptions, or a urlDashManifestProvider
+ * if unset, which will use the loadOptions.uri as the manifest location.
+ *
+ * @param loadOptions
+ */
+export declare function createDashManifestProvider(loadOptions: DashTrackLoadOptions): (deps: {
+    readonly requestInterceptor: RequestInterceptor;
+}) => import("./DashManifestProvider").DashManifestProvider;
+//# sourceMappingURL=createDashManifestProvider.d.ts.map