@bitmovin/player-web-x 10.2.0-beta.9 → 10.2.0

package/types/packages/advertising/bitmovin/Types.d.ts

@@ -5,21 +5,25 @@ import type { MetricsAtom } from '../../core/metrics/MetricsAtom';
 import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../../core/Types';
 import type { CoreUtils } from '../../core/utils/Types';
 import type { NetworkTask } from '../../network/NetworkTask';
-import type { NetworkExportNames } from '../../network/Types';
+import type { HttpRequestMethod, HttpResponseType, NetworkExportNames } from '../../network/Types';
 import type { TargetPlaybackState, TargetPlaybackStateAtom } from '../../playback/play-pause/TargetPlaybackStateAtom';
 import type { PlayPauseExportNames } from '../../playback/play-pause/Types';
-import type { SeekRestrictionAtom } from '../../playback/video-element-state/SeekRestrictionAtom';
-import type { VideoElementStateExportNames } from '../../playback/video-element-state/Types';
-import type { VideoElementStateAtom } from '../../playback/video-element-state/VideoElementStateAtom';
 import type { SourceStateAtom } from '../../source/atoms/SourceStateAtom';
 import type { createSourceReference } from '../../source/SourceReference';
 import type { SourceExportNames, SourceReferences } from '../../source/Types';
 import type { SourceRemovedError } from '../../sources-api/SourceRemovedError';
 import type { SourcesApiExportNames } from '../../sources-api/Types';
 import type { ContextWithState } from '../../Types';
+import type { AdExtensionSource } from '../base/AdExtension';
+import type { isAdPositionKnown } from '../base/AdPosition';
+import type { AdQuartile } from '../base/AdQuartile';
+import type { AdType } from '../base/AdType';
 import type { createBaseAdAtom } from '../base/BaseAdAtom';
-import type { createBaseAdBreakAtom } from '../base/BaseAdBreakAtom';
-import type { AdQuartile, AdSourceAdExports, AdType, AdvertisingBaseExportNames, BaseAdBreakState, BaseAdState, ContentSourceAdExports } from '../base/Types';
+import type { createBaseAdPodAtom } from '../base/BaseAdPodAtom';
+import type { BaseAdPodState } from '../base/BaseAdPodState';
+import type { BaseAdState } from '../base/BaseAdState';
+import type { createClickThroughAtom } from '../base/ClickThroughAtom';
+import type { AdSourceAdExports, AdvertisingBaseExportNames, ContentSourceAdExports } from '../base/Types';
 export type AdvertisingBitmovinPackageDependencies = {
     [CoreExportNames.CoreEffects]: CoreEffects;
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
@@ -29,18 +33,21 @@ export type AdvertisingBitmovinPackageDependencies = {
     [SourceExportNames.CreateSourceReference]: typeof createSourceReference;
     [SourceExportNames.SourceReferences]: SourceReferences;
     [SourcesApiExportNames.SourceRemovedError]: typeof SourceRemovedError;
-    [VideoElementStateExportNames.VideoElementState]: VideoElementStateAtom;
-    [VideoElementStateExportNames.SeekRestriction]: SeekRestrictionAtom;
     [NetworkExportNames.NetworkTask]: typeof NetworkTask;
+    [NetworkExportNames.HttpRequestMethod]: typeof HttpRequestMethod;
+    [NetworkExportNames.HttpResponseType]: typeof HttpResponseType;
     [AdaptationExportNames.Metrics]: MetricsAtom;
     [PlayPauseExportNames.TargetPlaybackState]: typeof TargetPlaybackState;
     [PlayPauseExportNames.TargetPlaybackStateAtom]: TargetPlaybackStateAtom;
     [AdvertisingBaseExportNames.AdType]: typeof AdType;
     [AdvertisingBaseExportNames.AdQuartile]: typeof AdQuartile;
-    [AdvertisingBaseExportNames.BaseAdBreakState]: typeof BaseAdBreakState;
+    [AdvertisingBaseExportNames.AdExtensionSource]: typeof AdExtensionSource;
+    [AdvertisingBaseExportNames.BaseAdPodState]: typeof BaseAdPodState;
     [AdvertisingBaseExportNames.BaseAdState]: typeof BaseAdState;
-    [AdvertisingBaseExportNames.CreateBaseAdBreak]: typeof createBaseAdBreakAtom;
+    [AdvertisingBaseExportNames.CreateBaseAdPod]: typeof createBaseAdPodAtom;
     [AdvertisingBaseExportNames.CreateBaseAd]: typeof createBaseAdAtom;
+    [AdvertisingBaseExportNames.CreateClickThrough]: typeof createClickThroughAtom;
+    [AdvertisingBaseExportNames.IsAdPositionKnown]: typeof isAdPositionKnown;
 };
 export type AdvertisingBitmovinPackageExports = ContentSourceAdExports & AdSourceAdExports;
 export type AdvertisingBitmovinContext = ContextHaving<AdvertisingBitmovinPackageDependencies, AdvertisingBitmovinPackageExports, ContextWithState>;

package/types/packages/analytics/Analytics.package.d.ts

@@ -13,3 +13,5 @@ import type { Package } from '../../../framework-types/package-api/Package';
 import type { AnalyticsPackageDependencies } from './Types';
 export declare const AnalyticsPackage: Package<AnalyticsPackageDependencies, EmptyObject, EmptyObject>;
 export default AnalyticsPackage;
+
+export declare const version: string;

package/types/packages/browser-specific/safari/Safari.package.d.ts

@@ -0,0 +1,5 @@
+import type { EmptyObject } from '../../../../framework-types/BaseTypes';
+import type { SafariPackageDependencies } from './Types';
+export declare const SafariPackage: import("../../../../framework-types/package-api/Package").Package<SafariPackageDependencies, EmptyObject, EmptyObject>;
+
+export declare const version: string;

package/types/packages/browser-specific/safari/Types.d.ts

@@ -0,0 +1,24 @@
+import type { EmptyObject } from '../../../../framework-types/BaseTypes';
+import type { ContextHaving, ContextUsing } from '../../../../framework-types/execution-context/Types';
+import type { CapabilitiesExportNames, PlatformCapabilities } from '../../capabilities/Types';
+import type { EventListenerEffect } from '../../core/effects/EventListenerEffectFactory';
+import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../../core/Types';
+import type { CoreUtils } from '../../core/utils/Types';
+import type { MediaState, MediaStateAtom, MediaStateExportNames } from '../../media-state/Types';
+import type { BrowserDetectionExports } from '../../platform-detection/browser-detection/Types';
+import type { SourceStateAtom } from '../../source/atoms/SourceStateAtom';
+import type { SourceExportNames } from '../../source/Types';
+import type { ContextWithState } from '../../Types';
+export type SafariPackageDependencies = BrowserDetectionExports & {
+    [SourceExportNames.SourceState]: SourceStateAtom;
+    [CoreExportNames.Utils]: CoreUtils;
+    [CoreExportNames.CoreEffects]: CoreEffects;
+    [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
+    [MediaStateExportNames.MediaState]: typeof MediaState;
+    [MediaStateExportNames.MediaStateAtom]: MediaStateAtom;
+    [CapabilitiesExportNames.PlatformCapabilities]: PlatformCapabilities;
+};
+export type SafariPackageExports = EmptyObject;
+export type SafariPackageContext = ContextUsing<[
+    EventListenerEffect
+], ContextHaving<SafariPackageDependencies, SafariPackageExports, ContextWithState>>;

package/types/packages/capabilities/Capabilities.package.d.ts

@@ -24,3 +24,5 @@ type Dependencies = {
 };
 export declare const CapabilitiesPackage: import("../../../framework-types/package-api/Package").Package<Dependencies, Exports, EmptyObject>;
 export default CapabilitiesPackage;
+
+export declare const version: string;

package/types/packages/capabilities/Types.d.ts

@@ -1,4 +1,4 @@
-import type { ContainerFormat } from '../stream-data-structure/segment/SegmentDataAtom';
+import type { ContainerFormat } from '../core/Constants';
 export interface PlatformCapabilities {
     managedMediaSourceSupported(): boolean;
     mediaSourceSupported(): boolean;

package/types/packages/container/container-mp4/ContainerMp4.package.d.ts

@@ -14,6 +14,7 @@
  */
 import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
 import type { EmptyObject } from '../../../Types';
+import type { Constants } from '../../core/Constants';
 import type { CoreEffects, CoreStateAtoms } from '../../core/Types';
 import { CoreExportNames } from '../../core/Types';
 import type SegmentProcessorErrors from '../../segment-processing/Errors';
@@ -27,6 +28,7 @@ type Dependencies = {
     [SourceExportNames.SourceState]: SourceStateAtom;
     [CoreExportNames.CoreEffects]: CoreEffects;
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
+    [CoreExportNames.Constants]: Constants;
     [SegmentProcessingExportNames.SegmentProcessorType]: typeof SegmentProcessorType;
     [SegmentProcessingExportNames.SegmentProcessingComponent]: SegmentProcessingComponent;
     [SegmentProcessingExportNames.SegmentProcessorErrors]: typeof SegmentProcessorErrors;
@@ -34,3 +36,5 @@ type Dependencies = {
 export type ContainerMp4PackageContext = ContextHaving<Dependencies, EmptyObject, ContextWithState>;
 export declare const ContainerMp4Package: import("../../../../framework-types/package-api/Package").Package<Dependencies, EmptyObject, EmptyObject>;
 export default ContainerMp4Package;
+
+export declare const version: string;

package/types/packages/container/container-ts/ContainerTs.package.d.ts

@@ -11,6 +11,7 @@
  */
 import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
 import type { EmptyObject } from '../../../Types';
+import type { Constants } from '../../core/Constants';
 import type { CoreEffects, CoreStateAtoms } from '../../core/Types';
 import { CoreExportNames } from '../../core/Types';
 import type SegmentProcessorErrors from '../../segment-processing/Errors';
@@ -18,12 +19,13 @@ import type { SegmentProcessingComponent, SegmentProcessorType } from '../../seg
 import { SegmentProcessingExportNames } from '../../segment-processing/Types';
 import type { SourceStateAtom } from '../../source/atoms/SourceStateAtom';
 import { SourceExportNames } from '../../source/Types';
-import type { StreamDataStructureSegments } from '../../stream-data-structure/segment/Exports';
+import { StreamDataStructureSegments } from '../../stream-data-structure/segment/Exports';
 import type { ContextWithState } from '../../Types';
 type Dependencies = {
     [SourceExportNames.SourceState]: SourceStateAtom;
     [CoreExportNames.CoreEffects]: CoreEffects;
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
+    [CoreExportNames.Constants]: Constants;
     [SegmentProcessingExportNames.SegmentProcessorType]: typeof SegmentProcessorType;
     [SegmentProcessingExportNames.SegmentProcessingComponent]: SegmentProcessingComponent;
     [SegmentProcessingExportNames.SegmentProcessorErrors]: typeof SegmentProcessorErrors;
@@ -31,3 +33,5 @@ type Dependencies = {
 export type ContainerTsPackageContext = ContextHaving<Dependencies, EmptyObject, ContextWithState>;
 export declare const ContainerTsPackage: import("../../../../framework-types/package-api/Package").Package<Dependencies, EmptyObject, EmptyObject>;
 export default ContainerTsPackage;
+
+export declare const version: string;

package/types/packages/container/ts-transmuxer/TsTransmuxer.package.d.ts

@@ -12,6 +12,7 @@
  */
 import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
 import type { EmptyObject } from '../../../Types';
+import type { Constants } from '../../core/Constants';
 import type { CoreEffects, CoreStateAtoms } from '../../core/Types';
 import { CoreExportNames } from '../../core/Types';
 import type { CoreUtils } from '../../core/utils/Types';
@@ -27,6 +28,7 @@ type Dependencies = {
     [CoreExportNames.Utils]: CoreUtils;
     [CoreExportNames.CoreEffects]: CoreEffects;
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
+    [CoreExportNames.Constants]: Constants;
     [SegmentProcessingExportNames.SegmentProcessorType]: typeof SegmentProcessorType;
     [SegmentProcessingExportNames.SegmentProcessingComponent]: SegmentProcessingComponent;
     [SegmentProcessingExportNames.SegmentProcessorErrors]: typeof SegmentProcessorErrors;
@@ -34,3 +36,5 @@ type Dependencies = {
 export type TsTransmuxerPackageContext = ContextHaving<Dependencies, EmptyObject, ContextWithState>;
 export declare const TsTransmuxerPackage: import("../../../../framework-types/package-api/Package").Package<Dependencies, EmptyObject, EmptyObject>;
 export default TsTransmuxerPackage;
+
+export declare const version: string;

package/types/packages/core/Constants.d.ts

@@ -39,6 +39,12 @@ export declare enum LoadControl {
     Metadata = 1,
     Data = 2
 }
+export declare enum ContainerFormat {
+    MP4 = "mp4",
+    TS = "mp2t",
+    WebM = "webm",
+    Unknown = "unknown"
+}
 export type Constants = {
     Codec: typeof Codec;
     MediaType: typeof MediaType;
@@ -49,4 +55,5 @@ export type Constants = {
     LoadControl: typeof LoadControl;
     Version: string;
     SubtitleFormatType: typeof SubtitleFormatType;
+    ContainerFormat: typeof ContainerFormat;
 };

package/types/packages/core/Core.package.d.ts

@@ -11,3 +11,5 @@ import type { EmptyObject } from '../../Types';
 import type { CoreExports } from './Types';
 export declare const CorePackage: import("../../../framework-types/package-api/Package").Package<import("../../../framework-types/BaseTypes").EmptyObject, CoreExports, EmptyObject>;
 export default CorePackage;
+
+export declare const version: string;

package/types/packages/core/Types.d.ts

@@ -9,8 +9,9 @@ import type { createDataStreamAtom, DataStreamClearedError, DataStreamClosedErro
 import type { createMapStateAtom } from './state/MapStateAtom';
 import type { createPrimitiveAtom } from './state/PrimitiveAtom';
 import type { createQueueAtom, QueueItemRemovedError } from './state/QueueAtom';
+import type { createRingBufferAtom } from './state/RingBufferAtom';
 import type { StateEffectFactory } from './state/state-effect/StateEffectFactory';
-import type { createStateMachineAtom, flushPendingUpdates, logTransitions } from './state/StateMachineAtom';
+import type { createStateMachineAtom, flushPendingUpdates } from './state/StateMachineAtom';
 import type { CreateStoreEffectFactory } from './state/StoreEffectFactory';
 import type { createStreamSectionAtom } from './state/stream-timeline/StreamSectionAtom';
 import type { createStreamSequenceMapAtom } from './state/stream-timeline/StreamSequenceMapAtom';
@@ -61,6 +62,7 @@ export type CoreStateAtoms = {
     createPrimitiveAtom: typeof createPrimitiveAtom;
     createTimelineAtom: typeof createTimelineAtom;
     createTimelineTrackerAtom: typeof createTimelineTrackerAtom;
+    createRingBufferAtom: typeof createRingBufferAtom;
     Queue: {
         createQueueAtom: typeof createQueueAtom;
         QueueItemRemovedError: typeof QueueItemRemovedError;
@@ -89,6 +91,5 @@ export type CoreStateAtoms = {
     StateMachine: {
         createStateMachineAtom: typeof createStateMachineAtom;
         flushPendingUpdates: typeof flushPendingUpdates;
-        logTransitions: typeof logTransitions;
     };
 };

package/types/packages/core/metrics/MetricsAtom.d.ts

@@ -1,7 +1,7 @@
 import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
 import type { EmptyObject } from '../../../Types';
-import type { RingBufferAtom } from '../../adaptation/RingBufferAtom';
 import type { ContextWithState } from '../../Types';
+import type { RingBufferAtom } from '../state/RingBufferAtom';
 import type { CoreExportNames, CoreStateAtoms } from '../Types';
 import type { NetworkSampleAtom } from './network/NetworkSampleAtom';
 export interface Metrics {

package/types/packages/{adaptation → core/state}/RingBufferAtom.d.ts

@@ -1,4 +1,4 @@
-import type { ContextWithState } from '../Types';
+import type { ContextWithState } from '../../Types';
 export interface RingBuffer<T> {
     buffer: T[];
     capacity: number;
@@ -10,7 +10,7 @@ export declare function getDefaultRingBuffer<T>(capacity?: number, input?: T[]):
 export declare function getTail<T>(data: RingBufferAtom<T>): T | undefined;
 export declare function getHead<T>(data: RingBufferAtom<T>): T | undefined;
 export type RingBufferAtom<T> = ReturnType<typeof createRingBufferAtom<T>>;
-export declare const createRingBufferAtom: <ElementType>(context: ContextWithState, capacity?: number, defaultData?: ElementType[] | undefined) => import("../core/state/Types").StateAtom<RingBuffer<ElementType>, {
+export declare const createRingBufferAtom: <ElementType>(context: ContextWithState, capacity?: number, defaultData?: ElementType[] | undefined) => import("./Types").StateAtom<RingBuffer<ElementType>, {
     add: (data: RingBuffer<ElementType>, element: ElementType) => boolean;
     clear: (data: RingBuffer<ElementType>) => boolean;
 }>;

package/types/packages/core/state/StateMachineAtom.d.ts

@@ -9,21 +9,22 @@ export interface StateMachine<S> {
     current: S;
     previous: S;
 }
-export type StateMachineAtom<S extends string, _ extends ContextWithState, D = void> = StateAtom<StateMachine<S>, {
+export type BaseStateMachineContext = ContextHaving<{
+    [CoreExportNames.Utils]: CoreUtils;
+}, EmptyObject, ContextWithState>;
+export type StateMachineAtom<S extends string, _ extends BaseStateMachineContext, D = void> = StateAtom<StateMachine<S>, {
     updateState: (state: StateMachine<S>, data: D) => boolean;
 }>;
-export type Transition<S extends string, C extends ContextWithState, D = void> = (context: C, data: D) => S;
-export type TransitionMap<S extends string, C extends ContextWithState, D = void> = {
+export type Transition<S extends string, C extends BaseStateMachineContext, D = void> = (context: C, data: D) => S;
+export type TransitionMap<S extends string, C extends BaseStateMachineContext, D = void> = {
     [key in S]: Transition<S, C, D>;
 };
-export type Handler<S extends string, C extends ContextWithState, D = void> = NamedTask<Task<C, StateMachineAtom<S, C, D>, void>>;
-export type HandlerMap<S extends string, C extends ContextWithState, D = void> = {
+export type Handler<S extends string, C extends BaseStateMachineContext, D = void> = NamedTask<Task<C, StateMachineAtom<S, C, D>, void>>;
+export type HandlerMap<S extends string, C extends BaseStateMachineContext, D = void> = {
     [key in S]?: Handler<S, C, D>;
 };
-export declare function createStateMachineAtom<S extends string, C extends ContextWithState, D = void>(context: C, initialState: S, transitions: TransitionMap<S, C, D>, handlers?: HandlerMap<S, C, D>): StateMachineAtom<S, C, D>;
-export declare function flushPendingUpdates(context: ContextWithState, stateMachine: StateMachineAtom<string, ContextWithState>): void;
-type ContextWithStateAndLogger = ContextHaving<{
-    [CoreExportNames.Utils]: CoreUtils;
-}, EmptyObject, ContextWithState>;
-export declare function logTransitions<S extends string, C extends ContextWithState, D = void>(context: ContextWithStateAndLogger, stateMachine: StateMachineAtom<S, C, D>, name: string): void;
-export {};
+export type StateMachineLoggingOptions = {
+    name: string;
+};
+export declare function createStateMachineAtom<S extends string, C extends BaseStateMachineContext, D = void>(context: C, initialState: S, transitions: TransitionMap<S, C, D>, handlers?: HandlerMap<S, C, D>, loggingOptions?: StateMachineLoggingOptions): StateMachineAtom<S, C, D>;
+export declare function flushPendingUpdates(context: BaseStateMachineContext, stateMachine: StateMachineAtom<string, BaseStateMachineContext>): void;

package/types/packages/core/state/state-effect/Types.d.ts

@@ -1,8 +1,8 @@
 import type { ExecutionContext } from '../../../../../framework-types/execution-context/ExecutionContext';
 import type { AnyNamedTask, AnyParameterTask, AnyTask, NamedTask, TaskParam } from '../../../../../framework-types/task/Types';
 import type { EmptyObject } from '../../../../Types';
-import type { IsStateAtom } from '../Types';
+import type { StateAtom } from '../Types';
 export type ParameterizedTask<P, S extends NamedTask<AnyTask>> = S extends NamedTask<AnyParameterTask<P>> ? S : NamedTask<AnyParameterTask<P>>;
-export type TaskParameter<Atom, Task extends ParameterizedTask<Atom, NamedTask<AnyTask>>> = IsStateAtom<TaskParam<Task>> extends true ? TaskParam<Task> : never;
+export type TaskParameter<Atom, Task extends ParameterizedTask<Atom, NamedTask<AnyTask>>> = Extract<TaskParam<Task>, StateAtom>;
 export type ErrorCallback = (error: Error) => boolean;
 export type SubscriberTuple = [ExecutionContext<EmptyObject, EmptyObject>, AnyNamedTask, ErrorCallback];

package/types/packages/core/technology/Types.d.ts

@@ -11,9 +11,9 @@ export type Factory<Payload, Context extends AnyExecutionContext, TechnologyName
     resolve: NamedTask<Task<Context, Payload, void>>;
     add(technology: Technology<Payload, Context, TechnologyName>, abortSignal: AbortSignal): void;
 };
-export declare const TechnologyExport = "technology";
+export declare const TechnologyExports = "technology";
 export type TechnologyExports = {
-    [TechnologyExport]: {
+    [TechnologyExports]: {
         create: <Payload, Context extends AnyExecutionContext, TechnologyName extends string>(context: ContextWithState, prioritize: Prioritize<Payload, Context, TechnologyName>) => Factory<Payload, Context, TechnologyName>;
     };
 };

package/types/packages/core/utils/ArrayHelper.d.ts

@@ -1,5 +1,4 @@
 declare function findIndex<T>(arr: readonly T[], searchValue: number, getValue: (value: T) => number): number;
-declare function AlternatingIndexGenerator(length: number, startIndex?: number): Generator<number, void, unknown>;
 declare function findIndexWithPivot<T, V = number>(arr: readonly T[], pivotIndex: number, searchValue: V, getValue: (value: T) => V, matches: (value: T) => boolean): number;
 declare class IterableStreamClosedError extends Error {
     name: string;
@@ -16,7 +15,6 @@ declare const _default: {
         insertSorted: typeof insertSorted;
         sortedIndex: typeof sortedIndex;
     };
-    AlternatingIndexGenerator: typeof AlternatingIndexGenerator;
     IterableStreamClosedError: typeof IterableStreamClosedError;
     readToEnd: typeof readToEnd;
     equals: typeof equals;

package/types/packages/core/utils/DomUtils.d.ts

@@ -1,8 +1,11 @@
 import type { ContextWithState } from '../../Types';
-declare function getOrCreateTextTrack(context: ContextWithState, video: HTMLVideoElement, label: string, kind: TextTrackKind, id: string): Promise<TextTrack>;
+export declare class ErrorCreatingTextTrack extends Error {
+    constructor(id: string);
+}
 declare function removeTextTrack(trackId: string): void;
 declare const _default: {
-    getOrCreateTextTrack: typeof getOrCreateTextTrack;
+    getOrCreateTextTrack: import("../../../../framework-types/task/Types").NamedTask<([video, label, kind, id]: [HTMLVideoElement, string, TextTrackKind, string], context: ContextWithState) => TextTrack | import("../../../../framework-types/abortable/Abortable").Abortable<TextTrack>>;
     removeTextTrack: typeof removeTextTrack;
+    ErrorCreatingTextTrack: typeof ErrorCreatingTextTrack;
 };
 export default _default;

package/types/packages/data/Data.package.d.ts

@@ -13,3 +13,5 @@ import type { EmptyObject } from '../../Types';
 import type { DataDependencies, DataExports } from './Types';
 export declare const DataPackage: import("../../../framework-types/package-api/Package").Package<DataDependencies, DataExports, EmptyObject>;
 export default DataPackage;
+
+export declare const version: string;

package/types/packages/data/Types.d.ts

@@ -10,8 +10,10 @@ import type { StateEffect } from '../core/state/state-effect/StateEffectFactory'
 import type { StreamTimelineAtom } from '../core/state/stream-timeline/StreamTimelineMapAtom';
 import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../core/Types';
 import type { CoreUtils } from '../core/utils/Types';
+import type { createNetworkAtom } from '../network/NetworkAtom';
+import type { NetworkMessageType } from '../network/NetworkMessageTypes';
 import type { NetworkTask } from '../network/NetworkTask';
-import type { NetworkExportNames } from '../network/Types';
+import type { HttpRequestMethod, HttpResponseType, NetworkExportNames } from '../network/Types';
 import type SegmentProcessorErrors from '../segment-processing/Errors';
 import type { SegmentProcessingComponent, SegmentProcessingExportNames } from '../segment-processing/Types';
 import type { SourceStateAtom } from '../source/atoms/SourceStateAtom';
@@ -30,6 +32,10 @@ export type DataDependencies = {
     [CoreExportNames.Utils]: CoreUtils;
     [AdaptationExportNames.Metrics]: MetricsAtom;
     [NetworkExportNames.NetworkTask]: typeof NetworkTask;
+    [NetworkExportNames.NetworkMessageType]: typeof NetworkMessageType;
+    [NetworkExportNames.NetworkAtom]: typeof createNetworkAtom;
+    [NetworkExportNames.HttpRequestMethod]: typeof HttpRequestMethod;
+    [NetworkExportNames.HttpResponseType]: typeof HttpResponseType;
     [SegmentProcessingExportNames.SegmentProcessorErrors]: typeof SegmentProcessorErrors;
     [SegmentProcessingExportNames.SegmentProcessingComponent]: SegmentProcessingComponent;
     [AdaptationExportNames.Select]: (tracks: readonly MediaTrackAtom[]) => MediaTrackAtom;

package/types/packages/event-bus/EventBus.package.d.ts

@@ -15,3 +15,5 @@ export type EventBusExports = {
 };
 declare const EventBusPackage: import("../../../framework-types/package-api/Package").Package<EmptyObject, EventBusExports, EmptyObject>;
 export default EventBusPackage;
+
+export declare const version: string;

package/types/packages/manifest/dash/DashManifest.package.d.ts

@@ -1,3 +1,5 @@
 import type { EmptyObject } from '../../../../framework-types/BaseTypes';
 export declare const DashManifestPackage: import("../../../../framework-types/package-api/Package").Package<EmptyObject, EmptyObject, EmptyObject>;
 export default DashManifestPackage;
+
+export declare const version: string;

package/types/packages/manifest/dash/parsing/DashParsing.package.d.ts

@@ -23,3 +23,5 @@ export type DashParsingContext = ContextHaving<{
 }, EmptyObject, BaseContext>;
 export declare const DashParsingPackage: import("../../../../../framework-types/package-api/Package").Package<EmptyObject, DashParsingPackageExports, EmptyObject>;
 export default DashParsingPackage;
+
+export declare const version: string;

package/types/packages/manifest/dash/parsing/Errors.d.ts

@@ -1,4 +1,4 @@
-import { FrameworkError } from '../../../core/FrameworkError';
+import { FrameworkError } from '../../../../../framework-types/error/FrameworkError';
 export declare class DashParsingError extends FrameworkError {
     constructor(message: string);
 }

package/types/packages/manifest/dash/root/Dash.package.d.ts

@@ -13,3 +13,5 @@ import type { EmptyObject } from '../../../../Types';
 import type { DashDependencies, DashExports } from './Types';
 export declare const DashPackage: import("../../../../../framework-types/package-api/Package").Package<DashDependencies, DashExports, EmptyObject>;
 export default DashPackage;
+
+export declare const version: string;

package/types/packages/manifest/dash/root/Types.d.ts

@@ -6,7 +6,7 @@ import type { MetricsAtom } from '../../../core/metrics/MetricsAtom';
 import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../../../core/Types';
 import type { CoreUtils } from '../../../core/utils/Types';
 import type { NetworkTask } from '../../../network/NetworkTask';
-import type { NetworkExportNames } from '../../../network/Types';
+import type { HttpRequestMethod, HttpResponseType, NetworkExportNames } from '../../../network/Types';
 import type { SourceStateAtom } from '../../../source/atoms/SourceStateAtom';
 import type { SourceExportNames } from '../../../source/Types';
 import type { StreamDataStructurePackageExports } from '../../../stream-data-structure/Types';
@@ -28,6 +28,8 @@ export type DashDependencies = {
     [SourceExportNames.SourceState]: SourceStateAtom;
     [AdaptationExportNames.Metrics]: MetricsAtom;
     [NetworkExportNames.NetworkTask]: typeof NetworkTask;
+    [NetworkExportNames.HttpRequestMethod]: typeof HttpRequestMethod;
+    [NetworkExportNames.HttpResponseType]: typeof HttpResponseType;
     [DashParsingExportNames.ParsingTask]: typeof DashParsingTask;
     [DashTranslationExportNames.DashTranslator]: typeof DashPlaylistTranslatorTask;
 } & StreamDataStructurePackageExports & StreamingState & DashTechState;

package/types/packages/manifest/dash/technology/DashManifestTechnology.package.d.ts

@@ -9,3 +9,5 @@ import type { EmptyObject } from '../../../../Types';
 import type { DashManifestTechnologyDependencies } from './Types';
 export declare const DashManifestTechnologyPackage: import("../../../../../framework-types/package-api/Package").Package<DashManifestTechnologyDependencies, import("../../../../../framework-types/BaseTypes").EmptyObject, EmptyObject>;
 export default DashManifestTechnologyPackage;
+
+export declare const version: string;

package/types/packages/manifest/dash/technology/Types.d.ts

@@ -3,7 +3,7 @@ import type { ContextHaving } from '../../../../../framework-types/execution-con
 import type { Constants } from '../../../core/Constants';
 import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../../../core/Types';
 import type { CoreUtils } from '../../../core/utils/Types';
-import type { ManifestTechnologyEntry, PlaybackTechnologyComponent } from '../../../playback-technology/Types';
+import type { ManifestTechnologyEntry, PlaybackTechnologyComponent, PlaybackTechnologyEntryType, PlaybackTechnologyExportNames } from '../../../playback-technology/Types';
 import type { Resource } from '../../../source/atoms/SourceConfigAtom';
 import type { StreamDataStructureStream } from '../../../stream-data-structure/stream/Exports';
 import type { createStreamingStateAtom, StreamingStateAtom } from '../../../streaming/atoms/StreamingStateAtom';
@@ -20,6 +20,7 @@ export interface DashTechStateData {
 export type DashManifestTechnologyExports = EmptyObject;
 export type DashManifestTechnologyDependencies = {
     [PlaybackTechnologyComponent]: PlaybackTechnologyComponent;
+    [PlaybackTechnologyExportNames.EntryType]: typeof PlaybackTechnologyEntryType;
     [CoreExportNames.Constants]: Constants;
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
     [CoreExportNames.CoreEffects]: CoreEffects;

package/types/packages/manifest/dash/translation/DashTranslation.package.d.ts

@@ -10,3 +10,5 @@ import type { EmptyObject } from '../../../../Types';
 import type { DashTranslationPackageDependencies, DashTranslationPackageExports } from './Types';
 export declare const DashTranslationPackage: import("../../../../../framework-types/package-api/Package").Package<DashTranslationPackageDependencies, DashTranslationPackageExports, EmptyObject>;
 export default DashTranslationPackage;
+
+export declare const version: string;

package/types/packages/manifest/hls/HlsManifest.package.d.ts

@@ -1,3 +1,5 @@
 import type { EmptyObject } from '../../../../framework-types/BaseTypes';
 export declare const HlsManifestPackage: import("../../../../framework-types/package-api/Package").Package<EmptyObject, EmptyObject, EmptyObject>;
 export default HlsManifestPackage;
+
+export declare const version: string;

package/types/packages/manifest/hls/parsing/Constants.d.ts

@@ -0,0 +1,47 @@
+export declare enum HlsEncryptionMethod {
+    NONE = "NONE",
+    AES_128 = "AES-128",
+    SAMPLE_AES = "SAMPLE-AES"
+}
+export declare enum MetadataType {
+        CUETAG = "CUETAG",
+        DATERANGE = "DATERANGE",
+        CUSTOM = "CUSTOM",
+        SCTE = "SCTE",
+        ID3 = "ID3",
+        EMSG = "EMSG"
+}
+export declare enum TagType {
+    M3u = "m3u",
+    AllowCache = "allow-cache",
+    ByteRange = "byterange",
+    EndList = "endlist",
+    Inf = "inf",
+    Key = "key",
+    MediaSequence = "media-sequence",
+    DiscontinuitySequence = "discontinuity-sequence",
+    PlaylistType = "playlist-type",
+    StreamInf = "stream-inf",
+    IframeStreamInf = "i-frame-stream-inf",
+    Media = "media",
+    Start = "start",
+    Discontinuity = "discontinuity",
+    DateTime = "date-time",
+    TargetDuration = "targetduration",
+    Map = "map",
+    IndependentSegments = "independent-segments",
+    SessionData = "session-data",
+    SessionKey = "session-key",
+    CueOut = "cue-out",
+    CueOutCont = "cue-out-cont",
+    CueIn = "cue-in",
+    Scte35 = "scte35",
+    DateRange = "daterange",
+    Version = "version",
+    Uri = "uri",
+    Unknown = "unknown"
+}
+export declare enum PlaylistType {
+    Vod = "VOD",
+    Event = "EVENT"
+}

package/types/packages/manifest/hls/parsing/Errors.d.ts

@@ -1,4 +1,4 @@
-import { FrameworkError } from '../../../core/FrameworkError';
+import { FrameworkError } from '../../../../../framework-types/error/FrameworkError';
 export declare class HlsParsingError extends FrameworkError {
     constructor(message: string);
 }

package/types/packages/manifest/hls/parsing/HlsParsing.package.d.ts

@@ -26,3 +26,5 @@ export type HlsParsingContext = ContextHaving<{
 }, EmptyObject, BaseContext>;
 export declare const HlsParsingPackage: import("../../../../../framework-types/package-api/Package").Package<EmptyObject, HlsParsingPackageExports, EmptyObject>;
 export default HlsParsingPackage;
+
+export declare const version: string;