@amazon/vinyl 1.0.0

package/dist/types/ts3.7/streaming/ContentStream.d.ts

@@ -0,0 +1,116 @@
+import { Disposable, EventHostImpl, Maybe, ReadonlyEventHost, ReadonlyRanges } from '@amazon/vinyl-util';
+import { StreamingEventMap } from '../streaming/StreamingEventMap';
+import { SegmentController } from '../streaming/SegmentController';
+import { BufferingController } from '../streaming/buffering/BufferingController';
+import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { 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/ts3.7/streaming/ContentStreamingOptions.d.ts

@@ -0,0 +1,13 @@
+import { SegmentControllerImplOptions } from '../streaming/SegmentControllerImpl';
+import { 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/ts3.7/streaming/ContentTypesValue.d.ts

@@ -0,0 +1,8 @@
+import { ContentType } from './MediaQualityMetadata';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { 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/ts3.7/streaming/DescriptorRecord.d.ts

@@ -0,0 +1,31 @@
+import { ObjectSchema, RecordSchema } from '@amazon/vinyl-validation';
+import { Maybe, ReadonlyRecord } from '@amazon/vinyl-util';
+import { 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/ts3.7/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/ts3.7/streaming/ManifestController.d.ts

@@ -0,0 +1,13 @@
+import { 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/ts3.7/streaming/MediaQualityMetadata.d.ts

@@ -0,0 +1,145 @@
+import { Maybe, MutableDeep } from '@amazon/vinyl-util';
+import { ObjectSchema } from '@amazon/vinyl-validation';
+import { DescriptorRecord } from '../streaming/DescriptorRecord';
+import { DrmInitDataType } from '../streaming/DrmInitDataType';
+import { CencEncryptionScheme } from '../drm/CencEncryptionScheme';
+import { DrmKeySystem } from '../drm/DrmKeySystem';
+import { 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/ts3.7/streaming/MediaTimeline.d.ts

@@ -0,0 +1,45 @@
+import { SegmentReference } from '../streaming/SegmentReference';
+import { SegmentDataProvider } from '../streaming/SegmentDataSlot';
+import { 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/ts3.7/streaming/SegmentController.d.ts

@@ -0,0 +1,117 @@
+import { AnyRecord, Disposable, ReadonlyAbort, ReadonlyEventHost, ReadonlyRanges } from '@amazon/vinyl-util';
+import { SegmentReference } from '../streaming/SegmentReference';
+import { ChangeEvent } from '../event/ChangeEvent';
+import { 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

package/dist/types/ts3.7/streaming/SegmentControllerImpl.d.ts

@@ -0,0 +1,167 @@
+import { EventHostImpl, ReadonlyAbort, ReadonlyRanges } from '@amazon/vinyl-util';
+import { ReadonlyPlaybackController } from '../playback/ReadonlyPlaybackController';
+import { PrefetchOptions, SegmentController, SegmentControllerEventMap } from '../streaming/SegmentController';
+import { SegmentReference } from '../streaming/SegmentReference';
+import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { MediaTimeline } from '../streaming/MediaTimeline';
+import { QualitySelector } from '../streaming/abr/QualitySelector';
+/**
+ * The interval to check if additional segments should be prefetched.
+ */
+export declare const PREFETCH_POLL_THROTTLE = 1;
+export interface SegmentControllerImplDeps {
+    readonly playbackController: ReadonlyPlaybackController;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+    readonly qualitySelector: QualitySelector;
+}
+export interface SegmentControllerImplOptions {
+    /**
+     * The amount of time ahead of the playhead to prefetch when the track is active.
+     * Default: 240
+     */
+    readonly prefetchActive: number;
+    /**
+     * The amount of time to prefetch when the track is not active.
+     * Default: 20
+     */
+    readonly prefetchInactive: number;
+    /**
+     * The number of seconds behind the playhead to retain segments.
+     * Default: 30
+     */
+    readonly retainTail: number;
+}
+export declare const defaultSegmentControllerBaseOptions: SegmentControllerImplOptions;
+/**
+ * Default SegmentController implementation.
+ * Provides segments for a given time.
+ * Handles segment prefetching and caching.
+ *
+ * Uses mediaTimelineTransformed to resolve segments directly from the MediaTimeline.
+ */
+export declare class SegmentControllerImpl extends EventHostImpl<SegmentControllerEventMap> implements SegmentController {
+    readonly deps: SegmentControllerImplDeps;
+    readonly contentType: ContentType;
+    get [Symbol.toStringTag](): string;
+    private _active;
+    get active(): boolean;
+    private readonly _fetchedRanges;
+    private _startTime;
+    /**
+     * A map of decoder id to init segment slots.
+     * This allows representations with seamless bitstream switching to share initialization segments without
+     * making unnecessary requests or decoder re-initializations.
+     */
+    private readonly cachedInitSegments;
+    private readonly cachedSegments;
+    private readonly disposer;
+    readonly options: SegmentControllerImplOptions;
+    private prefetchingPriority;
+    /**
+     * True if the last segment in the prefetch range has been cached.
+     */
+    private ended;
+    private prefetching;
+    private _error;
+    private timeUpdateSub;
+    private seekingSub;
+    private readonly abort;
+    /**
+     * Cached last period lookup for fast repeated access.
+     */
+    private _cachedPeriod;
+    constructor(deps: SegmentControllerImplDeps, contentType: ContentType, options?: Partial<SegmentControllerImplOptions>);
+    get error(): (Error | null);
+    getDuration(): Promise<number | null>;
+    /**
+     * Gets the period at the given time, using a cache for the last returned period.
+     */
+    private getPeriodAtTime;
+    /**
+     * Configures this segment provider and initiates prefetching.
+     * This may be called multiple times, for example when re-using a cached track a new track priority and start time
+     * can be provided.
+     */
+    configure(options: Partial<PrefetchOptions>): void;
+    get startTime(): number;
+    get trackPrefetchPriority(): number;
+    /**
+     * Returns the range that should be prefetched.
+     */
+    private get prefetchRange();
+    /**
+     * Returns the range that should be prefetched when inactive.
+     * This range will not be removed during sweeps unless `clear` is called.
+     */
+    private get prefetchRangeInactive();
+    /**
+     * Returns the range that should be prefetched while active.
+     */
+    private get prefetchRangeActive();
+    /**
+     * Clears data segments no longer within the current prefetch range.
+     * Init segments will not be changed.
+     */
+    private sweepCachedSegments;
+    /**
+     * Gets the next time to prefetch, or null if the prefetch range has been filled.
+     */
+    private getNextTimeToPrefetch;
+    private pollPrefetch;
+    private prefetchErrorHandler;
+    get fetchedRanges(): ReadonlyRanges;
+    get fetchedTime(): number;
+    private _streamingQuality;
+    get streamingQuality(): (MediaQualityMetadata | null);
+    private set streamingQuality(value: (MediaQualityMetadata | null));
+    getSegment(time: number, abort?: ReadonlyAbort): Promise<SegmentReference<ArrayBuffer> | null>;
+    private _getSegment;
+    /**
+     * Gets the minimum buffer time from the timeline.
+     * Falls back to a reasonable default.
+     */
+    private getMinBufferTime;
+    /**
+     * Prefetches the segment at the given time. Does not use the background scheduler.
+     *
+     * @param time
+     */
+    private prefetchImmediate;
+    /**
+     * Gets a streaming segment slot that spans the given time, or null if there is no media at that time.
+     * Slots will be cached until they slide out of the retention range or `clear` is called.
+     */
+    private getSlotAtTime;
+    /**
+     * Gets a cached init segment slot for the given decoder id. If a slot is not cached, create one.
+     */
+    private getOrCreateInitSlot;
+    /**
+     * Creates a slot that spans the given time, or returns null if there is no media at that time.
+     * Uses the mediaTimelineTransformed to resolve segments directly.
+     */
+    private createSlotForTime;
+    /**
+     * Indicates that this segment provider is providing segments for an active track and should be prioritized
+     * accordingly.
+     * Time ranges to be prefetched will change to the active prefetch window.
+     */
+    activate(): void;
+    /**
+     * Deactivates the segment provider.
+     * This clears cached segments not within the inactive prefetch range.
+     * Time ranges to be prefetched will change to the inactive prefetch window.
+     */
+    deactivate(): void;
+    clear(): void;
+    reset(): void;
+    /**
+     * Resets the slot if it's in an error state.
+     * @param slot
+     */
+    private resetSlot;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=SegmentControllerImpl.d.ts.map