@amazon/vinyl 1.0.0

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

@@ -0,0 +1,21 @@
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { DashManifestData } from '../../track/dash/DashManifestProvider';
+import { AdaptationSetType, RepresentationType } from '@amazon/vinyl-mpd-parser';
+import { 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/ts3.7/track/dash/createSegmentControllerFactory.d.ts

@@ -0,0 +1,19 @@
+import { ReadonlyPlaybackController } from '../../playback/ReadonlyPlaybackController';
+import { SegmentControllerImpl, SegmentControllerImplOptions } from '../../streaming/SegmentControllerImpl';
+import { ContentType } from '../../streaming/MediaQualityMetadata';
+import { SegmentController } from '../../streaming/SegmentController';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { MediaTimeline } from '../../streaming/MediaTimeline';
+import { 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/ts3.7/track/dash/manifestTransformUtils.d.ts

@@ -0,0 +1,30 @@
+import { AdaptationSetType, DashManifest, RepresentationType } from '@amazon/vinyl-mpd-parser';
+import { DashManifestData } from '../../track/dash/DashManifestProvider';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { 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/ts3.7/track/dash/timeline/DashRepresentationSegmentProvider.d.ts

@@ -0,0 +1,27 @@
+import { RepresentationType } from '@amazon/vinyl-mpd-parser';
+import { DashUriResolveDeps } from '../../../track/dash/util/uriResolution';
+import { CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+import { SegmentReference } from '../../../streaming/SegmentReference';
+import { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
+import { 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/ts3.7/track/dash/urlDashManifestProvider.d.ts

@@ -0,0 +1,17 @@
+import { Maybe } from '@amazon/vinyl-util';
+import { RequestInitOptions } from '@amazon/vinyl-util';
+import { RequestInterceptor } from '@amazon/vinyl-util';
+import { 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/ts3.7/track/dash/util/mimeType.d.ts

@@ -0,0 +1,12 @@
+import { RepresentationType } from '@amazon/vinyl-mpd-parser';
+import { 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/ts3.7/track/dash/util/mpd.d.ts

@@ -0,0 +1,80 @@
+import { 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/ts3.7/track/dash/util/uriResolution.d.ts

@@ -0,0 +1,88 @@
+import { BaseURLType, RepresentationType } from '@amazon/vinyl-mpd-parser';
+import { Uri } from '@amazon/vinyl-xml';
+import { 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/ts3.7/track/filters/keySystemFilter.d.ts

@@ -0,0 +1,10 @@
+import { MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import { 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/ts3.7/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/ts3.7/track/filters/resourceTypeFilter.d.ts

@@ -0,0 +1,10 @@
+import { Capabilities } from '../../client/Capabilities';
+import { 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/ts3.7/track/filters/sampleRateFilter.d.ts

@@ -0,0 +1,13 @@
+import { MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import { 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

package/dist/types/ts3.7/track/hls/HlsManifestController.d.ts

@@ -0,0 +1,25 @@
+import { ManifestController } from '../../streaming/ManifestController';
+import { HlsManifestData, HlsManifestProvider } from './HlsManifestProvider';
+export type HlsManifestController = ManifestController<Promise<HlsManifestData>>;
+export declare class HlsManifestControllerImpl implements HlsManifestController {
+    private readonly manifestProvider;
+    get [Symbol.toStringTag](): string;
+    get logPrefix(): string;
+    private readonly _data;
+    private _error;
+    private readonly abortSlot;
+    private readonly disposer;
+    constructor(manifestProvider: HlsManifestProvider);
+    get error(): (Error | null);
+    refresh(): void;
+    reset(): void;
+    get value(): Promise<HlsManifestData>;
+    get changeId(): number;
+    getValue(): Promise<HlsManifestData>;
+    onData(callback: (value: Promise<HlsManifestData>, previous?: Promise<HlsManifestData>) => void): () => void;
+    map<U>(fn: (value: Promise<HlsManifestData>) => U): import("@amazon/vinyl-observable").MutableValue<U>;
+    pick<K extends keyof NonNullable<Promise<HlsManifestData>>>(key: K): import("@amazon/vinyl-observable").MutableValue<Promise<HlsManifestData>[K]>;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=HlsManifestController.d.ts.map

package/dist/types/ts3.7/track/hls/HlsManifestProvider.d.ts

@@ -0,0 +1,21 @@
+import { ReadonlyAbort } from '@amazon/vinyl-util';
+import { MainPlaylist, MediaPlaylist } from '@amazon/vinyl-hls-parser';
+export type HlsManifestProvider = (abort?: ReadonlyAbort) => Promise<HlsManifestData>;
+export interface HlsManifestData {
+    /**
+     * The main HLS playlist manifest.
+     * Use getMediaPlaylist to resolve bitrate manifests.
+     */
+    readonly mainPlaylist: MainPlaylist;
+    /**
+     * 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;
+    /**
+     * Lazily fetches and caches a media playlist by variant URI.
+     */
+    readonly getMediaPlaylist: (uri: string) => Promise<MediaPlaylist>;
+}
+//# sourceMappingURL=HlsManifestProvider.d.ts.map

package/dist/types/ts3.7/track/hls/HlsMediaQualityMetadataResolver.d.ts

@@ -0,0 +1,5 @@
+import { AlternativeRendition, VariantStream } from '@amazon/vinyl-hls-parser';
+import { MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+export type HlsMediaQualityMetadataResolver = (variant: VariantStream, renditions: readonly AlternativeRendition[]) => MediaQualityMetadata;
+export declare function createDefaultHlsMediaQualityMetadataResolver(): HlsMediaQualityMetadataResolver;
+//# sourceMappingURL=HlsMediaQualityMetadataResolver.d.ts.map

package/dist/types/ts3.7/track/hls/HlsTrack.d.ts

@@ -0,0 +1,30 @@
+import { Maybe, RequestInitOptions } from '@amazon/vinyl-util';
+import { TrackLoadOptions, TrackFactory } from '../TrackFactory';
+import { TrackBaseOptions } from '../TrackBase';
+import { HlsManifestProvider } from './HlsManifestProvider';
+import { HlsManifestController } from './HlsManifestController';
+import { HlsManifestData } from './HlsManifestProvider';
+import { HlsMediaQualityMetadataResolver } from './HlsMediaQualityMetadataResolver';
+import { MseTrackDeps } from '../mse/MseTrack';
+import { Factories } from '@amazon/vinyl-di';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { MediaTimeline } from '../../streaming/MediaTimeline';
+export interface HlsTrackLoadOptions extends TrackLoadOptions {
+    readonly type: 'hls';
+    readonly manifestProvider?: Maybe<HlsManifestProvider>;
+    readonly requestInit?: Maybe<RequestInitOptions>;
+    readonly segmentRequestInit?: Maybe<RequestInitOptions>;
+    readonly config?: Maybe<TrackBaseOptions>;
+}
+export interface HlsTrackDeps extends MseTrackDeps {
+    readonly manifestController: HlsManifestController;
+    readonly manifestTransformed: ObservableValue<Promise<HlsManifestData>>;
+    readonly mediaQualityMetadataResolver: HlsMediaQualityMetadataResolver;
+    readonly mediaTimeline: ObservableValue<Promise<MediaTimeline>>;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+}
+export type HlsTrackFactoryDeps = {
+    readonly createHlsFactories: (loadOptions: HlsTrackLoadOptions) => Factories<HlsTrackDeps>;
+};
+export declare function createHlsTrackFactory(deps: HlsTrackFactoryDeps): TrackFactory<HlsTrackLoadOptions>;
+//# sourceMappingURL=HlsTrack.d.ts.map

package/dist/types/ts3.7/track/hls/buildHlsMediaTimeline.d.ts

@@ -0,0 +1,13 @@
+import { HlsManifestData } from '../../track/hls/HlsManifestProvider';
+import { HlsMediaQualityMetadataResolver } from '../../track/hls/HlsMediaQualityMetadataResolver';
+import { MediaTimeline } from '../../streaming/MediaTimeline';
+import { CreateSegmentDataProviderDeps } from '../../track/createSegmentDataProvider';
+export interface BuildHlsMediaTimelineDeps extends CreateSegmentDataProviderDeps {
+    readonly mediaQualityMetadataResolver: HlsMediaQualityMetadataResolver;
+}
+/**
+ * Builds a MediaTimeline from an HLS manifest.
+ * HLS has a single implicit period spanning the full duration.
+ */
+export declare function buildHlsMediaTimeline(deps: BuildHlsMediaTimelineDeps, data: HlsManifestData): MediaTimeline;
+//# sourceMappingURL=buildHlsMediaTimeline.d.ts.map

package/dist/types/ts3.7/track/hls/createDefaultHlsManifestTransformer.d.ts

@@ -0,0 +1,11 @@
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { HlsManifestData } from '../../track/hls/HlsManifestProvider';
+export interface HlsManifestTransformerDeps {
+    readonly manifestController: ObservableValue<Promise<HlsManifestData>>;
+}
+/**
+ * The default HLS manifest transformer sorts variants by bandwidth descending (highest quality first).
+ * Quality and language filtering is handled by the media timeline transformer.
+ */
+export declare function createDefaultHlsManifestTransformer(deps: HlsManifestTransformerDeps): ObservableValue<Promise<HlsManifestData>>;
+//# sourceMappingURL=createDefaultHlsManifestTransformer.d.ts.map

package/dist/types/ts3.7/track/hls/createHlsContentStreamFactories.d.ts

@@ -0,0 +1,27 @@
+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';
+export interface HlsContentStreamTrackDeps {
+    readonly mediaSourceController: MediaSourceController;
+    readonly playbackController: PlaybackController;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+    readonly qualitySelector: QualitySelector;
+}
+export declare function createHlsContentStreamFactories(options: Maybe<ContentStreamingOptions>): (deps: HlsContentStreamTrackDeps) => 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=createHlsContentStreamFactories.d.ts.map

package/dist/types/ts3.7/track/hls/createHlsContentTypesValue.d.ts

@@ -0,0 +1,15 @@
+import { ContentTypesValue } from '../../streaming/ContentTypesValue';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { HlsManifestData } from './HlsManifestProvider';
+export interface HlsContentTypesValueDeps {
+    readonly manifestTransformed: ObservableValue<Promise<HlsManifestData>>;
+}
+/**
+ * Creates an ObservableValue for the content types present in the HLS manifest.
+ *
+ * Per RFC 8216 §4.3.4.2, content types are determined from:
+ * 1. The CODECS attribute on EXT-X-STREAM-INF (variant streams)
+ * 2. The TYPE attribute on EXT-X-MEDIA (alternative renditions)
+ */
+export declare function createHlsContentTypesValue(deps: HlsContentTypesValueDeps): ContentTypesValue;
+//# sourceMappingURL=createHlsContentTypesValue.d.ts.map

package/dist/types/ts3.7/track/hls/createHlsFactories.d.ts

@@ -0,0 +1,73 @@
+import { HlsTrackLoadOptions } from './HlsTrack';
+import { Maybe, RequestInterceptor } from '@amazon/vinyl-util';
+import { createMediaSource } from '../../util/media/mediaSource';
+import { MediaSourceControllerImpl, MediaSourceControllerImplDeps } from '../../streaming/buffering/MediaSourceController';
+import { HlsManifestControllerImpl } from './HlsManifestController';
+import { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
+import { createHlsContentTypesValue } from './createHlsContentTypesValue';
+import { createContentStreamFactory } from '../../streaming/ContentStream';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { PlaybackController } from '../../playback/PlaybackController';
+import { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
+import { DrmController } from '../../drm/DrmController';
+import { Capabilities } from '../../client/Capabilities';
+import { PlaybackSource } from '../../playback/PlaybackSource';
+import { QualitySelectorImplOptions } from '../../streaming/abr/QualitySelectorImpl';
+import { QualitySelectorImpl } from '../../streaming/abr/QualitySelectorImpl';
+import { VinylOptions } from '../../vinyl/VinylOptions';
+import { createDefaultHlsManifestTransformer } from './createDefaultHlsManifestTransformer';
+import { BuildHlsMediaTimelineDeps } from './buildHlsMediaTimeline';
+import { createDefaultMediaTimelineTransformer } from '../../streaming/createDefaultMediaTimelineTransformer';
+import { HlsManifestData } from './HlsManifestProvider';
+export interface HlsFactoryDeps {
+    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 HlsInitOptions = {
+    readonly streaming?: Maybe<ContentStreamingOptions>;
+};
+export declare function createHlsFactories(options: Maybe<HlsInitOptions>): (deps: HlsFactoryDeps) => (loadOptions: HlsTrackLoadOptions) => {
+    contentTypesValue: typeof createHlsContentTypesValue;
+    manifestController: () => HlsManifestControllerImpl;
+    manifestTransformed: typeof createDefaultHlsManifestTransformer;
+    mediaQualityMetadataResolver: () => import("./HlsMediaQualityMetadataResolver").HlsMediaQualityMetadataResolver;
+    mediaSourceFactory: () => typeof createMediaSource;
+    mediaSourceController: (deps: MediaSourceControllerImplDeps) => MediaSourceControllerImpl;
+    segmentRequestInit: () => Maybe<Readonly<Omit<RequestInit, "signal">>>;
+    createContentStreamFactories: (deps: import("./createHlsContentStreamFactories").HlsContentStreamTrackDeps) => 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("../..").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;
+    mediaTimeline: (deps: BuildHlsMediaTimelineDeps & {
+        readonly manifestTransformed: ObservableValue<Promise<HlsManifestData>>;
+    }) => 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=createHlsFactories.d.ts.map

package/dist/types/ts3.7/track/hls/createUrlHlsManifestProvider.d.ts

@@ -0,0 +1,21 @@
+import { MainPlaylist, MediaPlaylist } from '@amazon/vinyl-hls-parser';
+import { Maybe, ReadonlyAbort, RequestInitOptions } from '@amazon/vinyl-util';
+import { HlsManifestProvider } from './HlsManifestProvider';
+export declare function createUrlHlsManifestProvider(url: string, requestInit?: RequestInitOptions): HlsManifestProvider;
+export interface FetchMediaPlaylistOptions {
+    /** The variant URI to resolve against the base URL. */
+    readonly uri: string;
+    /** The base URL for resolving relative URIs. */
+    readonly baseUrl: string;
+    /** Variable definitions from the main playlist. */
+    readonly defines: MainPlaylist['defines'];
+    /** Optional request configuration. */
+    readonly requestInit?: Maybe<RequestInitOptions>;
+    /** Optional abort signal. */
+    readonly abort?: Maybe<ReadonlyAbort>;
+}
+/**
+ * Fetches and parses an HLS media playlist from a variant URI.
+ */
+export declare function fetchMediaPlaylist(options: FetchMediaPlaylistOptions): Promise<MediaPlaylist>;
+//# sourceMappingURL=createUrlHlsManifestProvider.d.ts.map

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

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