@amazon/vinyl 1.0.0

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

@@ -0,0 +1,43 @@
+import type { ContentProtection, PeriodType, RepresentationType } from '@amazon/vinyl-mpd-parser';
+import type { ContentType, DrmProtection, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import type { 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/ts4.1/track/dash/DashTrack.d.ts

@@ -0,0 +1,46 @@
+import type { TrackBaseOptions } from '../../track/TrackBase';
+import type { DashManifestProvider, DashManifestData } from './DashManifestProvider';
+import type { DashManifestController } from './DashManifestController';
+import type { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { Maybe, RequestInitOptions } from '@amazon/vinyl-util';
+import type { Factories } from '@amazon/vinyl-di';
+import type { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
+import type { MseTrackDeps } from '../../track/mse/MseTrack';
+import type { 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/ts4.1/track/dash/buildDashMediaTimeline.d.ts

@@ -0,0 +1,9 @@
+import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { MediaTimeline } from '../../streaming/MediaTimeline';
+import type { 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/ts4.1/track/dash/createDashContentStreamFactories.d.ts

@@ -0,0 +1,36 @@
+import type { MediaSourceController } from '../../streaming/buffering/MediaSourceController';
+import type { PlaybackController } from '../../playback/PlaybackController';
+import type { QualitySelector } from '../../streaming/abr/QualitySelector';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { ContentType } from '../../streaming/MediaQualityMetadata';
+import type { SourceBufferControllerImplDeps } from '../../streaming/buffering/SourceBufferController';
+import { SourceBufferControllerImpl } from '../../streaming/buffering/SourceBufferController';
+import type { BufferingControllerImplDeps } from '../../streaming/buffering/BufferingController';
+import { BufferingControllerImpl } from '../../streaming/buffering/BufferingController';
+import type { SegmentControllerImplDeps } from '../../streaming/SegmentControllerImpl';
+import { SegmentControllerImpl } from '../../streaming/SegmentControllerImpl';
+import type { Maybe } from '@amazon/vinyl-util';
+import type { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
+import type { 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/ts4.1/track/dash/createDashContentTypesValue.d.ts

@@ -0,0 +1,14 @@
+import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
+import type { ContentTypesValue } from '../../streaming/ContentTypesValue';
+import type { 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/ts4.1/track/dash/createDashFactories.d.ts

@@ -0,0 +1,86 @@
+import type { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import type { Maybe, RequestInterceptor } from '@amazon/vinyl-util';
+import { createDefaultDashManifestTransformer } from '../../track/dash/createDefaultDashManifestTransformer';
+import { createMediaSource } from '../../util/media/mediaSource';
+import type { DashMediaQualityMetadataResolverDeps } from '../../track/dash/DashMediaQualityMetadataResolver';
+import type { MediaSourceControllerImplDeps } from '../../streaming/buffering/MediaSourceController';
+import { MediaSourceControllerImpl } from '../../streaming/buffering/MediaSourceController';
+import type { PlaybackController } from '../../playback/PlaybackController';
+import type { DashManifestController, DashManifestControllerImplDeps } from '../../track/dash/DashManifestController';
+import type { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
+import type { DrmController } from '../../drm/DrmController';
+import type { Capabilities } from '../../client/Capabilities';
+import type { QualitySelectorImplOptions } from '../../streaming/abr/QualitySelectorImpl';
+import { QualitySelectorImpl } from '../../streaming/abr/QualitySelectorImpl';
+import type { PlaybackSource } from '../../playback/PlaybackSource';
+import { createContentStreamFactory } from '../../streaming/ContentStream';
+import type { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
+import { createDashContentTypesValue } from '../../track/dash/createDashContentTypesValue';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { VinylOptions } from '../../vinyl/VinylOptions';
+import type { BuildDashMediaTimelineDeps } from '../../track/dash/buildDashMediaTimeline';
+import { createDefaultMediaTimelineTransformer } from '../../streaming/createDefaultMediaTimelineTransformer';
+import type { 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/ts4.1/track/dash/createDashManifestProvider.d.ts

@@ -0,0 +1,12 @@
+import type { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import type { 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

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

@@ -0,0 +1,21 @@
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { AdaptationSetType, RepresentationType } from '@amazon/vinyl-mpd-parser';
+import type { Comparator } from '@amazon/vinyl-util';
+export interface DashManifestTransformerDeps {
+    readonly manifestController: ObservableValue<Promise<DashManifestData>>;
+}
+/**
+ * The default dash manifest transformer sorts adaptation sets and representations.
+ * Quality filtering is handled by the media timeline transformer.
+ */
+export declare function createDefaultDashManifestTransformer(deps: DashManifestTransformerDeps): ObservableValue<Promise<DashManifestData>>;
+/**
+ * The default adaptation set comparator orders by descending selectionPriority.
+ */
+export declare function createDefaultAdaptationSetComparator(): Comparator<AdaptationSetType>;
+/**
+ * The default representation comparator orders by ascending quality ranking and descending bandwidth.
+ */
+export declare function createDefaultRepresentationComparator(): Comparator<RepresentationType>;
+//# sourceMappingURL=createDefaultDashManifestTransformer.d.ts.map

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

@@ -0,0 +1,20 @@
+import type { ReadonlyPlaybackController } from '../../playback/ReadonlyPlaybackController';
+import type { SegmentControllerImplOptions } from '../../streaming/SegmentControllerImpl';
+import { SegmentControllerImpl } from '../../streaming/SegmentControllerImpl';
+import type { ContentType } from '../../streaming/MediaQualityMetadata';
+import type { SegmentController } from '../../streaming/SegmentController';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { MediaTimeline } from '../../streaming/MediaTimeline';
+import type { QualitySelector } from '../../streaming/abr/QualitySelector';
+export type SegmentControllerFactory = (deps: {
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+    readonly qualitySelector: QualitySelector;
+}) => SegmentController;
+export interface SegmentControllerFactoryDeps {
+    readonly playbackController: ReadonlyPlaybackController;
+}
+export declare function createSegmentControllerFactory(playerDeps: SegmentControllerFactoryDeps, contentType: ContentType, options?: Partial<SegmentControllerImplOptions>): (trackDeps: {
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+    readonly qualitySelector: QualitySelector;
+}) => SegmentControllerImpl;
+//# sourceMappingURL=createSegmentControllerFactory.d.ts.map

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

@@ -0,0 +1,30 @@
+import type { AdaptationSetType, DashManifest, RepresentationType } from '@amazon/vinyl-mpd-parser';
+import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { Comparator, FilterPredicate, MaybePromise } from '@amazon/vinyl-util';
+/**
+ * Returns true if the given Dash manifest has unfiltered representations in every Period.
+ */
+export declare function manifestIsPlayable(manifest: DashManifest): boolean;
+/**
+ * Filters dash representations using a synchronous predicate.
+ */
+export declare function filterDashRepresentations(filter: FilterPredicate<RepresentationType>, throwError: () => never, manifest: DashManifest): DashManifest;
+/**
+ * Filters dash adaptation sets using a synchronous predicate.
+ */
+export declare function filterDashAdaptationSets(filter: FilterPredicate<AdaptationSetType>, throwError: () => never, manifest: DashManifest): DashManifest;
+/**
+ * Sorts dash adaptation sets using a comparator.
+ */
+export declare function sortDashAdaptationSets(comparator: Comparator<AdaptationSetType>, manifest: DashManifest): DashManifest;
+/**
+ * Sorts dash representations using a comparator.
+ */
+export declare function sortDashRepresentations(comparator: Comparator<RepresentationType>, manifest: DashManifest): DashManifest;
+/**
+ * Maps a manifest transformation function over a DashManifestData observable.
+ * Handles the boilerplate of extracting manifest/baseUrl and reconstructing the result.
+ */
+export declare function mapManifestTransform(manifestController: ObservableValue<Promise<DashManifestData>>, transformManifest: (manifest: DashManifest) => MaybePromise<DashManifest>): ObservableValue<Promise<DashManifestData>>;
+//# sourceMappingURL=manifestTransformUtils.d.ts.map

package/dist/types/ts4.1/track/dash/timeline/DashRepresentationSegmentProvider.d.ts

@@ -0,0 +1,27 @@
+import type { RepresentationType } from '@amazon/vinyl-mpd-parser';
+import type { DashUriResolveDeps } from '../../../track/dash/util/uriResolution';
+import type { CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+import type { SegmentReference } from '../../../streaming/SegmentReference';
+import type { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
+import type { DashMediaQualityMetadataResolver } from '../../../track/dash/DashMediaQualityMetadataResolver';
+export interface DashSegmentProviderDeps extends DashUriResolveDeps, CreateSegmentDataProviderDeps {
+    /**
+     * Produces abstract metadata from a dash representation.
+     */
+    readonly mediaQualityMetadataResolver: DashMediaQualityMetadataResolver;
+}
+export interface DashRepresentationSegmentProvider {
+    /**
+     * Gets a segment reference within this representation for the given time, in seconds, relative to the period.
+     *
+     * @param time
+     * @param affordance Forward-snap tolerance in seconds: if `time` falls just before a
+     * segment's start (within `affordance`), that segment is returned. Defaults to `0`.
+     */
+    getSegment(time: number, affordance?: number): Promise<SegmentReference<SegmentDataProvider> | null>;
+}
+/**
+ * Creates a representation timeline for the given representation.
+ */
+export declare function createDashRepresentationSegmentProvider(deps: DashSegmentProviderDeps, baseUrl: string, representation: RepresentationType): DashRepresentationSegmentProvider;
+//# sourceMappingURL=DashRepresentationSegmentProvider.d.ts.map

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

@@ -0,0 +1,17 @@
+import type { Maybe } from '@amazon/vinyl-util';
+import type { RequestInitOptions } from '@amazon/vinyl-util';
+import type { RequestInterceptor } from '@amazon/vinyl-util';
+import type { DashManifestProvider } from '../../track/dash/DashManifestProvider';
+/**
+ * Creates a DashManifestProvider which performs a request to retrieve a dash manifest.
+ * Can be a relative path.
+ *
+ * Usage example:
+ *
+ * ```createRequesterDashManifestProvider('https://example.com/manifest.mpd')```
+ * @param input The resource location of the dash manifest.
+ * @param init Optional request options such as headers.
+ * @param requestInterceptor An optional transformer to mutate request parameters before the request is made.
+ */
+export declare function urlDashManifestProvider(input: string, init?: Maybe<RequestInitOptions>, requestInterceptor?: RequestInterceptor): DashManifestProvider;
+//# sourceMappingURL=urlDashManifestProvider.d.ts.map

package/dist/types/ts4.1/track/dash/util/mimeType.d.ts

@@ -0,0 +1,12 @@
+import type { RepresentationType } from '@amazon/vinyl-mpd-parser';
+import type { ContentType } from '../../../streaming/MediaQualityMetadata';
+export interface RepresentationMimeInfo {
+    readonly mimeType: string | null;
+    readonly contentType: ContentType | null;
+}
+/**
+ * Returns the full mime type with codecs and the inferred content type from the
+ * provided representation.
+ */
+export declare function getRepresentationMimeInfo(representation: RepresentationType): RepresentationMimeInfo;
+//# sourceMappingURL=mimeType.d.ts.map

package/dist/types/ts4.1/track/dash/util/mpd.d.ts

@@ -0,0 +1,80 @@
+import type { AdaptationSetType, DashManifest, MPDtype, PeriodType, RepresentationType, SegmentBaseType, SegmentListType, SegmentTemplateType } from '@amazon/vinyl-mpd-parser';
+/**
+ * Calculates the inherited SegmentList for the given representation. Or returns undefined if no SegmentList is
+ * present in the hierarchy.
+ */
+export declare function getSegmentList(representation: RepresentationType): SegmentListType | undefined;
+/**
+ * Calculates the inherited SegmentTemplate for the given representation. Or returns undefined if no SegmentTemplate is
+ * present in the hierarchy.
+ */
+export declare function getSegmentTemplate(representation: RepresentationType): SegmentTemplateType | undefined;
+/**
+ * Calculates the inherited SegmentBase for the given representation. Or returns undefined if no SegmentBase is
+ * present in the hierarchy.
+ */
+export declare function getSegmentBase(representation: RepresentationType): SegmentBaseType | undefined;
+/**
+ * Returns the representation's ancestry: [MPD, Period, AdaptationSet, Representation]
+ */
+export declare function getRepresentationAncestry(representation: RepresentationType): readonly [
+    MPDtype,
+    PeriodType,
+    AdaptationSetType,
+    RepresentationType
+];
+export type PeriodRange = readonly [
+    number,
+    number | null
+];
+/**
+ * Calculates the period start and end time.
+ */
+export declare function calculatePeriodTimeRange(period: PeriodType): PeriodRange;
+/**
+ * Calculates the start time of the given period.
+ *
+ * In a static presentation, the first period SHALL start at the zero point of the MPD timeline (with a
+ * Period@start value of 0 seconds).
+ */
+export declare function calculatePeriodStart(period: PeriodType): number;
+/**
+ * In a static presentation, the last period SHALL have a Period@duration.
+ *
+ * In a dynamic presentation, the first period SHALL start at or after the zero point of the MPD timeline (with a
+ *  Period@start value of 0 seconds or greater).
+ *
+ * In a dynamic presentation, the last period MAY have a Period@duration, in which case it has a fixed duration. If
+ * without Period@duration, the last period in a dynamic presentation has an unlimited duration (that may later be
+ * shortened by an MPD update).
+ */
+export declare function calculatePeriodEnd(period: PeriodType): number | null;
+/**
+ * Converts a sample time to an MPD-relative time.
+ *
+ * The samples within a representation exist on a linear sample timeline defined by the encoder. This function maps
+ * those sample times onto the MPD timeline.
+ *
+ * https://dashif-documents.azurewebsites.net/Guidelines-TimingModel/master/Guidelines-TimingModel.html
+ *
+ * @param sampleTime The sample start time, in timescale units, relative to the media.
+ * @param periodStart The presentation start time of the period, relative to the MPD timeline.
+ * @param presentationTimeOffset Specifies a presentation time offset in the media timeline relative to the start
+ * of the Period, in timescale units, used to adjust the timing of media presentation.
+ * @param timescale The timescale, in units per second.
+ */
+export declare function sampleToMpdTime(sampleTime: number, periodStart: number, presentationTimeOffset: number, timescale: number): number;
+/**
+ * Gets the period spanning the given presentation time.
+ */
+export declare function getPeriodAtTime(manifest: DashManifest, time: number): PeriodType | null;
+/**
+ * Flattens representations across all adaptation sets for the given Period.
+ */
+export declare function flattenRepresentations(period: PeriodType): RepresentationType[];
+/**
+ * Calculates the manifest duration, either from the mediaPresentationDuration or the last period end time.
+ * @param manifest
+ */
+export declare function calculateDuration(manifest: DashManifest): number | null;
+//# sourceMappingURL=mpd.d.ts.map

package/dist/types/ts4.1/track/dash/util/uriResolution.d.ts

@@ -0,0 +1,88 @@
+import type { BaseURLType, RepresentationType } from '@amazon/vinyl-mpd-parser';
+import type { Uri } from '@amazon/vinyl-xml';
+import type { Maybe } from '@amazon/vinyl-util';
+/**
+ * Selects a base URL alternate.
+ */
+export interface BaseUrlSelector {
+    /**
+     * Given a list of Dash base URLs, chooses which one will be used.
+     *
+     * @param baseUrls A list of Dash base URL objects for a single scope.
+     * Guaranteed to not be empty.
+     */
+    selectBaseUrl(baseUrls: readonly BaseURLType[]): BaseURLType;
+}
+export declare const pickFirstBaseUrlSelector: BaseUrlSelector;
+export interface DashUriResolveDeps {
+    /**
+     * Selects the BaseURL from provided alternates.
+     */
+    readonly baseUrlSelector: BaseUrlSelector;
+}
+export interface ResolvedDashUri {
+    /**
+     * The absolute URL.
+     */
+    readonly url: string;
+    /**
+     * The service location.
+     * @see BaseURL.serviceLocation
+     */
+    readonly serviceLocation: string | null;
+}
+export interface DashUriResolveOptions {
+    /**
+     * The URI to resolve.
+     */
+    readonly uri?: Maybe<Uri>;
+    /**
+     * The representation to use as the scope for BaseURL resolution.
+     */
+    readonly representation: RepresentationType;
+    /**
+     * The resource location of the manifest.
+     */
+    readonly baseUrl: string;
+}
+/**
+ * Resolves the base URL. Walks down the ancestry, concatenating BaseURL paths according to
+ * MPEG-DASH ISO/IEC 23009-1 standard, section 5.6.4.
+ *
+ * The BaseURL elements are used to define the base URL against which relative URLs specified in the manifest are
+ * resolved. This can occur at multiple levels within the manifest (e.g., at the Period, Adaptation Set, or
+ * Representation level).
+ * Relative URLs are resolved according to standard URL resolution rules, as defined by RFC 3986. This involves
+ * resolving the relative URL against the effective base URL, which could be the URL of the manifest itself or
+ * a <BaseURL> specified at a higher level in the manifest hierarchy.
+ *
+ * Manifest URL as Base: If no <BaseURL> is specified, the URL from which the DASH manifest (MPD file) was
+ * retrieved acts as the base URL for resolving any relative URLs.
+ *
+ * https://standards.iso.org/ittf/PubliclyAvailableStandards/index.html
+ *
+ * Note: URL resolution is not a simple concatenation, the `URL` class is used to resolve relative URLs per RFC
+ * 3986:2005.
+ *
+ * @return Returns a resolved BaseURL object with calculated values according to inheritance rules.
+ */
+export declare function resolveDashUri(deps: DashUriResolveDeps, options: DashUriResolveOptions): ResolvedDashUri;
+export interface SegmentTemplateUriOptions {
+    /**
+     * The sequence number of the segment. Will replace `$Number$` in url templates.
+     */
+    readonly segmentNumber?: Maybe<number>;
+    /**
+     * The sample time of the segment. Will replace `$Time$` in url templates.
+     */
+    readonly sampleTime?: Maybe<number>;
+    /**
+     * The representation, will use the id and bandwidth for replacement tokens.
+     */
+    readonly representation: RepresentationType;
+}
+/**
+ * Creates a segment url using segment template tokens, as defined in 5.3.9.4.4.
+ */
+export declare function segmentTemplateUrl(uri: Uri, options: SegmentTemplateUriOptions): Uri;
+//# sourceMappingURL=uriResolution.d.ts.map

package/dist/types/ts4.1/track/filters/keySystemFilter.d.ts

@@ -0,0 +1,10 @@
+import type { MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import type { DrmController } from '../../drm/DrmController';
+export declare function throwKeySystemsUnsupported(): never;
+/**
+ * Returns true when the media's key system is supported or the representation has no content protection.
+ */
+export declare function canPlayKeySystem(deps: {
+    readonly drmController: DrmController;
+}, metadata: MediaQualityMetadata): Promise<boolean>;
+//# sourceMappingURL=keySystemFilter.d.ts.map

package/dist/types/ts4.1/track/filters/languageFilter.d.ts

@@ -0,0 +1,29 @@
+export declare function throwLanguagesUnsupported(): never;
+/**
+ * Normalizes a BCP 47 / RFC 5646 language tag.
+ *
+ * - Converts ISO 639-2 (3-letter) codes to ISO 639-1 (2-letter)
+ * - Forces language to lowercase, region to uppercase
+ * - Discards script/dialect subtags beyond language-REGION
+ *
+ * Examples: `eng` → `en`, `en-us` → `en-US`, `fra-CA` → `fr-CA`
+ */
+export declare function normalizeLanguage(locale: string): string;
+/**
+ * Computes a relatedness score between two language codes.
+ * Higher is better. 0 means unrelated.
+ *
+ * - 4: exact match after normalization (e.g. `en-US` vs `en-US`)
+ * - 3: candidate is parent of target (e.g. `en` vs `en-US`)
+ * - 2: candidate is sibling of target (e.g. `en-CA` vs `en-US`)
+ * - 1: candidate is child of target (e.g. `en-US` vs `en`)
+ * - 0: unrelated
+ */
+export declare function languageRelatedness(target: string, candidate: string): number;
+/**
+ * Finds the best language match from a set of available languages.
+ * Returns the best matching language, or undefined if the set is empty.
+ * When no language is related, the first available language is returned.
+ */
+export declare function findBestLanguageMatch(target: string, available: ArrayLike<string>): string | undefined;
+//# sourceMappingURL=languageFilter.d.ts.map

package/dist/types/ts4.1/track/filters/resourceTypeFilter.d.ts

@@ -0,0 +1,10 @@
+import type { Capabilities } from '../../client/Capabilities';
+import type { MediaFormatMetadata } from '../../streaming/MediaQualityMetadata';
+export declare function throwMimeTypesUnsupported(): never;
+/**
+ * Returns true when the media's codec and container is supported.
+ */
+export declare function canPlayMimeType(deps: {
+    readonly capabilities: Capabilities;
+}, metadata: MediaFormatMetadata): boolean;
+//# sourceMappingURL=resourceTypeFilter.d.ts.map

package/dist/types/ts4.1/track/filters/sampleRateFilter.d.ts

@@ -0,0 +1,13 @@
+import type { MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import type { Capabilities } from '../../client/Capabilities';
+export declare function throwSamplingRatesUnsupported(): never;
+/**
+ * Returns true when the media's sampling rate is supported.
+ * If Firefox (which does not support >48kHz), filter out all sampling rates above the supported sampling rate.
+ * All other browsers filter out all sampling rates above the supported sampling rate unless this will filter all
+ * and then do not filter the lowest sampling rate.
+ */
+export declare function supportsAudioSamplingRate(deps: {
+    readonly capabilities: Capabilities;
+}, metadata: MediaQualityMetadata, _index: number, array: ArrayLike<MediaQualityMetadata>): boolean;
+//# sourceMappingURL=sampleRateFilter.d.ts.map