@amazon/vinyl 1.0.0

package/dist/types/ts4.1/playback/error/InvalidSeekError.d.ts

@@ -0,0 +1,17 @@
+import type { Json } from '@amazon/vinyl-util';
+import { ReportableError } from '@amazon/vinyl-util';
+import type { ReadonlyRanges } from '@amazon/vinyl-util';
+/**
+ * An error indicating a seek was out of range.
+ * This will have an error level of `ErrorLevel.WARN`.
+ * This indicates a bad seek request, but is recoverable.
+ */
+export declare class InvalidSeekError extends ReportableError {
+    readonly time: number;
+    readonly seekable: ReadonlyRanges;
+    readonly tolerance: number;
+    get [Symbol.toStringTag](): string;
+    constructor(time: number, seekable: ReadonlyRanges, tolerance: number);
+    toJSON(): Json;
+}
+//# sourceMappingURL=InvalidSeekError.d.ts.map

package/dist/types/ts4.1/playback/error/ReportableMediaError.d.ts

@@ -0,0 +1,17 @@
+import type { Json, Maybe } from '@amazon/vinyl-util';
+import { ReportableError } from '@amazon/vinyl-util';
+/**
+ * An error from the media element
+ */
+export declare class ReportableMediaError extends ReportableError {
+    static readonly MEDIA_ERR_ABORTED = 1;
+    static readonly MEDIA_ERR_NETWORK = 2;
+    static readonly MEDIA_ERR_DECODE = 3;
+    static readonly MEDIA_ERR_SRC_NOT_SUPPORTED = 4;
+    get [Symbol.toStringTag](): string;
+    readonly reason: string;
+    readonly code: number;
+    constructor(error: Maybe<MediaError>);
+    toJSON(): Json;
+}
+//# sourceMappingURL=ReportableMediaError.d.ts.map

package/dist/types/ts4.1/playback/logging/mediaErrorToJson.d.ts

@@ -0,0 +1,7 @@
+import type { Maybe } from '@amazon/vinyl-util';
+export declare function mediaErrorToJson(error: Maybe<MediaError>): {
+    readonly name: string;
+    readonly message: string;
+    readonly code: number;
+};
+//# sourceMappingURL=mediaErrorToJson.d.ts.map

package/dist/types/ts4.1/playback/logging/playbackStateLoggingHandler.d.ts

@@ -0,0 +1,15 @@
+import type { Disposable } from '@amazon/vinyl-util';
+import type { ReadonlyPlaybackController } from '../../playback/ReadonlyPlaybackController';
+/**
+ * The number of seconds to throttle timeupdate logs.
+ * Logs will not be emitted for timeupdate events less than this interval.
+ */
+export declare const TIMEUPDATE_THROTTLE = 5;
+/**
+ * Logs all playback state events.
+ *
+ * @param playbackState The event host with playback events to observe.
+ * @return Returns a disposable handle to remove all added handlers.
+ */
+export declare function playbackStateLoggingHandler(playbackState: ReadonlyPlaybackController): Disposable;
+//# sourceMappingURL=playbackStateLoggingHandler.d.ts.map

package/dist/types/ts4.1/playback/loudness/LoudnessNormalizationController.d.ts

@@ -0,0 +1,25 @@
+import type { AnyRecord, Clearable, EventHost } from '@amazon/vinyl-util';
+/**
+ * Event map for LoudnessNormalizationController.
+ */
+export interface LoudnessNormalizationControllerEventMap {
+    readonly change: AnyRecord;
+}
+/**
+ * Handles loudness normalization by applying gain adjustments
+ * based on track loudness metadata.
+ */
+export interface LoudnessNormalizationController extends EventHost<LoudnessNormalizationControllerEventMap>, Clearable {
+    /**
+     * Loudness gain adjustment value.
+     */
+    readonly gain: number;
+    /**
+     * Sets the current track's loudness level in LUFS, for the current track
+     * played.
+     *
+     * @param value
+     */
+    setTrackLoudness(value: number | null): void;
+}
+//# sourceMappingURL=LoudnessNormalizationController.d.ts.map

package/dist/types/ts4.1/playback/loudness/LoudnessNormalizationControllerImpl.d.ts

@@ -0,0 +1,41 @@
+import type { LogTarget } from '@amazon/vinyl-util';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import type { LoudnessNormalizationController, LoudnessNormalizationControllerEventMap } from './LoudnessNormalizationController';
+import type { LoudnessNormalizationControllerImplOptions } from './LoudnessNormalizationControllerImplOptions';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+export type LoudnessNormalizationControllerImplDeps = {
+    readonly options: ObservableValue<LoudnessNormalizationControllerImplOptions>;
+};
+/**
+ * Applies gain adjustment based on track loudness metadata from manifest.
+ * This controller normalizes audio loudness to a target level for consistent playback volume.
+ */
+export declare class LoudnessNormalizationControllerImpl extends EventHostImpl<LoudnessNormalizationControllerEventMap> implements LoudnessNormalizationController, LogTarget {
+    private readonly deps;
+    get [Symbol.toStringTag](): string;
+    readonly logPrefix: string;
+    private _gain;
+    private readonly disposer;
+    private trackLoudness;
+    private _options;
+    constructor(deps: LoudnessNormalizationControllerImplDeps);
+    get options(): Required<LoudnessNormalizationControllerImplOptions>;
+    setTrackLoudness(value: number | null): void;
+    get gain(): number;
+    /**
+     * Sets the loudness gain value for current track playback.
+     *
+     * @param value New gain value to apply
+     */
+    private set gain(value: number);
+    /**
+     * Update gain value based on current track loudness and target loudness.
+     */
+    private updateGain;
+    /**
+     * Resets the loudness gain Value to max gain value.
+     */
+    clear(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=LoudnessNormalizationControllerImpl.d.ts.map

package/dist/types/ts4.1/playback/loudness/LoudnessNormalizationControllerImplOptions.d.ts

@@ -0,0 +1,28 @@
+import type { ObjectSchema } from '@amazon/vinyl-validation';
+/**
+ * Options for configuring the loudness normalization controller.
+ */
+export interface LoudnessNormalizationControllerImplOptions {
+    /**
+     * If true, applies loudness Normalization to the current track played.
+     * Default: false
+     */
+    readonly enabled: boolean;
+    /**
+     * Target loudness level in LUFS (Loudness Units relative to Full Scale).
+     * Default: -14.0 dB
+     */
+    readonly targetLufs?: number;
+    /**
+     * Maximum gain reduction to apply in dB.
+     * Default: 10 Db
+     */
+    readonly maxGainDb?: number;
+}
+export declare const defaultLoudnessNormalizationControllerImplOptions: {
+    readonly enabled: false;
+    readonly targetLufs: -14;
+    readonly maxGainDb: 10;
+};
+export declare const loudnessNormalizationControllerImplOptionsValidator: ObjectSchema<LoudnessNormalizationControllerImplOptions>;
+//# sourceMappingURL=LoudnessNormalizationControllerImplOptions.d.ts.map

package/dist/types/ts4.1/playback/nextHasMetadata.d.ts

@@ -0,0 +1,4 @@
+import type { PlaybackControllerEventMap, ReadonlyPlaybackController } from '../playback/ReadonlyPlaybackController';
+import type { AnyRecord, NextEventAsPromiseOptions } from '@amazon/vinyl-util';
+export declare function nextHasMetadata(controller: ReadonlyPlaybackController, options?: NextEventAsPromiseOptions<PlaybackControllerEventMap, 'loadedMetadata'>): Promise<AnyRecord>;
+//# sourceMappingURL=nextHasMetadata.d.ts.map

package/dist/types/ts4.1/streaming/ContentStream.d.ts

@@ -0,0 +1,117 @@
+import type { Disposable, Maybe, ReadonlyEventHost, ReadonlyRanges } from '@amazon/vinyl-util';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import type { StreamingEventMap } from '../streaming/StreamingEventMap';
+import type { SegmentController } from '../streaming/SegmentController';
+import type { BufferingController } from '../streaming/buffering/BufferingController';
+import type { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import type { Factories } from '@amazon/vinyl-di';
+/**
+ * Creates a new ContentStream for the given content type.
+ */
+export type ContentStreamFactory = (contentType: ContentType) => ContentStream;
+export interface ContentStream extends ReadonlyEventHost<StreamingEventMap>, Disposable {
+    /**
+     * The content type for this stream.
+     * E.g. 'audio' or 'video'
+     */
+    readonly contentType: ContentType;
+    /**
+     * The prefetched time ranges.
+     */
+    readonly fetchedRanges: ReadonlyRanges;
+    /**
+     * The quality currently being requested.
+     */
+    readonly streamingQuality: MediaQualityMetadata | null;
+    /**
+     * The quality of the currently buffered media for this stream.
+     */
+    readonly bufferingQuality: MediaQualityMetadata | null;
+    /**
+     * The quality for the currently buffered media at currentTime for this stream.
+     */
+    readonly playbackQuality: MediaQualityMetadata | null;
+    /**
+     * The error, if in an error state.
+     */
+    readonly error: Error | null;
+    /**
+     * True if the last segment has been appended.
+     */
+    readonly bufferingEnded: boolean;
+    /**
+     * Starts prefetching with the given priority and prefetch start time.
+     * @param options
+     */
+    preload(options: ContentStreamPreloadOptions): void;
+    clearPrefetch(): void;
+    /**
+     * Resets the track to recover from error states.
+     * Resets both the segment controller and buffering controller to clear failed segments and error conditions.
+     */
+    reset(): void;
+    /**
+     * Activates the content stream, activating sub-controllers.
+     */
+    activate(options: ContentStreamActivateOptions): void;
+    /**
+     * Deactivates the content stream, deactivating sub-controllers.
+     */
+    deactivate(): void;
+}
+export interface ContentStreamPreloadOptions {
+    /**
+     * Track priority for prefetching.
+     * Higher values take precedence.
+     */
+    readonly prefetchPriority: number;
+    /**
+     * The media presentation time (in seconds) to begin prefetching.
+     */
+    readonly startTime?: Maybe<number>;
+}
+export interface ContentStreamActivateOptions {
+    /**
+     * The media presentation time (in seconds) to seek to.
+     */
+    readonly startTime?: Maybe<number>;
+}
+export interface ContentStreamImplDeps {
+    readonly bufferingController: BufferingController;
+    readonly segmentController: SegmentController;
+}
+export declare class ContentStreamImpl extends EventHostImpl<StreamingEventMap> implements ContentStream {
+    readonly contentType: ContentType;
+    private disposer;
+    private readonly segmentController;
+    private readonly bufferingController;
+    constructor(dependencyFactories: Factories<ContentStreamImplDeps>, contentType: ContentType);
+    preload(options: ContentStreamPreloadOptions): void;
+    get fetchedRanges(): ReadonlyRanges;
+    get streamingQuality(): (MediaQualityMetadata | null);
+    get bufferingQuality(): (MediaQualityMetadata | null);
+    get playbackQuality(): (MediaQualityMetadata | null);
+    get bufferingEnded(): boolean;
+    get error(): (Error | null);
+    /**
+     * Clears all fetched fragments and source buffers. Streaming will resume.
+     * 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.
+     */
+    clearPrefetch(): void;
+    /**
+     * Resets the track to recover from error states.
+     * Resets both the segment controller and buffering controller to clear failed segments and error conditions.
+     */
+    reset(): void;
+    activate(options: ContentStreamActivateOptions): void;
+    deactivate(): void;
+    dispose(): void;
+}
+/**
+ * The `Factory` to create a function which satisfies `ContentStreamFactory`.
+ */
+export declare function createContentStreamFactory(deps: {
+    readonly createContentStreamFactories: (contentType: ContentType) => Factories<ContentStreamImplDeps>;
+}): (contentType: ContentType) => ContentStreamImpl;
+//# sourceMappingURL=ContentStream.d.ts.map

package/dist/types/ts4.1/streaming/ContentStreamingOptions.d.ts

@@ -0,0 +1,13 @@
+import type { SegmentControllerImplOptions } from '../streaming/SegmentControllerImpl';
+import type { BufferingControllerImplOptions } from '../streaming/buffering/BufferingController';
+export interface ContentStreamingOptions {
+    /**
+     * Configuration for the segment controller.
+     */
+    readonly segmentController?: Partial<SegmentControllerImplOptions>;
+    /**
+     * Configuration for the buffering controller.
+     */
+    readonly buffering?: Partial<BufferingControllerImplOptions>;
+}
+//# sourceMappingURL=ContentStreamingOptions.d.ts.map

package/dist/types/ts4.1/streaming/ContentTypesValue.d.ts

@@ -0,0 +1,8 @@
+import type { ContentType } from './MediaQualityMetadata';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { ReadonlySet } from '@amazon/vinyl-util';
+/**
+ * Provides the content types to create streams for.
+ */
+export type ContentTypesValue = ObservableValue<Promise<ReadonlySet<ContentType>>>;
+//# sourceMappingURL=ContentTypesValue.d.ts.map

package/dist/types/ts4.1/streaming/DescriptorRecord.d.ts

@@ -0,0 +1,31 @@
+import type { ObjectSchema, RecordSchema } from '@amazon/vinyl-validation';
+import type { Maybe, ReadonlyRecord } from '@amazon/vinyl-util';
+import type { Uri } from '@amazon/vinyl-xml';
+/**
+ * A map of scheme URIs to a descriptor list.
+ */
+export type DescriptorRecord = ReadonlyRecord<Uri, readonly Descriptor[] | undefined>;
+/**
+ * A generic descriptor providing extended information.
+ */
+export interface Descriptor {
+    /**
+     * An optional unique identifier for the descriptor.
+     */
+    readonly id?: Maybe<string>;
+    /**
+     * An optional value associated with the descriptor, whose interpretation depends on the scheme.
+     */
+    readonly value?: Maybe<string>;
+}
+/**
+ * Gets The first matching descriptor value from a record with a matching URI and optional id.
+ *
+ * @param record The descriptor record.
+ * @param uri The URI key.
+ * @param id An optional id. If provided the descriptor must have a matching id.
+ */
+export declare function getDescriptorValue(record: DescriptorRecord, uri: Uri, id?: Maybe<string>): string | null;
+export declare const descriptorValidator: ObjectSchema<Descriptor>;
+export declare const descriptorRecordValidator: RecordSchema<DescriptorRecord>;
+//# sourceMappingURL=DescriptorRecord.d.ts.map

package/dist/types/ts4.1/streaming/DrmInitDataType.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Initialization data formats for EME.
+ * https://www.w3.org/TR/eme-initdata-registry/
+ */
+export type DrmInitDataType = 'cenc' | 'keyids' | 'webm' | string;
+//# sourceMappingURL=DrmInitDataType.d.ts.map

package/dist/types/ts4.1/streaming/ManifestController.d.ts

@@ -0,0 +1,13 @@
+import type { ObservableValue } from '@amazon/vinyl-observable';
+export interface ManifestController<T> extends ObservableValue<T> {
+    /**
+     * Manually triggers a reload of the manifest.
+     * A manifest reload will not clear currently fetched or buffered segments.
+     */
+    refresh(): void;
+    /**
+     * If the manifest promise has rejected, refresh.
+     */
+    reset(): void;
+}
+//# sourceMappingURL=ManifestController.d.ts.map

package/dist/types/ts4.1/streaming/MediaQualityMetadata.d.ts

@@ -0,0 +1,145 @@
+import type { Maybe, MutableDeep } from '@amazon/vinyl-util';
+import type { ObjectSchema } from '@amazon/vinyl-validation';
+import type { DescriptorRecord } from '../streaming/DescriptorRecord';
+import type { DrmInitDataType } from '../streaming/DrmInitDataType';
+import type { CencEncryptionScheme } from '../drm/CencEncryptionScheme';
+import { DrmKeySystem } from '../drm/DrmKeySystem';
+import type { FrameRate } from '@amazon/vinyl-mpd-parser';
+export type ContentType = 'audio' | 'video' | 'text';
+export declare const ALL_CONTENT_TYPES: [
+    "video",
+    "audio",
+    "text"
+];
+/**
+ * Contains media formatting and encryption metadata.
+ */
+export interface MediaFormatMetadata {
+    /**
+     * The content type of the representation, e.g. 'audio', 'video', 'text'
+     * Must be non-null for segmented media.
+     */
+    readonly contentType: ContentType | null;
+    /**
+     * The full MIME type of the media.
+     *
+     * Must be non-null for segmented media.
+     */
+    readonly mimeType: string | null;
+    /**
+     * The initialization data format.
+     */
+    readonly initDataType: DrmInitDataType | null;
+    /**
+     * The method of encryption, or null.
+     */
+    readonly encryptionScheme: CencEncryptionScheme | null;
+    /**
+     * Protection schemes used in this media.
+     */
+    readonly contentProtections: readonly DrmProtection[];
+}
+/**
+ * Protection information for a key system.
+ * Media may have more than one protection system.
+ */
+export interface DrmProtection {
+    /**
+     * The key system used in the encryption.
+     */
+    readonly keySystem: DrmKeySystem;
+    /**
+     * The initialization key, in base 64.
+     */
+    readonly pssh?: Maybe<string>;
+    /**
+     * PlayReady object.
+     */
+    readonly pro?: Maybe<string>;
+}
+export declare const drmProtectionValidator: ObjectSchema<DrmProtection>;
+export declare const mediaFormatMetadataValidator: ObjectSchema<MediaFormatMetadata>;
+/**
+ * Metadata representing attributes of a media representation.
+ */
+export interface MediaQualityMetadata extends MediaFormatMetadata {
+    /**
+     * Provides a decoding identifier. If this value changes from the previously buffered
+     * segment, the initialization segment must be buffered before appending the media segment.
+     * Unique to the track.
+     */
+    readonly decoderId: string;
+    /**
+     * The quality id identifies the quality representation.
+     * Unique to the track.
+     */
+    readonly qualityId: string;
+    /**
+     * Optional string specifying the codec(s) used for this representation. The format follows the RFC 6381 codec
+     * string format.
+     */
+    readonly codecs: string | null;
+    /**
+     * The average bandwidth in bits per second required for playing this representation.
+     * For HLS, and non-segmented media this will be null.
+     */
+    readonly bandwidth: number | null;
+    /**
+     * The peak bandwidth in bits per second required for playing this representation
+     * with its cumulative A/V content streams.
+     *
+     * Guaranteed to be set for segmented media.
+     */
+    readonly bandwidthTotal: number | null;
+    /**
+     * Audio sampling rate(s) in samples per second.
+     * An array of either one or two decimal integer values. If there are two elements this represents a minimum and
+     * maximum sampling rate of the audio media.
+     */
+    readonly audioSamplingRate: readonly number[] | null;
+    /**
+     * Frame rate for video representations, specified either as a ratio of integers, e.g. [30000, 1001]
+     */
+    readonly frameRate: FrameRate | null;
+    /**
+     * For video representations, the width of the video in pixels.
+     */
+    readonly width: number | null;
+    /**
+     * For video representations, the height of the video in pixels.
+     */
+    readonly height: number | null;
+    /**
+     * Information that may enhance playback or presentation.
+     */
+    readonly supplementalProperties: DescriptorRecord;
+    /**
+     * Specifies the language of the content, using a code as defined by RFC 5646.
+     */
+    readonly lang: string | null;
+    /**
+     * Identifies the group this quality belongs to (e.g. the adaptation set).
+     */
+    readonly groupId: string;
+    /**
+     * The group IDs that this quality is permitted to switch to during playback.
+     * Derived from the DASH `urn:mpeg:dash:adaptation-set-switching:2016` supplemental property.
+     * Includes the quality's own groupId.
+     * Null means no switching constraint (all groups are permitted).
+     * An array restricts switching to only the listed group IDs.
+     * Default behavior:
+     * - DASH: restricted to own group unless adaptation-set-switching property is present.
+     * - HLS: restricted to variants with the same base codec and language.
+     */
+    readonly switchingGroupIds: readonly string[] | null;
+}
+/**
+ * Creates a new, empty media format metadata object.
+ */
+export declare function createEmptyMediaFormatMetadata(): MutableDeep<MediaFormatMetadata>;
+/**
+ * Creates a new empty media quality metadata object.
+ */
+export declare function createEmptyMediaQualityMetadata(): MutableDeep<MediaQualityMetadata>;
+export declare const mediaQualityMetadataValidator: ObjectSchema<MediaQualityMetadata>;
+//# sourceMappingURL=MediaQualityMetadata.d.ts.map

package/dist/types/ts4.1/streaming/MediaTimeline.d.ts

@@ -0,0 +1,45 @@
+import type { SegmentReference } from '../streaming/SegmentReference';
+import type { SegmentDataProvider } from '../streaming/SegmentDataSlot';
+import type { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+/**
+ * Represents a single quality within a period, providing access to its metadata
+ * and segment data.
+ */
+export interface MediaQualityData {
+    readonly metadata: MediaQualityMetadata;
+    /**
+     * Gets the segment reference at the given time, or null if the time is outside the range.
+     * @param time The time, in seconds, relative to the presentation timeline.
+     * @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>;
+}
+/**
+ * Represents a period within the media timeline.
+ */
+export interface MediaPeriod {
+    readonly startTime: number;
+    readonly endTime: number;
+    readonly qualities: readonly MediaQualityData[];
+}
+/**
+ * Represents the full media timeline, composed of one or more periods.
+ */
+export interface MediaTimeline {
+    readonly periods: readonly MediaPeriod[];
+    /**
+     * The minimum duration of the buffer that a client should maintain for uninterrupted playback.
+     */
+    readonly minBufferTime: number;
+    /**
+     * The total duration of the media, in seconds.
+     * Returns null if duration cannot be determined.
+     */
+    getDuration?(): Promise<number | null>;
+}
+/**
+ * Gets the period spanning the given presentation time.
+ */
+export declare function getMediaPeriodAtTime(timeline: MediaTimeline, time: number): MediaPeriod | null;
+//# sourceMappingURL=MediaTimeline.d.ts.map

package/dist/types/ts4.1/streaming/SegmentController.d.ts

@@ -0,0 +1,117 @@
+import type { AnyRecord, Disposable, ReadonlyAbort, ReadonlyEventHost, ReadonlyRanges } from '@amazon/vinyl-util';
+import type { SegmentReference } from '../streaming/SegmentReference';
+import type { ChangeEvent } from '../event/ChangeEvent';
+import type { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+/**
+ * Forward-snap tolerance, in seconds, applied when looking up a segment by time.
+ *
+ * If the requested time falls within this window before a segment's `startTime`,
+ * that segment is returned rather than treating the gap as uncovered. This absorbs
+ * small alignment differences between qualities, where one quality's segment may
+ * begin a few milliseconds later than another's at the same logical boundary.
+ *
+ * Pass to `getSegmentAtTime` (and `MediaQualityData.getSegment`) as the `affordance`
+ * argument. Callers resuming streaming after a seek should also bias the requested
+ * time *behind* the playhead by at least this amount, so any subsequent appends
+ * cover the playhead without leaving a gap. The `SegmentController` clamps negative
+ * request times to `0`, so callers don't need to guard against the bias going below
+ * the start of the timeline.
+ */
+export declare const SEGMENT_START_AFFORDANCE = 0.2;
+export interface SegmentControllerEventMap {
+    /**
+     * fetchedRanges have been updated.
+     */
+    readonly fetchedRangesChange: AnyRecord;
+    /**
+     * Emitted when the timeline has changed.
+     */
+    readonly change: AnyRecord;
+    /**
+     * Dispatched when the current streaming quality changes.
+     * This is dispatched when a new quality is requested.
+     */
+    readonly streamingQualityChange: ChangeEvent<MediaQualityMetadata | null>;
+}
+/**
+ * The SegmentController provides segments to buffer for the given time.
+ * It is expected to prefetch segments based on the expectation of when the segments will be
+ * needed next.
+ */
+export interface ReadonlySegmentController extends ReadonlyEventHost<SegmentControllerEventMap> {
+    readonly error: Error | null;
+    /**
+     * The time ranges currently fetched.
+     */
+    readonly fetchedRanges: ReadonlyRanges;
+    /**
+     * The most recently requested quality metadata.
+     */
+    readonly streamingQuality: MediaQualityMetadata | null;
+    /**
+     * The duration of the media, in seconds.
+     * Returns null if duration cannot be determined.
+     */
+    getDuration(): Promise<number | null>;
+    /**
+     * Returns a Promise for a segment covering the given time, with quality chosen by
+     * the configured `QualitySelector`. Resolves to `null` if no media exists at that
+     * time. Negative `time` values are clamped to `0`.
+     *
+     * The lookup forward-snaps by `SEGMENT_START_AFFORDANCE`: if `time` falls within
+     * that window before a segment's `startTime`, that segment is returned. This
+     * absorbs sub-second segment-boundary differences across qualities so an ABR
+     * switch doesn't replay or skip media at the boundary.
+     *
+     * Calling this also blocks the prefetch queue until the returned promise settles,
+     * so the active request is prioritized over background prefetching.
+     *
+     * @param time The time, in seconds, the requested segment should span.
+     * @param abort Aborts the returned promise (rejecting with `AbortError`) and
+     * releases the prefetch-queue lock. The underlying network request may continue
+     * so its result can still populate the cache.
+     */
+    getSegment(time: number, abort?: ReadonlyAbort): Promise<SegmentReference<ArrayBuffer> | null>;
+}
+/**
+ * Configuration the track is expected to provide to the SegmentController.
+ */
+export interface PrefetchOptions {
+    /**
+     * The prefetching priority of the track. Higher numbers take precedence.
+     */
+    readonly trackPrefetchPriority: number;
+    /**
+     * When the track is inactive, the starting time to prefetch from.
+     */
+    readonly startTime: number;
+}
+/**
+ * Provides segments for a given time.
+ * Handles segment prefetching and caching.
+ */
+export interface SegmentController extends ReadonlySegmentController, Disposable {
+    /**
+     * Configures this segment provider.
+     */
+    configure(options: Partial<PrefetchOptions>): void;
+    /**
+     * Clears the cached segments.
+     * Currently pending segment promises will be rejected with an abort reason.
+     */
+    clear(): void;
+    /**
+     * Indicates that this segment provider is providing segments for an active track and should be prioritized
+     * accordingly.
+     */
+    activate(): void;
+    /**
+     * Indicates that this segment provider is providing segments for an inactive track.
+     */
+    deactivate(): void;
+    /**
+     * Resets failed segments to a pending state.
+     */
+    reset(): void;
+}
+//# sourceMappingURL=SegmentController.d.ts.map