rx-player 4.0.0-dev.2023121900 → 4.0.0-dev.2024022100

package/dist/commonjs/multithread_types.d.ts

@@ -0,0 +1,815 @@
+/**
+ * This file regroups TypeScript types and enums only needed when running the
+ * RxPlayer in a
+ * multithread situation.
+ */
+import type { IResolutionInfo, IManifestFetcherSettings, ISegmentFetcherCreatorBackoffOptions, IInbandEvent, IPausedPlaybackObservation, IRepresentationsChoice, ITrackSwitchingMode } from "./core/types";
+import type { ISerializedMediaError, ISerializedNetworkError, ISerializedEncryptedMediaError, ISerializedOtherError } from "./errors";
+import type { ISerializedSourceBufferError } from "./errors/source_buffer_error";
+import type { IContentProtection, ITextDisplayerData } from "./main_thread/types";
+import type { IManifestMetadata, IPeriodsUpdateResult } from "./manifest";
+import type { ISourceBufferInterfaceAppendBufferParameters, SourceBufferType } from "./mse";
+import type { IFreezingStatus, IRebufferingStatus } from "./playback_observer";
+import type { ITrackType } from "./public_types";
+import type { ITransportOptions } from "./transports";
+import type { ILoggerLevel } from "./utils/logger";
+import type { IRange } from "./utils/ranges";
+/**
+ * First message sent by the main thread to the WebWorker.
+ * A WebWorker should only receive one `IInitMessage` at most and it should be
+ * always the first message received.
+ *
+ * Allows for WebWorker initialization.
+ */
+export interface IInitMessage {
+    type: MainThreadMessageType.Init;
+    value: {
+        /** Link to the DASH_WASM's feature WebAssembly file to parse DASH MPDs. */
+        dashWasmUrl: string;
+        /**
+         * If `true` the final element on the current page displaying the content
+         * can display video content.
+         *
+         * If `false`, it cannot, but it can be assumed to be able to play audio
+         * content.
+         * An example where it would be set to `false` is for `HTMLAudioElement`
+         * elements (`<audio>` tags).
+         */
+        hasVideo: boolean;
+        /**
+         * If `true` the current platform exposes Media Source extensions (MSE) API
+         * in a WebWorker environment.
+         *
+         * If `false`, every MSE API has to be called on the main thread, usually
+         * by messages posted by the WebWorker.
+         */
+        hasMseInWorker: boolean;
+        /** Initial logging level that should be set. */
+        logLevel: ILoggerLevel;
+        sendBackLogs: boolean;
+        /**
+         * Value of `Date.now()` at the time the `timestamp` property was generated.
+         *
+         * This is mostly useful for timestamp synchronization: by calling both
+         * `performance.now` (the same call on the main thread made to calculate
+         * `timestamp` - but which is not synchronized initially to the WebWorker's)
+         * and `Date.now()` both on the main thread and on the WebWorker,
+         * calculating the difference between the two and comparing both the main
+         * thread's difference and the WebWorker's difference, you're able to
+         * produce a relatively-synchronized timestamp between the two.
+         */
+        date: number;
+        /**
+         * Value returned by `performance.now()` at the same time `date` was
+         * calculated.
+         *
+         * Allows for timestamp synchronization.
+         * @see date property.
+         */
+        timestamp: number;
+    };
+}
+/** Options needed when initializing a new content. */
+export interface IContentInitializationData {
+    /**
+     * Identifier uniquely identifying a specific content.
+     *
+     * Protects against all kind of race conditions or asynchronous issues.
+     */
+    contentId: string;
+    /**
+     * URL at which the content's Manifest is accessible.
+     * `undefined` if unknown.
+     */
+    url?: string | undefined;
+    /** If `true`, text buffer (e.g. for subtitles) is enabled. */
+    hasText: boolean;
+    /**
+     * Options relative to the streaming protocol.
+     *
+     * Options not yet supported in a WebWorker environment are omitted.
+     */
+    transportOptions: Omit<ITransportOptions, "manifestLoader" | "segmentLoader" | "representationFilter"> & {
+        manifestLoader: undefined;
+        segmentLoader: undefined;
+        representationFilter: string | undefined;
+    };
+    /** Initial video bitrate on which the adaptive logic will base itself. */
+    initialVideoBitrate?: number | undefined;
+    /** Initial audio bitrate on which the adaptive logic will base itself. */
+    initialAudioBitrate?: number | undefined;
+    /**
+     * Options relative to the fetching and refreshing of the Manifest.
+     */
+    manifestRetryOptions: IManifestFetcherSettings;
+    /** Options relative to the fetching of media segments. */
+    segmentRetryOptions: ISegmentFetcherCreatorBackoffOptions;
+}
+export interface ILogLevelUpdateMessage {
+    type: MainThreadMessageType.LogLevelUpdate;
+    value: {
+        /** The new logger level that should be set. */
+        logLevel: ILoggerLevel;
+        sendBackLogs: boolean;
+    };
+}
+/**
+ * Message sent by the main thread when a new content should be "prepared".
+ *
+ * You can begin performing operarions which do not interrupt the previous
+ * content, like fetching its Manifest.
+ *
+ * Note that on the receivings-side, you only need to prepare one content at
+ * most. Meaning that if multiple `IPrepareContentMessage` arrive in a row, you
+ * can stop the preparation of previous contents.
+ */
+export interface IPrepareContentMessage {
+    type: MainThreadMessageType.PrepareContent;
+    value: IContentInitializationData;
+}
+/**
+ * Message sent by the main thread to stop playback of the last prepared content
+ * (through a `IPrepareContentMessage`) - if it was playing - and dispose all
+ * associated resources.
+ */
+export interface IStopContentMessage {
+    type: MainThreadMessageType.StopContent;
+    /**
+     * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
+     *
+     * Allows to ensure no race condition lead to actually stopping another content
+     * than the one meant by the main thread.
+     */
+    contentId: string;
+    value: null;
+}
+/**
+ * Message sent by the main thread to start playback of the last prepared content
+ * (through a `IPrepareContentMessage`).
+ */
+export interface IStartPreparedContentMessage {
+    type: MainThreadMessageType.StartPreparedContent;
+    /**
+     * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
+     *
+     * Allows to ensure no race condition lead to starting another content than
+     * the one meant by the main thread.
+     */
+    contentId: string;
+    value: IStartPreparedContentMessageValue;
+}
+/** Options needed when starting a new content. */
+export interface IStartPreparedContentMessageValue {
+    /** The start time at which we should play, in seconds. */
+    initialTime: number;
+    /** The current playback observation. */
+    initialObservation: ISerializedPlaybackObservation;
+    /**
+     * Hex-encoded string identifying the key system used.
+     * May be cross-referenced with the content's metadata when performing
+     * optimizations.
+     */
+    drmSystemId: string | undefined;
+    /**
+     * Enable/Disable fastSwitching: allow to replace lower-quality segments by
+     * higher-quality ones to have a faster transition.
+     */
+    enableFastSwitching: boolean;
+    /** Behavior when a new video and/or audio codec is encountered. */
+    onCodecSwitch: "continue" | "reload";
+}
+/**
+ * Message sent by the main thread when it has updated its list of supported
+ * codecs and has reasons to think that the WebWorker is not aware of it
+ * (e.g. their support was not set in a Manifest).
+ */
+export interface ICodecSupportUpdateMessage {
+    type: MainThreadMessageType.CodecSupportUpdate;
+    value: Array<{
+        /** The corresponding codec (e.g. "ec-3"). */
+        codec: string;
+        /** The mime-type associated (e.g. "audio/mp4"). */
+        mimeType: string;
+        /**
+         * If `true`, this `mimeType` and `codec` combination is supported.
+         * If `false`, it is not supported.
+         */
+        result: boolean;
+    }>;
+}
+/**
+ * Message sent by the main thread to the WebWorker regularly after an
+ * `IPrepareContentMessage` to provide various media-related metadata
+ * only obtainable on the main thread.
+ *
+ * Those messages are sent until the `IStopContentMessage` for that same
+ * `contentId`.
+ */
+export interface IPlaybackObservationMessage {
+    type: MainThreadMessageType.PlaybackObservation;
+    /**
+     * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
+     * Allows to prevent race conditions.
+     */
+    contentId: string;
+    /** The media-related metadata that has just been observed now. */
+    value: ISerializedPlaybackObservation;
+}
+/**
+ * Message sent by the main thread when at least one of the `Representation` of
+ * the current content just had a change of decipherability status.
+ *
+ * That is if one of the Representation either:
+ *   - became undecipherable
+ *   - became decipherable
+ *   - had its decipherability status transition from being known to unknown
+ */
+export interface IDecipherabilityStatusChangedMessage {
+    type: MainThreadMessageType.DecipherabilityStatusUpdate;
+    /**
+     * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
+     * Allows to prevent race conditions.
+     */
+    contentId: string;
+    /** List of the `Representation` which had their decipherability status updated. */
+    value: IDecipherabilityStatusChangedPayload[];
+}
+/** Object describing the new decipherability status of a `Representation`. */
+export interface IDecipherabilityStatusChangedPayload {
+    /** `uniqueId` for the concerned `Representation`. */
+    representationUniqueId: string;
+    /**
+     * If set to `true`, the `Representation` became decipherable.
+     *
+     * If set to `false`, the `Representation` became undecipherable.
+     *
+     * If set to `undefined`, the `Representation`'s decipherability status became
+     * unknown.
+     */
+    decipherable: boolean | undefined;
+}
+/** Message allowing to update the URL of the content being played. */
+export interface IUpdateContentUrlsMessage {
+    type: MainThreadMessageType.ContentUrlsUpdate;
+    /**
+     * Same `contentId` than for the corresponding `IPrepareContentMessage` message.
+     * Allows to prevent race conditions.
+     */
+    contentId: string;
+    /** Information on the new URL to set. */
+    value: IUpdateContentUrlsMessageValue;
+}
+/** Payload of an `IUpdateContentUrlsMessage`. */
+export interface IUpdateContentUrlsMessageValue {
+    /**
+     * URLs to reach that Manifest from the most prioritized URL to the least
+     * prioritized URL.
+     */
+    urls: string[] | undefined;
+    /**
+     * If `true` the resource in question (e.g. DASH's MPD) will be refreshed
+     * immediately.
+     */
+    refreshNow: boolean;
+}
+export interface ITrackUpdateMessage {
+    type: MainThreadMessageType.TrackUpdate;
+    contentId: string;
+    value: {
+        periodId: string;
+        bufferType: ITrackType;
+        choice: ITrackUpdateChoiceObject | null | undefined;
+    };
+}
+export interface ITrackUpdateChoiceObject {
+    /** The Adaptation choosen. */
+    adaptationId: string;
+    /** "Switching mode" in which the track switch should happen. */
+    switchingMode: ITrackSwitchingMode;
+    /**
+     * Shared reference allowing to indicate which Representations from
+     * that Adaptation are allowed.
+     */
+    initialRepresentations: IRepresentationsChoice;
+    /** Relative resuming position after a track change */
+    relativeResumingPosition: number | undefined;
+}
+export interface IRepresentationUpdateMessage {
+    type: MainThreadMessageType.RepresentationUpdate;
+    contentId: string;
+    value: {
+        periodId: string;
+        bufferType: ITrackType;
+        adaptationId: string;
+        choice: IRepresentationsChoice;
+    };
+}
+/** Media-related metadata. */
+export interface ISerializedPlaybackObservation {
+    /**
+     * Information on whether the media element was paused at the time of the
+     * Observation.
+     */
+    paused: IPausedPlaybackObservation;
+    position: [number, number | null];
+    /** `readyState` property of the HTMLMediaElement. */
+    readyState: number;
+    /** Target playback rate at which we want to play the content. */
+    speed: number;
+    /** Theoretical maximum position on the content that can currently be played. */
+    maximumPosition: number;
+    /**
+     * Ranges of buffered data per type of media.
+     *
+     * `null` as a record's value if no buffer exists for that type of media.
+     *
+     * `null` as a `buffered` value if this could not have been obtained on the
+     * current environment (e.g. in the main thread).
+     */
+    buffered: Record<ITrackType, IRange[] | null>;
+    duration: number;
+    /**
+     * Set if the player is short on audio and/or video media data and is a such,
+     * rebuffering.
+     * `null` if not.
+     */
+    rebuffering: IRebufferingStatus | null;
+    /**
+     * Set if the player is frozen, that is, stuck in place for unknown reason.
+     * Note that this reason can be a valid one, such as a necessary license not
+     * being obtained yet.
+     *
+     * `null` if the player is not frozen.
+     */
+    freezing: IFreezingStatus | null;
+    /**
+     * Gap between `currentTime` and the next position with un-buffered data.
+     * `Infinity` if we don't have buffered data right now.
+     * `undefined` if we cannot determine the buffer gap.
+     */
+    bufferGap: number | undefined;
+}
+/**
+ * Sent when the SourceBuffer linked to the given `mediaSourceId` and
+ * `SourceBufferType`, running on the main thread, succeeded to perform the last
+ * operation given to it (either through an `AppendBufferWorkerMessage` or a
+ * `RemoveBufferWorkerMessage`).
+ */
+export interface ISourceBufferOperationSuccessMainMessage {
+    type: MainThreadMessageType.SourceBufferSuccess;
+    /**
+     * Identify the MediaSource which contains the SourceBuffer concerned by
+     * this update.
+     */
+    mediaSourceId: string;
+    /**
+     * Id uniquely identifying this SourceBuffer.
+     * It should be the same `SourceBufferType` than the one on the
+     * `CreateSourceBufferWorkerMessage`.
+     */
+    sourceBufferType: SourceBufferType;
+    /** Identify the corresponding SourceBuffer operation. */
+    operationId: string;
+    value: {
+        /**
+         * New contiguous buffered time ranges, in chronological order in seconds.
+         */
+        buffered: IRange[];
+    };
+}
+export interface ISourceBufferErrorMainMessage {
+    type: MainThreadMessageType.SourceBufferError;
+    /**
+     * Identify the MediaSource which contains the SourceBuffer concerned by
+     * this update.
+     */
+    mediaSourceId: string;
+    /** Identify the SourceBuffer in question. */
+    sourceBufferType: SourceBufferType;
+    /** Identify the corresponding SourceBuffer operation. */
+    operationId: string;
+    value: ISerializedSourceBufferError | {
+        /**
+         * Identify a cancellation-specific error (the corresponding operation
+         * was cancelled.
+         */
+        errorName: "CancellationError";
+    };
+}
+/**
+ * Sent by the main thread to a Worker when the MediaSource linked to the
+ * `mediaSourceId` changed its readyState.
+ *
+ * This message is only sent if the MediaSource is created on the main thread.
+ */
+export interface IMediaSourceReadyStateChangeMainMessage {
+    type: MainThreadMessageType.MediaSourceReadyStateChange;
+    /** Identify the MediaSource through this unique identifier. */
+    mediaSourceId: string;
+    value: ReadyState;
+}
+export interface IPushTextDataSuccessMessage {
+    type: MainThreadMessageType.PushTextDataSuccess;
+    contentId: string;
+    value: {
+        ranges: IRange[];
+    };
+}
+export interface IRemoveTextDataSuccessMessage {
+    type: MainThreadMessageType.RemoveTextDataSuccess;
+    contentId: string;
+    value: {
+        ranges: IRange[];
+    };
+}
+export interface IPushTextDataErrorMessage {
+    type: MainThreadMessageType.PushTextDataError;
+    contentId: string;
+    value: {
+        message: string;
+    };
+}
+export interface IRemoveTextDataErrorMessage {
+    type: MainThreadMessageType.RemoveTextDataError;
+    contentId: string;
+    value: {
+        message: string;
+    };
+}
+/**
+ * Template for a message originating from main thread to update
+ * `SharedReference` objects (a common abstraction of the RxPlayer allowing for
+ * passing values whose updates can be listened to through a callback).
+ *
+ * Here, `TRefName` is the "name" of the `SharedReference` (the identifier
+ * choosen for it) and `TRefType` is the type of its value.
+ */
+export interface IReferenceUpdate<TRefName extends string, TRefType> {
+    type: MainThreadMessageType.ReferenceUpdate;
+    value: {
+        name: TRefName;
+        newVal: TRefType;
+    };
+}
+export type IReferenceUpdateMessage = IReferenceUpdate<"wantedBufferAhead", number> | IReferenceUpdate<"maxVideoBufferSize", number> | IReferenceUpdate<"maxBufferBehind", number> | IReferenceUpdate<"maxBufferAhead", number> | IReferenceUpdate<"limitVideoResolution", IResolutionInfo> | IReferenceUpdate<"throttleVideoBitrate", number>;
+export declare const enum MainThreadMessageType {
+    Init = "init",
+    PushTextDataSuccess = "add-text-success",
+    RemoveTextDataSuccess = "remove-text-success",
+    PushTextDataError = "push-text-error",
+    RemoveTextDataError = "remove-text-error",
+    CodecSupportUpdate = "codec-support-update",
+    ContentUrlsUpdate = "urls-update",
+    DecipherabilityStatusUpdate = "decipherability-update",
+    LogLevelUpdate = "log-level-update",
+    MediaSourceReadyStateChange = "media-source-ready-state-change",
+    PlaybackObservation = "observation",
+    PrepareContent = "prepare",
+    ReferenceUpdate = "ref-update",
+    RepresentationUpdate = "rep-update",
+    SourceBufferError = "sb-error",
+    SourceBufferSuccess = "sb-success",
+    StartPreparedContent = "start",
+    StopContent = "stop",
+    TrackUpdate = "track-update"
+}
+export type IMainThreadMessage = IInitMessage | ILogLevelUpdateMessage | IPrepareContentMessage | IStopContentMessage | IStartPreparedContentMessage | IReferenceUpdateMessage | ICodecSupportUpdateMessage | IPlaybackObservationMessage | IDecipherabilityStatusChangedMessage | IUpdateContentUrlsMessage | ISourceBufferErrorMainMessage | ISourceBufferOperationSuccessMainMessage | ITrackUpdateMessage | IRepresentationUpdateMessage | IPushTextDataSuccessMessage | IRemoveTextDataSuccessMessage | IPushTextDataErrorMessage | IRemoveTextDataErrorMessage | IMediaSourceReadyStateChangeMainMessage;
+export type ISentError = ISerializedNetworkError | ISerializedMediaError | ISerializedEncryptedMediaError | ISerializedOtherError;
+/**
+ * Message sent by the WebWorker when its initialization, started implicitely
+ * as soon as the `new Worker` call was made for it, has finished and succeeded.
+ *
+ * Once that message has been received, you can ensure that no
+ * `IInitErrorWorkerMessage` will ever be received for the same worker.
+ *
+ * Note that receiving this message is not a requirement before preparing and
+ * loading a content, both initialization and content loading can be started in
+ * parallel.
+ */
+export interface IInitSuccessWorkerMessage {
+    type: WorkerMessageType.InitSuccess;
+    value: null;
+}
+/**
+ * Message sent by the WebWorker when its initialization, started implicitely
+ * as soon as the `new Worker` call was made for it, has finished and failed.
+ *
+ * Once that message has been received, you can ensure that no
+ * `IInitErrorWorkerMessage` will ever be received for the same worker.
+ *
+ * Note that you may received this message while preparing and/or loading a
+ * content, both initialization and content loading can be started in
+ * parallel.
+ * As such, this message may be coupled with a content error.
+ */
+export interface IInitErrorWorkerMessage {
+    type: WorkerMessageType.InitError;
+    value: {
+        /** A string describing the error encountered. */
+        errorMessage: string;
+        kind: "dashWasmInitialization";
+    };
+}
+export interface INeedsBufferFlushWorkerMessage {
+    type: WorkerMessageType.NeedsBufferFlush;
+    contentId: string;
+    value: {
+        relativeResumingPosition: number;
+        relativePosHasBeenDefaulted: boolean;
+    } | undefined;
+}
+export interface IActivePeriodChangedWorkerMessage {
+    type: WorkerMessageType.ActivePeriodChanged;
+    contentId: string;
+    value: {
+        periodId: string;
+    };
+}
+export interface IWarningWorkerMessage {
+    type: WorkerMessageType.Warning;
+    contentId: string | undefined;
+    value: ISentError;
+}
+export interface IAttachMediaSourceWorkerMessage {
+    type: WorkerMessageType.AttachMediaSource;
+    contentId: string | undefined;
+    mediaSourceId: string | undefined;
+    value: IAttachMediaSourceWorkerMessagePayload;
+}
+export type IAttachMediaSourceWorkerMessagePayload = {
+    type: "handle";
+    value: MediaProvider;
+} | {
+    type: "url";
+    value: string;
+};
+export interface ICreateMediaSourceWorkerMessage {
+    type: WorkerMessageType.CreateMediaSource;
+    mediaSourceId: string;
+    contentId: string;
+}
+export interface IAddSourceBufferWorkerMessage {
+    type: WorkerMessageType.AddSourceBuffer;
+    mediaSourceId: string;
+    value: {
+        sourceBufferType: SourceBufferType;
+        codec: string;
+    };
+}
+export interface IAppendBufferWorkerMessage {
+    type: WorkerMessageType.SourceBufferAppend;
+    mediaSourceId: string;
+    sourceBufferType: SourceBufferType;
+    operationId: string;
+    value: {
+        data: BufferSource;
+        params: ISourceBufferInterfaceAppendBufferParameters;
+    };
+}
+export interface IRemoveBufferWorkerMessage {
+    type: WorkerMessageType.SourceBufferRemove;
+    mediaSourceId: string;
+    sourceBufferType: SourceBufferType;
+    operationId: string;
+    value: {
+        /** Start time we should remove data from, in seconds. */
+        start: number;
+        /** End time we should remove data at, in seconds. */
+        end: number;
+    };
+}
+export interface IAbortBufferWorkerMessage {
+    type: WorkerMessageType.AbortSourceBuffer;
+    mediaSourceId: string;
+    sourceBufferType: SourceBufferType;
+    value: null;
+}
+export interface IUpdateMediaSourceDurationWorkerMessage {
+    type: WorkerMessageType.UpdateMediaSourceDuration;
+    mediaSourceId: string;
+    value: {
+        duration: number;
+        isRealEndKnown: boolean;
+    };
+}
+export interface IInterruptMediaSourceDurationWorkerMessage {
+    type: WorkerMessageType.InterruptMediaSourceDurationUpdate;
+    mediaSourceId: string;
+    value: null;
+}
+export interface IEndOfStreamWorkerMessage {
+    type: WorkerMessageType.EndOfStream;
+    mediaSourceId: string;
+    value: null;
+}
+export interface IStopEndOfStreamWorkerMessage {
+    type: WorkerMessageType.InterruptEndOfStream;
+    mediaSourceId: string;
+    value: null;
+}
+export interface IDisposeMediaSourceWorkerMessage {
+    type: WorkerMessageType.DisposeMediaSource;
+    mediaSourceId: string;
+    value: null;
+}
+export interface IAdaptationChangeWorkerMessage {
+    type: WorkerMessageType.AdaptationChanged;
+    contentId: string;
+    value: {
+        adaptationId: string | null;
+        periodId: string;
+        type: ITrackType;
+    };
+}
+export interface IRepresentationChangeWorkerMessage {
+    type: WorkerMessageType.RepresentationChanged;
+    contentId: string;
+    value: {
+        adaptationId: string;
+        representationId: string | null;
+        periodId: string;
+        type: ITrackType;
+    };
+}
+export interface IManifestReadyWorkerMessage {
+    type: WorkerMessageType.ManifestReady;
+    contentId: string;
+    value: {
+        manifest: IManifestMetadata;
+    };
+}
+export interface IManifestUpdateWorkerMessage {
+    type: WorkerMessageType.ManifestUpdate;
+    contentId: string | undefined;
+    value: {
+        manifest: IManifestMetadata;
+        updates: IPeriodsUpdateResult;
+    };
+}
+export interface IEncryptionDataEncounteredWorkerMessage {
+    type: WorkerMessageType.EncryptionDataEncountered;
+    contentId: string | undefined;
+    value: IContentProtection;
+}
+export interface IErrorWorkerMessage {
+    type: WorkerMessageType.Error;
+    contentId: string | undefined;
+    value: ISentError;
+}
+export interface IUpdatePlaybackRateWorkerMessage {
+    type: WorkerMessageType.UpdatePlaybackRate;
+    contentId: string | undefined;
+    value: number;
+}
+export interface IReloadingMediaSourceWorkerMessage {
+    type: WorkerMessageType.ReloadingMediaSource;
+    contentId: string;
+    value: {
+        timeOffset: number;
+        minimumPosition?: number | undefined;
+        maximumPosition?: number | undefined;
+    };
+}
+export interface INeedsDecipherabilityFlushWorkerMessage {
+    type: WorkerMessageType.NeedsDecipherabilityFlush;
+    contentId: string;
+    value: null;
+}
+export interface ILockedStreamWorkerMessage {
+    type: WorkerMessageType.LockedStream;
+    contentId: string;
+    value: {
+        /** Period concerned. */
+        periodId: string;
+        /** Buffer type concerned. */
+        bufferType: ITrackType;
+    };
+}
+export interface IBitrateEstimateChangeWorkerMessage {
+    type: WorkerMessageType.BitrateEstimateChange;
+    contentId: string;
+    value: {
+        bitrate: number | undefined;
+        bufferType: ITrackType;
+    };
+}
+export interface IInbandEventWorkerMessage {
+    type: WorkerMessageType.InbandEvent;
+    contentId: string;
+    value: IInbandEvent[];
+}
+export interface IPeriodStreamReadyWorkerMessage {
+    type: WorkerMessageType.PeriodStreamReady;
+    contentId: string;
+    value: {
+        /** Period concerned. */
+        periodId: string;
+        /** Buffer type concerned. */
+        bufferType: ITrackType;
+    };
+}
+export interface IPeriodStreamClearedWorkerMessage {
+    type: WorkerMessageType.PeriodStreamCleared;
+    contentId: string;
+    value: {
+        /** `id` of the Period concerned. */
+        periodId: string;
+        /** Buffer type concerned. */
+        bufferType: ITrackType;
+    };
+}
+export interface IPushTextDataWorkerMessage {
+    type: WorkerMessageType.PushTextData;
+    contentId: string;
+    value: ITextDisplayerData;
+}
+export interface IRemoveTextDataWorkerMessage {
+    type: WorkerMessageType.RemoveTextData;
+    contentId: string;
+    value: {
+        start: number;
+        end: number;
+    };
+}
+export interface IStopTextDisplayerWorkerMessage {
+    type: WorkerMessageType.StopTextDisplayer;
+    contentId: string;
+    value: null;
+}
+export interface IResetTextDisplayerWorkerMessage {
+    type: WorkerMessageType.ResetTextDisplayer;
+    contentId: string;
+    value: null;
+}
+export interface ILogMessageWorkerMessage {
+    type: WorkerMessageType.LogMessage;
+    value: {
+        logLevel: ILoggerLevel;
+        logs: Array<boolean | string | number | ISentError | null | undefined>;
+    };
+}
+export interface IDiscontinuityUpdateWorkerMessage {
+    type: WorkerMessageType.DiscontinuityUpdate;
+    contentId: string;
+    value: IDiscontinuityUpdateWorkerMessagePayload;
+}
+export interface IDiscontinuityUpdateWorkerMessagePayload {
+    periodId: string;
+    bufferType: ITrackType;
+    discontinuity: IDiscontinuityTimeInfo | null;
+    position: number;
+}
+/** Information on a found discontinuity. */
+export interface IDiscontinuityTimeInfo {
+    /**
+     * Start time of the discontinuity.
+     * `undefined` for when the start is unknown but the discontinuity was
+     * currently encountered at the position we were in when this event was
+     * created.
+     */
+    start: number | undefined;
+    /**
+     * End time of the discontinuity, in seconds.
+     * If `null`, no further segment can be loaded for the corresponding Period.
+     */
+    end: number | null;
+}
+export declare const enum WorkerMessageType {
+    AbortSourceBuffer = "abort-source-buffer",
+    ActivePeriodChanged = "active-period-changed",
+    AdaptationChanged = "adaptation-changed",
+    AddSourceBuffer = "add-source-buffer",
+    AttachMediaSource = "attach-media-source",
+    BitrateEstimateChange = "bitrate-estimate-change",
+    CreateMediaSource = "create-media-source",
+    DiscontinuityUpdate = "discontinuity-update",
+    DisposeMediaSource = "dispose-media-source",
+    EncryptionDataEncountered = "encryption-data-encountered",
+    EndOfStream = "end-of-stream",
+    Error = "error",
+    InbandEvent = "inband-event",
+    InitError = "init-error",
+    InitSuccess = "init-success",
+    InterruptEndOfStream = "stop-end-of-stream",
+    InterruptMediaSourceDurationUpdate = "stop-media-source-duration",
+    LockedStream = "locked-stream",
+    LogMessage = "log",
+    ManifestReady = "manifest-ready",
+    ManifestUpdate = "manifest-update",
+    NeedsBufferFlush = "needs-buffer-flush",
+    NeedsDecipherabilityFlush = "needs-decipherability-flush",
+    PeriodStreamCleared = "period-stream-cleared",
+    PeriodStreamReady = "period-stream-ready",
+    PushTextData = "push-text-data",
+    ReloadingMediaSource = "reloading-media-source",
+    RemoveTextData = "remove-text-data",
+    RepresentationChanged = "representation-changed",
+    ResetTextDisplayer = "reset-text-displayer",
+    SourceBufferAppend = "source-buffer-append",
+    SourceBufferRemove = "source-buffer-remove",
+    StopTextDisplayer = "stop-text-displayer",
+    UpdateMediaSourceDuration = "update-media-source-duration",
+    UpdatePlaybackRate = "update-playback-rate",
+    Warning = "warning"
+}
+export type IWorkerMessage = IAbortBufferWorkerMessage | IActivePeriodChangedWorkerMessage | IAdaptationChangeWorkerMessage | IAddSourceBufferWorkerMessage | IPushTextDataWorkerMessage | IAppendBufferWorkerMessage | IAttachMediaSourceWorkerMessage | IBitrateEstimateChangeWorkerMessage | ICreateMediaSourceWorkerMessage | IDiscontinuityUpdateWorkerMessage | IDisposeMediaSourceWorkerMessage | IEncryptionDataEncounteredWorkerMessage | IEndOfStreamWorkerMessage | IErrorWorkerMessage | IInbandEventWorkerMessage | IInitSuccessWorkerMessage | IInitErrorWorkerMessage | IInterruptMediaSourceDurationWorkerMessage | ILockedStreamWorkerMessage | ILogMessageWorkerMessage | IManifestReadyWorkerMessage | IManifestUpdateWorkerMessage | INeedsBufferFlushWorkerMessage | INeedsDecipherabilityFlushWorkerMessage | IPeriodStreamClearedWorkerMessage | IPeriodStreamReadyWorkerMessage | IReloadingMediaSourceWorkerMessage | IRemoveBufferWorkerMessage | IRemoveTextDataWorkerMessage | IRepresentationChangeWorkerMessage | IResetTextDisplayerWorkerMessage | IStopEndOfStreamWorkerMessage | IStopTextDisplayerWorkerMessage | IUpdateMediaSourceDurationWorkerMessage | IUpdatePlaybackRateWorkerMessage | IWarningWorkerMessage;