@bitmovin/player-web-x 10.2.0-beta.13 → 10.2.0-beta.15

package/types/packages/advertising/base/AdQuartile.d.ts

@@ -0,0 +1,5 @@
+export declare enum AdQuartile {
+    FirstQuartile = "first-quartile",
+    Midpoint = "midpoint",
+    ThirdQuartile = "third-quartile"
+}

package/types/packages/advertising/base/AdResource.d.ts

@@ -0,0 +1,16 @@
+export declare enum AdResourceType {
+    Static = "static",
+    Iframe = "iframe",
+    Html = "html"
+}
+export type AdResource = {
+    type: AdResourceType.Static;
+    url: string;
+    creativeType: string;
+} | {
+    type: AdResourceType.Iframe;
+    url: string;
+} | {
+    type: AdResourceType.Html;
+    markup: string;
+};

package/types/packages/advertising/base/AdSchedule.d.ts

@@ -1,3 +1,3 @@
 import type { ArrayAtom } from '../../core/state/ArrayStateAtom';
-import type { BaseAdBreakAtom } from './BaseAdBreakAtom';
-export type AdSchedule = ArrayAtom<BaseAdBreakAtom>;
+import type { BaseAdPodAtom } from './BaseAdPodAtom';
+export type AdSchedule = ArrayAtom<BaseAdPodAtom>;

package/types/packages/advertising/base/AdTagAtom.d.ts

@@ -1,7 +1,7 @@
 import type { EmptyObject } from '../../../../framework-types/BaseTypes';
 import type { StateAtom } from '../../core/state/Types';
 import type { ContextWithState } from '../../Types';
-import type { AdType } from './Types';
+import type { AdType } from './AdType';
 type AdTag = {
     type: AdType;
     url: string;

package/types/packages/advertising/base/AdType.d.ts

@@ -0,0 +1,4 @@
+export declare enum AdType {
+    VAST = "vast",
+    VMAP = "vmap"
+}

package/types/packages/advertising/base/BaseAdAtom.d.ts

@@ -1,22 +1,44 @@
 import type { EmptyObject } from '../../../../framework-types/BaseTypes';
+import type { ArrayAtom } from '../../core/state/ArrayStateAtom';
 import type { PrimitiveAtom } from '../../core/state/PrimitiveAtom';
 import type { StateAtom } from '../../core/state/Types';
 import type { Transient } from '../../core/utils/StateUtils';
+import type { AdExtension } from './AdExtension';
+import type { AdIconAtom } from './AdIconAtom';
 import type { AdPosition } from './AdPosition';
-import type { AdQuartile, AdvertisingBaseContext } from './Types';
-import { BaseAdState } from './Types';
+import type { AdQuartile } from './AdQuartile';
+import { BaseAdState } from './BaseAdState';
+import type { ClickThroughAtom } from './ClickThroughAtom';
+import type { CompanionAdAtom } from './CompanionAdAtom';
+import type { AdvertisingBaseContext } from './Types';
 type AdState = {
     id: string;
+    externalAdId: string;
     position: AdPosition;
-    isSkippable: PrimitiveAtom<boolean>;
     skipDelay: PrimitiveAtom<number>;
     quartile: PrimitiveAtom<AdQuartile | undefined>;
     state: PrimitiveAtom<BaseAdState>;
     error: PrimitiveAtom<Error | undefined>;
     sourcePreloadOffset: PrimitiveAtom<number>;
+    isLinear: PrimitiveAtom<boolean>;
+    canPause: PrimitiveAtom<boolean>;
+    paused: PrimitiveAtom<boolean>;
+    play: Transient<void>;
+    pause: Transient<void>;
+    canSkip: PrimitiveAtom<boolean>;
     skip: Transient<void>;
-    clicked: Transient<string | undefined>;
+    canSetVolume: PrimitiveAtom<boolean>;
+    volume: PrimitiveAtom<number>;
+    canExpand: PrimitiveAtom<boolean>;
+    expanded: PrimitiveAtom<boolean>;
+    hasTimeline: PrimitiveAtom<boolean>;
+    duration: PrimitiveAtom<number>;
+    currentTime: PrimitiveAtom<number>;
+    clickThrough: ClickThroughAtom | undefined;
+    companions: ArrayAtom<CompanionAdAtom>;
+    icons: ArrayAtom<AdIconAtom>;
+    extensions: ArrayAtom<AdExtension>;
 };
 export type BaseAdAtom = StateAtom<AdState, EmptyObject>;
-export declare function createBaseAdAtom(context: AdvertisingBaseContext, id: string, position: AdPosition, adSkipDelay: number, preloadOffset: number): BaseAdAtom;
+export declare function createBaseAdAtom(context: AdvertisingBaseContext, id: string, externalAdId: string, position: AdPosition, adSkipDelay: number, preloadOffset: number, clickThrough: ClickThroughAtom | undefined, initialCompanions: CompanionAdAtom[], initialIcons: AdIconAtom[], initialExtensions: AdExtension[]): BaseAdAtom;
 export {};

package/types/packages/advertising/base/{BaseAdBreakAtom.d.ts → BaseAdPodAtom.d.ts}

@@ -8,22 +8,24 @@ import { CoreExportNames } from '../../core/Types';
 import type { ContextWithState } from '../../Types';
 import type { AdPosition } from './AdPosition';
 import type { AdTagAtom } from './AdTagAtom';
+import type { AdType } from './AdType';
 import type { BaseAdAtom } from './BaseAdAtom';
+import type { BaseAdPodState } from './BaseAdPodState';
 import type { PreloadConfigAtom } from './PreloadConfigAtom';
-import type { AdType } from './Types';
-import { BaseAdBreakState } from './Types';
-type BaseAdBreak = {
+import { AdvertisingBaseExportNames } from './Types';
+type BaseAdPod = {
     id: string;
     position: AdPosition;
     tag: AdTagAtom;
-    state: PrimitiveAtom<BaseAdBreakState>;
+    state: PrimitiveAtom<BaseAdPodState>;
     ads: ArrayAtom<BaseAdAtom>;
     preloadConfig: PreloadConfigAtom;
     error: PrimitiveAtom<Error | undefined>;
 };
-export type BaseAdBreakAtom = StateAtom<BaseAdBreak, EmptyObject>;
+export type BaseAdPodAtom = StateAtom<BaseAdPod, EmptyObject>;
 type Context = ContextHaving<{
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
+    [AdvertisingBaseExportNames.BaseAdPodState]: typeof BaseAdPodState;
 }, EmptyObject, ContextWithState>;
-export declare function createBaseAdBreakAtom(context: Context, id: string, scheduledPosition: string | number | undefined, tagType: AdType, url: string, adManifestPreloadOffset?: number, adSourcePreloadOffset?: number): BaseAdBreakAtom;
+export declare function createBaseAdPodAtom(context: Context, id: string, scheduledPosition: string | number | undefined, tagType: AdType, url: string, adManifestPreloadOffset?: number, adSourcePreloadOffset?: number): BaseAdPodAtom;
 export {};

package/types/packages/advertising/base/BaseAdPodState.d.ts

@@ -0,0 +1,7 @@
+export declare enum BaseAdPodState {
+    Scheduled = "scheduled",
+    Loaded = "loaded",
+    Playing = "playing",
+    Error = "error",
+    Completed = "completed"
+}

package/types/packages/advertising/base/BaseAdState.d.ts

@@ -0,0 +1,7 @@
+export declare enum BaseAdState {
+    Scheduled = "scheduled",
+    Playing = "playing",
+    Completed = "completed",
+    Skipped = "skipped",
+    Error = "error"
+}

package/types/packages/advertising/base/ClickThroughAtom.d.ts

@@ -0,0 +1,11 @@
+import type { EmptyObject } from '../../../../framework-types/BaseTypes';
+import type { StateAtom } from '../../core/state/Types';
+import type { Transient } from '../../core/utils/StateUtils';
+import type { AdvertisingBaseContext } from './Types';
+type ClickThroughState = {
+    url: string;
+    clicked: Transient<void>;
+};
+export type ClickThroughAtom = StateAtom<ClickThroughState, EmptyObject>;
+export declare function createClickThroughAtom(context: AdvertisingBaseContext, url: string): ClickThroughAtom;
+export {};

package/types/packages/advertising/base/CompanionAdAtom.d.ts

@@ -0,0 +1,18 @@
+import type { EmptyObject } from '../../../../framework-types/BaseTypes';
+import type { StateAtom } from '../../core/state/Types';
+import type { Transient } from '../../core/utils/StateUtils';
+import type { AdResource } from './AdResource';
+import type { ClickThroughAtom } from './ClickThroughAtom';
+import type { AdvertisingBaseContext } from './Types';
+type CompanionAdState = {
+    id: string;
+    width: number;
+    height: number;
+    resource: AdResource;
+    altText: string | undefined;
+    clickThrough: ClickThroughAtom | undefined;
+    shown: Transient<void>;
+};
+export type CompanionAdAtom = StateAtom<CompanionAdState, EmptyObject>;
+export declare function createCompanionAdAtom(context: AdvertisingBaseContext, id: string, width: number, height: number, resource: AdResource, altText: string | undefined, clickThrough: ClickThroughAtom | undefined): CompanionAdAtom;
+export {};

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

@@ -4,32 +4,16 @@ import type { CoreUtils } from '../../core/utils/Types';
 import type { SourceStateAtom } from '../../source/atoms/SourceStateAtom';
 import type { SourceExportNames } from '../../source/Types';
 import type { ContextWithState } from '../../Types';
+import type { AdExtensionSource } from './AdExtension';
+import type { isAdPositionKnown } from './AdPosition';
+import type { AdQuartile } from './AdQuartile';
 import type { AdSchedule } from './AdSchedule';
+import type { AdType } from './AdType';
 import type { BaseAdAtom, createBaseAdAtom } from './BaseAdAtom';
-import type { createBaseAdBreakAtom } from './BaseAdBreakAtom';
-export declare enum AdType {
-    VAST = "vast",
-    VMAP = "vmap"
-}
-export declare enum AdQuartile {
-    FirstQuartile = "first-quartile",
-    Midpoint = "midpoint",
-    ThirdQuartile = "third-quartile"
-}
-export declare enum BaseAdBreakState {
-    Scheduled = "scheduled",
-    Loaded = "loaded",
-    Playing = "playing",
-    Error = "error",
-    Completed = "completed"
-}
-export declare enum BaseAdState {
-    Scheduled = "scheduled",
-    Playing = "playing",
-    Completed = "completed",
-    Skipped = "skipped",
-    Error = "error"
-}
+import type { createBaseAdPodAtom } from './BaseAdPodAtom';
+import type { BaseAdPodState } from './BaseAdPodState';
+import type { BaseAdState } from './BaseAdState';
+import type { createClickThroughAtom } from './ClickThroughAtom';
 export type AdvertisingBasePackageDependencies = {
     [CoreExportNames.CoreEffects]: CoreEffects;
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
@@ -39,18 +23,24 @@ export type AdvertisingBasePackageDependencies = {
 export declare enum AdvertisingBaseExportNames {
     AdType = "ad-type",
     AdQuartile = "ad-quartile",
-    BaseAdBreakState = "base-ad-break-state",
+    AdExtensionSource = "ad-extension-source",
+    BaseAdPodState = "base-ad-pod-state",
     BaseAdState = "base-ad-state",
-    CreateBaseAdBreak = "create-base-ad-break",
-    CreateBaseAd = "create-base-ad"
+    CreateBaseAdPod = "create-base-ad-pod",
+    CreateBaseAd = "create-base-ad",
+    CreateClickThrough = "create-click-through",
+    IsAdPositionKnown = "is-position-known"
 }
 export type AdvertisingBasePackageExports = {
     [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 AdvertisingBaseContext = ContextHaving<AdvertisingBasePackageDependencies, AdvertisingBasePackageExports, ContextWithState>;
 export declare enum ContentSourceExportNames {

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/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;

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;

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;

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/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/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/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/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/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/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"
+}