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

package/types/packages/playback/play-pause/Types.d.ts

@@ -4,8 +4,6 @@ import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../../core/Ty
 import type { SourceStateAtom } from '../../source/atoms/SourceStateAtom';
 import type { SourceExportNames } from '../../source/Types';
 import type { ContextWithState } from '../../Types';
-import type { VideoElementStateExportNames } from '../video-element-state/Types';
-import type { VideoElementStateAtom } from '../video-element-state/VideoElementStateAtom';
 import type { TargetPlaybackState, TargetPlaybackStateAtom } from './TargetPlaybackStateAtom';
 export declare enum PlayPauseExportNames {
     TargetPlaybackStateAtom = "target-playback-state-atom",
@@ -15,7 +13,6 @@ export type PlayPausePackageDependencies = {
     [SourceExportNames.SourceState]: SourceStateAtom;
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
     [CoreExportNames.CoreEffects]: CoreEffects;
-    [VideoElementStateExportNames.VideoElementState]: VideoElementStateAtom;
 };
 export type PlayPausePackageApi = EmptyObject;
 export type PlayPausePackageExports = {

package/types/packages/playback/volume/Types.d.ts

@@ -3,17 +3,15 @@ import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../../core/Ty
 import type { SourceStateAtom } from '../../source/atoms/SourceStateAtom';
 import type { SourceExportNames } from '../../source/Types';
 import type { ContextWithState } from '../../Types';
-import type { VideoElementStateExportNames } from '../video-element-state/Types';
-import type { VideoElementStateAtom } from '../video-element-state/VideoElementStateAtom';
 import type { TargetVolumeStateAtom } from './TargetVolumeStateAtom';
 export declare const TargetVolumeState = "target-volume-state";
-export type VolumePackageExports = {
+export type TargetVolumeState = {
     [TargetVolumeState]: TargetVolumeStateAtom;
 };
+export type VolumePackageExports = TargetVolumeState;
 export type VolumePackageDependencies = {
     [CoreExportNames.CoreEffects]: CoreEffects;
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
     [SourceExportNames.SourceState]: SourceStateAtom;
-    [VideoElementStateExportNames.VideoElementState]: VideoElementStateAtom;
 };
 export type VolumePackageContext = ContextHaving<VolumePackageDependencies, VolumePackageExports, ContextWithState>;

package/types/packages/playback-api/play-pause-api/Types.d.ts

@@ -2,10 +2,10 @@ import type { ApiManager } from '../../../../framework-types/api-manager/ApiMana
 import type { EmptyObject } from '../../../../framework-types/BaseTypes';
 import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
 import type { CoreEffects, CoreExportNames } from '../../core/Types';
+import type { MediaStateAtom } from '../../media-state/MediaStateAtom';
+import type { MediaState, MediaStateExportNames } from '../../media-state/Types';
 import type { TargetPlaybackState, TargetPlaybackStateAtom } from '../../playback/play-pause/TargetPlaybackStateAtom';
 import type { PlayPauseExportNames } from '../../playback/play-pause/Types';
-import type { VideoElementStateExportNames } from '../../playback/video-element-state/Types';
-import type { VideoElementStateAtom } from '../../playback/video-element-state/VideoElementStateAtom';
 import type { SourcesApiExportNames } from '../../sources-api/Types';
 import type { ContextWithState } from '../../Types';
 export type PlayPauseApi = {
@@ -17,7 +17,8 @@ export type PlayPauseApiPackageDependencies = {
     [PlayPauseExportNames.TargetPlaybackState]: typeof TargetPlaybackState;
     [PlayPauseExportNames.TargetPlaybackStateAtom]: TargetPlaybackStateAtom;
     [SourcesApiExportNames.SourceApiManager]: ApiManager<PlayPauseApi>;
-    [VideoElementStateExportNames.VideoElementState]: VideoElementStateAtom;
+    [MediaStateExportNames.MediaStateAtom]: MediaStateAtom;
+    [MediaStateExportNames.MediaState]: typeof MediaState;
 };
 export type PlayPauseApiPackageExports = EmptyObject;
 export type PlayPauseApiPackageContext = ContextHaving<PlayPauseApiPackageDependencies, PlayPauseApiPackageExports, ContextWithState>;

package/types/packages/playback-api/playback-api-events/Types.d.ts

@@ -1,11 +1,12 @@
 import type { ApiManager } from '../../../../framework-types/api-manager/ApiManager';
 import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
-import type { CoreEffects, CoreExportNames } from '../../core/Types';
+import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../../core/Types';
+import type { CoreUtils } from '../../core/utils/Types';
 import type { extendEventBusTypes } from '../../event-bus/EventBus';
 import type { EventBus, EventBusExportNames } from '../../event-bus/Types';
-import type { PlaybackState, PlaybackStateMachineAtom, PlaybackStatePackageExportNames } from '../../playback/playback-state/Types';
-import type { VideoElementStateExportNames } from '../../playback/video-element-state/Types';
-import type { VideoElementStateAtom } from '../../playback/video-element-state/VideoElementStateAtom';
+import type { MediaInfo } from '../../media-state/MediaInfoAtoms';
+import type { MediaStateAtom } from '../../media-state/MediaStateAtom';
+import type { MediaState, MediaStateExportNames } from '../../media-state/Types';
 import type { SourceStateAtom } from '../../source/atoms/SourceStateAtom';
 import type { SourceExportNames } from '../../source/Types';
 import type { SourcesApiExportNames } from '../../sources-api/Types';
@@ -13,13 +14,15 @@ import type { ContextWithState } from '../../Types';
 import type { PlaybackEvent, PlaybackEventMap } from './events/PlaybackEventMap';
 export type PlaybackApiEventsPackageDependencies = {
     [CoreExportNames.CoreEffects]: CoreEffects;
+    [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
+    [CoreExportNames.Utils]: CoreUtils;
     [EventBusExportNames.ExtendEventBusTypes]: typeof extendEventBusTypes;
-    [PlaybackStatePackageExportNames.PlaybackState]: typeof PlaybackState;
-    [PlaybackStatePackageExportNames.PlaybackStateMachine]: PlaybackStateMachineAtom;
+    [MediaStateExportNames.MediaStateAtom]: MediaStateAtom;
+    [MediaStateExportNames.MediaState]: typeof MediaState;
+    [MediaStateExportNames.MediaInfo]: MediaInfo;
     [SourcesApiExportNames.SourceEventBus]: EventBus<PlaybackEventMap>;
     [SourcesApiExportNames.SourceApiManager]: ApiManager<PlaybackStateApi>;
     [SourceExportNames.SourceState]: SourceStateAtom;
-    [VideoElementStateExportNames.VideoElementState]: VideoElementStateAtom;
 };
 export declare enum PlaybackApiEventsPackageExportNames {
     PlaybackEvent = "playback-event"
@@ -29,5 +32,5 @@ export type PlaybackApiEventsPackageExports = {
 };
 export type PlaybackApiEventsPackageContext = ContextHaving<PlaybackApiEventsPackageDependencies, PlaybackApiEventsPackageExports, ContextWithState>;
 export type PlaybackStateApi = {
-    readonly state: PlaybackState;
+    readonly state: MediaState;
 };

package/types/packages/playback-api/time-api/Types.d.ts

@@ -3,8 +3,8 @@ import type { ContextHaving } from '../../../../framework-types/execution-contex
 import type { ArrayAtom } from '../../core/state/ArrayStateAtom';
 import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../../core/Types';
 import type { CoreUtils } from '../../core/utils/Types';
-import type { VideoElementStateExportNames } from '../../playback/video-element-state/Types';
-import type { VideoElementStateAtom } from '../../playback/video-element-state/VideoElementStateAtom';
+import type { MediaInfo } from '../../media-state/MediaInfoAtoms';
+import type { MediaStateExportNames } from '../../media-state/Types';
 import type { SourceStateAtom } from '../../source/atoms/SourceStateAtom';
 import type { SourceExportNames } from '../../source/Types';
 import type { SourcesApiExportNames } from '../../sources-api/Types';
@@ -24,7 +24,7 @@ export type TimeApiPackageDependencies = {
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
     [CoreExportNames.CoreEffects]: CoreEffects;
     [CoreExportNames.Utils]: CoreUtils;
-    [VideoElementStateExportNames.VideoElementState]: VideoElementStateAtom;
+    [MediaStateExportNames.MediaInfo]: MediaInfo;
     [SourceExportNames.SourceState]: SourceStateAtom;
     [SourcesApiExportNames.SourceApiManager]: ApiManager<TimeApi>;
 };
@@ -32,5 +32,4 @@ export declare const SeekableRangeProviders = "seekable-range-providers";
 export type SeekableRangeProviders = {
     [SeekableRangeProviders]: ArrayAtom<SeekableRangeProviderAtom>;
 };
-export type TimeApiPackageExports = SeekableRangeProviders;
-export type TimeApiPackageContext = ContextHaving<TimeApiPackageDependencies, TimeApiPackageExports, ContextWithState>;
+export type TimeApiPackageContext = ContextHaving<TimeApiPackageDependencies, SeekableRangeProviders, ContextWithState>;

package/types/packages/playback-technology/PlaybackTechnologyEntryType.d.ts

@@ -0,0 +1,4 @@
+export declare enum PlaybackTechnologyEntryType {
+    Presentation = "presentation",
+    Manifest = "manifest"
+}

package/types/packages/playback-technology/Types.d.ts

@@ -9,12 +9,8 @@ import type { Resource } from '../source/atoms/SourceConfigAtom';
 import type { SourceStateAtom } from '../source/atoms/SourceStateAtom';
 import type { SourceExportNames } from '../source/Types';
 import type { ContextWithState } from '../Types';
-export declare enum PlaybackTechnologyEntryType {
-    Presentation = "presentation",
-    Manifest = "manifest"
-}
-export declare function isManifestEntry(entry: TechnologyEntry): entry is ManifestTechnologyEntry;
-export declare function isPresentationEntry(entry: TechnologyEntry): entry is PresentationTechnologyEntry;
+import type { PlaybackTechnologyEntryType } from './PlaybackTechnologyEntryType';
+export type { PlaybackTechnologyEntryType } from './PlaybackTechnologyEntryType';
 export interface TechnologyEntryBase<Exports extends AnyRecord = EmptyObject> {
         type: PlaybackTechnologyEntryType;
         name: string;
@@ -49,6 +45,10 @@ export interface PlaybackTechnologyComponent {
         addTechnology: NamedTask<Task<BaseContext, TechnologyEntry<AnyRecord>, void>>;
 }
 export declare const PlaybackTechnologyComponent = "playback-technology-component";
+export declare enum PlaybackTechnologyExportNames {
+    EntryType = "playback-technology-entry-type"
+}
 export type PlaybackTechnologyExports = {
     [PlaybackTechnologyComponent]: PlaybackTechnologyComponent;
+    [PlaybackTechnologyExportNames.EntryType]: typeof PlaybackTechnologyEntryType;
 };

package/types/packages/player-api/PlayerApi.package.d.ts

@@ -13,6 +13,7 @@ import type { BaseContext } from '../../../framework-types/Types';
 import type { createEventBus, extendEventBusTypes } from '../event-bus/EventBus';
 import type { EventBus } from '../event-bus/Types';
 import { EventBusExportNames } from '../event-bus/Types';
+import { PlayerEvent } from './PlayerEvent';
 import type { PlayerApi, PlayerEventMap } from './Types';
 import { PlayerApiExportNames } from './Types';
 type PlayerApiDependencies = {
@@ -21,6 +22,7 @@ type PlayerApiDependencies = {
 };
 type PlayerApiExports = {
     [PlayerApiExportNames.PlayerEventBus]: EventBus<PlayerEventMap>;
+    [PlayerApiExportNames.PlayerEvent]: typeof PlayerEvent;
 };
 export type PlayerApiContext = ContextHaving<PlayerApiDependencies, PlayerApiExports, BaseContext>;
 declare const PlayerApiPackage: import("../../../framework-types/package-api/Package").Package<PlayerApiDependencies, PlayerApiExports, PlayerApi>;

package/types/packages/player-api/PlayerEvent.d.ts

@@ -0,0 +1,3 @@
+export declare enum PlayerEvent {
+    PlayerError = "player-error"
+}

package/types/packages/player-api/Types.d.ts

@@ -1,10 +1,10 @@
 import type { LogLevel, OnLogCallback } from '../../../framework-types/effects/LoggerEffect';
 import type { EventBus } from '../event-bus/Types';
+import type { PlayerEvent } from './PlayerEvent';
+export type { PlayerEvent } from './PlayerEvent';
 export declare enum PlayerApiExportNames {
-    PlayerEventBus = "player-event-bus"
-}
-export declare enum PlayerEvent {
-    PlayerError = "player-error"
+    PlayerEventBus = "player-event-bus",
+    PlayerEvent = "player-event"
 }
 export type PlayerErrorEvent = {
     message: string;

package/types/packages/presentation/mse/playback-technology/Types.d.ts

@@ -3,7 +3,7 @@ import type { ContextHaving } from '../../../../../framework-types/execution-con
 import type { CapabilitiesExportNames, PlatformCapabilities } from '../../../capabilities/Types';
 import type { Constants } from '../../../core/Constants';
 import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../../../core/Types';
-import type { PlaybackTechnologyComponent, PresentationTechnologyEntry } from '../../../playback-technology/Types';
+import type { PlaybackTechnologyComponent, PlaybackTechnologyEntryType, PlaybackTechnologyExportNames, PresentationTechnologyEntry } from '../../../playback-technology/Types';
 import type { Resource } from '../../../source/atoms/SourceConfigAtom';
 import type { ContextWithState } from '../../../Types';
 import type { MsePresentationStateAtom } from './atoms/MsePresentationStateAtom';
@@ -17,6 +17,7 @@ export interface MsePresentationStateData {
 export type MsePlaybackTechnologyExports = EmptyObject;
 export type MsePlaybackTechnologyDependencies = {
     [PlaybackTechnologyComponent]: PlaybackTechnologyComponent;
+    [PlaybackTechnologyExportNames.EntryType]: typeof PlaybackTechnologyEntryType;
     [CoreExportNames.Constants]: Constants;
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
     [CoreExportNames.CoreEffects]: CoreEffects;

package/types/packages/presentation/mse/playback-technology/atoms/MsePresentationStateAtom.d.ts

@@ -1,10 +1,7 @@
 import type { EmptyObject } from '../../../../../../framework-types/BaseTypes';
-import type { ContextHaving } from '../../../../../../framework-types/execution-context/Types';
 import type { StateAtom } from '../../../../core/state/Types';
 import type { Resource } from '../../../../source/atoms/SourceConfigAtom';
 import type { ContextWithState } from '../../../../Types';
 import type { MsePresentationStateData } from '../Types';
 export type MsePresentationStateAtom = StateAtom<MsePresentationStateData, EmptyObject>;
-type ExtendedContext = ContextHaving<EmptyObject, EmptyObject, ContextWithState>;
-export declare function createMsePresentationStateAtom(context: ExtendedContext, resource: Resource): MsePresentationStateAtom;
-export {};
+export declare function createMsePresentationStateAtom(context: ContextWithState, resource: Resource): MsePresentationStateAtom;

package/types/packages/presentation/mse/presentation/MsePresentation.package.d.ts

@@ -18,6 +18,7 @@ import type { NamedTask, Task } from '../../../../../framework-types/task/Types'
 import type { EmptyObject } from '../../../../Types';
 import type { PlatformCapabilities } from '../../../capabilities/Types';
 import { CapabilitiesExportNames } from '../../../capabilities/Types';
+import type { ContainerFormat } from '../../../core/Constants';
 import type { MapStateAtom } from '../../../core/state/MapStateAtom';
 import type { StoreEffectFactory } from '../../../core/state/StoreEffectFactory';
 import type { StreamTimelineAtom } from '../../../core/state/stream-timeline/StreamTimelineMapAtom';
@@ -28,13 +29,13 @@ import type { SegmentProcessingComponent, SegmentProcessorContext, SelectContain
 import { SegmentProcessingExportNames } from '../../../segment-processing/Types';
 import type { SourceState } from '../../../source/atoms/SourceStateAtom';
 import { SourceExportNames } from '../../../source/Types';
-import type { ContainerFormat } from '../../../stream-data-structure/segment/SegmentDataAtom';
 import type { SelectionGroupAtom } from '../../../stream-data-structure/selection-group/SelectionGroupAtom';
 import type { StreamDataStructurePackageExports } from '../../../stream-data-structure/Types';
 import { StreamingState } from '../../../streaming/Types';
 import type { ContextWithState } from '../../../Types';
 import { MsePresentationState } from '../playback-technology/Types';
 import type { SegmentOutputCache } from './cache/Types';
+import type { SegmentDataLayout } from './Types';
 import { MsePresentationExportNames } from './Types';
 type Dependencies = {
     [SourceExportNames.SourceState]: SourceState;
@@ -49,7 +50,8 @@ export type PresentationExports = {
 };
 export type PresentationContext = ContextUsing<[
     StoreEffectFactory<'segmentDataCache', SegmentOutputCache>,
-    StoreEffectFactory<'containerFormatMap', MapStateAtom<SelectionGroupAtom, ContainerFormat>>
+    StoreEffectFactory<'containerFormatMap', MapStateAtom<SelectionGroupAtom, ContainerFormat>>,
+    StoreEffectFactory<'segmentDataLayoutMap', MapStateAtom<SelectionGroupAtom, SegmentDataLayout>>
 ], ContextHaving<Dependencies, PresentationExports, ContextWithState>>;
 export declare const MsePresentationPackage: import("../../../../../framework-types/package-api/Package").Package<Dependencies, PresentationExports, EmptyObject>;
 export default MsePresentationPackage;

package/types/packages/presentation/mse/presentation/Types.d.ts

@@ -1,3 +1,9 @@
+import type { ContainerFormat, MediaType } from '../../../core/Constants';
 export declare enum MsePresentationExportNames {
     SelectContainerFormat = "presentation-select-container-format-task"
 }
+export type SegmentDataLayoutEntry = {
+    containerFormat: ContainerFormat;
+    mediaTypes: readonly MediaType[];
+};
+export type SegmentDataLayout = SegmentDataLayoutEntry[];

package/types/packages/presentation/native/NativePlayback.package.d.ts

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

package/types/packages/presentation/native/playback-technology/Types.d.ts

@@ -3,7 +3,7 @@ import type { ContextHaving } from '../../../../../framework-types/execution-con
 import type { CapabilitiesExportNames, PlatformCapabilities } from '../../../capabilities/Types';
 import type { Constants } from '../../../core/Constants';
 import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../../../core/Types';
-import type { PlaybackTechnologyComponent, PresentationTechnologyEntry } from '../../../playback-technology/Types';
+import type { PlaybackTechnologyComponent, PlaybackTechnologyEntryType, PlaybackTechnologyExportNames, PresentationTechnologyEntry } from '../../../playback-technology/Types';
 import type { Resource } from '../../../source/atoms/SourceConfigAtom';
 import type { ContextWithState } from '../../../Types';
 import type { NativePresentationStateAtom } from './atoms/NativePresentationStateAtom';
@@ -17,6 +17,7 @@ export interface NativePresentationStateData {
 export type NativePlaybackTechnologyExports = EmptyObject;
 export type NativePlaybackTechnologyDependencies = {
     [PlaybackTechnologyComponent]: PlaybackTechnologyComponent;
+    [PlaybackTechnologyExportNames.EntryType]: typeof PlaybackTechnologyEntryType;
     [CoreExportNames.Constants]: Constants;
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
     [CoreExportNames.CoreEffects]: CoreEffects;

package/types/packages/segment-processing/SegmentProcessing.package.d.ts

@@ -15,7 +15,8 @@ import type { SourceStateAtom } from '../source/atoms/SourceStateAtom';
 import { SourceExportNames } from '../source/Types';
 import Errors from './Errors';
 import { createSegmentProcessingComponent } from './SegmentProcessingComponent';
-import { SegmentProcessingExportNames, SegmentProcessorType } from './Types';
+import { SegmentProcessorType } from './SegmentProcessorType';
+import { SegmentProcessingExportNames } from './Types';
 export type SegmentProcessingDependencies = {
     [SourceExportNames.SourceState]: SourceStateAtom;
 };

package/types/packages/segment-processing/SegmentProcessorType.d.ts

@@ -0,0 +1,7 @@
+export declare enum SegmentProcessorType {
+    Decryptor = "decryptor",
+    Parser = "parser",
+    Preprocessor = "preprocessor",
+    Transmuxer = "transmuxer",
+    Postprocessor = "postprocessor"
+}

package/types/packages/segment-processing/Types.d.ts

@@ -1,7 +1,7 @@
 import type { ContextHaving, ContextUsing } from '../../../framework-types/execution-context/Types';
 import type { NamedTask, Task } from '../../../framework-types/task/Types';
 import type { EmptyObject } from '../../Types';
-import type { Constants, MediaType } from '../core/Constants';
+import type { Constants, ContainerFormat, MediaType } from '../core/Constants';
 import type { EventListenerEffect } from '../core/effects/EventListenerEffectFactory';
 import type { DataStreamAtom } from '../core/state/data-stream/DataStreamAtom';
 import type { CoreExportNames, CoreStateAtoms } from '../core/Types';
@@ -9,9 +9,11 @@ import type { Transient } from '../core/utils/StateUtils';
 import type { CoreUtils } from '../core/utils/Types';
 import type { StreamDataStructureSegments } from '../stream-data-structure/segment/Exports';
 import type { SegmentAtom } from '../stream-data-structure/segment/SegmentAtom';
-import type { ContainerFormat, SegmentDataAtom } from '../stream-data-structure/segment/SegmentDataAtom';
+import type { SegmentDataAtom } from '../stream-data-structure/segment/SegmentDataAtom';
 import type { ContextWithState } from '../Types';
 import type Errors from './Errors';
+import type { SegmentProcessorType } from './SegmentProcessorType';
+export type { SegmentProcessorType } from './SegmentProcessorType';
 type ProcessorDependencies = {
     [CoreExportNames.Utils]: CoreUtils;
     [CoreExportNames.Constants]: Constants;
@@ -29,13 +31,10 @@ export type SegmentProcessorContext = ContextUsing<[
 export type CodecMap = {
     [key in MediaType]?: string[];
 };
-export declare enum SegmentProcessorType {
-    Decryptor = "decryptor",
-    Parser = "parser",
-    Preprocessor = "preprocessor",
-    Transmuxer = "transmuxer",
-    Postprocessor = "postprocessor"
-}
+export type VideoInfo = {
+    width: number;
+    height: number;
+};
 type BaseProcessorData<I, O> = {
     segment: SegmentAtom;
     input: DataStreamAtom<I>;
@@ -54,6 +53,7 @@ export type SegmentDecryptor = BaseSegmentProcessor<SegmentDecryptorData> & {
 export type SegmentParserData = BaseProcessorData<Uint8Array, SegmentDataAtom> & {
     segment: SegmentAtom;
     codecsExtracted: Transient<CodecMap>;
+    videoInfoExtracted: Transient<VideoInfo>;
     playbackTimeExtracted: Transient<number>;
     durationExtracted: Transient<number>;
 };
@@ -90,6 +90,7 @@ export type SegmentProcessingComponentData = BaseProcessorData<Uint8Array, Segme
     codecsExtracted: Transient<{
         [key in MediaType]?: string[];
     }>;
+    videoInfoExtracted: Transient<VideoInfo>;
     playbackTimeExtracted: Transient<number>;
     durationExtracted: Transient<number>;
     selectContainerFormat: SelectContainerFormatTask;
@@ -98,4 +99,3 @@ export interface SegmentProcessingComponent {
     addProcessor(processor: SegmentProcessor): RemoveProcessor;
     process: NamedTask<Task<SegmentProcessorContext, SegmentProcessingComponentData, void>>;
 }
-export {};

package/types/packages/source/SourceReference.d.ts

@@ -20,7 +20,7 @@ type ExtendedContext = ContextHaving<{
 type CreateSourceReferenceParam = {
     context?: ExtendedContext;
     sourceConfig: SourceConfig;
-    sourceOptions?: Partial<SourceOptions>;
+    sourceOptions: SourceOptions;
     sourceErrorHandler?: (error: Error) => boolean;
     task?: NamedTask<Task<ExtendedContext, void, void>>;
     sourceId?: string;

package/types/packages/source/atoms/PlaybackConfigAtom.d.ts

@@ -1,8 +1,8 @@
 import type { PlaybackConfig } from '../../../bundles/Types';
 import type { ContextWithState } from '../../Types';
 export type PlaybackConfigAtom = ReturnType<typeof createPlaybackConfigAtom>;
-export declare const createPlaybackConfigAtom: (context: ContextWithState, options: PlaybackConfig | undefined) => import("../../core/state/Types").StateAtom<{
-    autoplay: boolean;
+export declare const createPlaybackConfigAtom: (context: ContextWithState, options: PlaybackConfig) => import("../../core/state/Types").StateAtom<{
     muted: boolean;
+    autoplay: boolean;
     preventSeeking: boolean;
 }, {}>;

package/types/packages/source/atoms/SourceConfigAtom.d.ts

@@ -1,11 +1,13 @@
 import type { EmptyObject } from '../../../../framework-types/BaseTypes';
 import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
 import type { Constants, ContentType, ResourceType } from '../../core/Constants';
+import type { CoreStateAtoms } from '../../core/Types';
 import { CoreExportNames } from '../../core/Types';
 import type { ContextWithState } from '../../Types';
 export type SourceConfigAtom = ReturnType<typeof createSourceConfigAtom>;
 type ExtendedContext = ContextHaving<{
     [CoreExportNames.Constants]: Constants;
+    [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;
 }, EmptyObject, ContextWithState>;
 export interface Resource {
     url: string;

package/types/packages/sources-api/SourcesApiEvent.d.ts

@@ -0,0 +1,7 @@
+export declare enum SourcesApiEvent {
+    SourceAdded = "source-added",
+    SourceRemoved = "source-removed",
+    VideoAttached = "video-attached",
+    VideoDetached = "video-detached",
+    SourceError = "source-error"
+}

package/types/packages/sources-api/Types.d.ts

@@ -3,6 +3,7 @@ import type { EmptyObject } from '../../../framework-types/BaseTypes';
 import type { LogLevel } from '../../../framework-types/effects/LoggerEffect';
 import type { ContextHaving } from '../../../framework-types/execution-context/Types';
 import type { BundleExportNames, PlayerConfig } from '../../bundles/Types';
+import type { DeepPartial } from '../../Types';
 import type { Constants, LoadControl } from '../core/Constants';
 import type { MapStateAtom } from '../core/state/MapStateAtom';
 import type { CoreEffects, CoreExportNames, CoreStateAtoms } from '../core/Types';
@@ -18,7 +19,9 @@ import type { StreamDataStructurePackageExports } from '../stream-data-structure
 import type { StreamingPackageExports } from '../streaming/Types';
 import type { ContextWithState } from '../Types';
 import type { SourceRemovedError } from './SourceRemovedError';
+import type { SourcesApiEvent } from './SourcesApiEvent';
 import type VideoElementUtils from './VideoElementUtils';
+export type { SourcesApiEvent } from './SourcesApiEvent';
 export interface SourcesApiObject<SourceApi extends EmptyObject> {
     list(): SourceApi[];
     add(config: SourceConfig, options?: SourceOptionsWithAttach, insertAt?: number): SourceApi;
@@ -26,20 +29,13 @@ export interface SourcesApiObject<SourceApi extends EmptyObject> {
     attachVideo(source: SourceApi, options?: AttachOptions): void;
     detachVideo(source: SourceApi): void;
 }
-export type SourceOptionsWithAttach = Partial<SourceOptions> & {
+export type SourceOptionsWithAttach = DeepPartial<SourceOptions> & {
     attach?: boolean | AttachOptions;
 };
 export interface AttachOptions {
         video?: HTMLVideoElement;
         container?: HTMLElement;
 }
-export declare enum SourcesApiEvent {
-    SourceAdded = "source-added",
-    SourceRemoved = "source-removed",
-    VideoAttached = "video-attached",
-    VideoDetached = "video-detached",
-    SourceError = "source-error"
-}
 export type SourcesApiEventMap = {
     [SourcesApiEvent.SourceAdded]: SourceAddedEvent;
     [SourcesApiEvent.SourceRemoved]: SourceRemovedEvent;

package/types/packages/stream-data-structure/Types.d.ts

@@ -14,6 +14,7 @@ export type StreamDataStructure = {
     [StreamDataStructure]: StreamAtom;
 };
 export declare const StreamDataStructureExportNames: readonly ["stream-data-structure-segments", "stream-data-structure-selection-groups", "stream-data-structure-tracks", "stream-data-structure-stream"];
+export type StreamDataStructureExportNames = typeof StreamDataStructureExportNames;
 export type StreamDataStructurePackageExports = StreamDataStructureSegments & StreamDataStructureSelectionGroups & StreamDataStructureTracks & StreamDataStructureStream;
 export type StreamDataStructureContext = ContextHaving<{
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;

package/types/packages/stream-data-structure/segment/Exports.d.ts

@@ -1,12 +1,12 @@
-import type { createDataSegmentAtom, createInitSegmentAtom, createSelfInitSegmentAtom, getGapToNextSegment, getReadableSegmentName, getTimeRange } from './SegmentAtom';
-import type { ContainerFormat, createSegmentDataAtom } from './SegmentDataAtom';
+import type { createDataSegmentAtom, createInitSegmentAtom, createSelfInitSegmentAtom, getGapToNextSegment, getReadableSegmentName, getTimeRange, SegmentType } from './SegmentAtom';
+import type { createSegmentDataAtom } from './SegmentDataAtom';
 import type { createSegmentTiming } from './SegmentTimingAtom';
 import type { isDataOrSelfInitSegment, isDataSegment, isInitSegment } from './SegmentTypeGuards';
 import type { SegmentUtils } from './SegmentUtils';
 export declare const StreamDataStructureSegments = "stream-data-structure-segments";
 export type StreamDataStructureSegments = {
     [StreamDataStructureSegments]: {
-        ContainerFormat: typeof ContainerFormat;
+        SegmentType: typeof SegmentType;
         createDataSegmentAtom: typeof createDataSegmentAtom;
         createInitSegmentAtom: typeof createInitSegmentAtom;
         createSelfInitSegmentAtom: typeof createSelfInitSegmentAtom;

package/types/packages/stream-data-structure/segment/SegmentAtom.d.ts

@@ -9,9 +9,14 @@ import type { SegmentTimingAtom } from './SegmentTimingAtom';
 export type Metadata = Record<string, any>;
 export type DataSegmentAtom = StateAtom<DataSegment, typeof BaseSegmentModifiers & {
     setInitSegment: typeof setInitSegment;
+    setTrack: typeof setTrack;
+}>;
+export type InitSegmentAtom = StateAtom<InitSegment, typeof BaseSegmentModifiers & {
+    setTrack: typeof setTrack;
+}>;
+export type SelfInitSegmentAtom = StateAtom<SelfInitializingSegment, typeof BaseSegmentModifiers & {
+    setTrack: typeof setTrack;
 }>;
-export type InitSegmentAtom = StateAtom<InitSegment, typeof BaseSegmentModifiers>;
-export type SelfInitSegmentAtom = StateAtom<SelfInitializingSegment, typeof BaseSegmentModifiers>;
 export interface ByteRange {
     start: number;
     end: number;
@@ -45,17 +50,21 @@ type Segment = InitSegment | DataSegment | SelfInitializingSegment;
 export type DataOrSelfInitSegmentAtom = DataSegmentAtom | SelfInitSegmentAtom;
 export type SegmentAtom = InitSegmentAtom | DataSegmentAtom | SelfInitSegmentAtom;
 declare const setInitSegment: (data: DataSegment, initSegment: InitSegmentAtom) => boolean;
+declare const setTrack: (segment: Segment, track: TrackAtom) => boolean;
 declare const BaseSegmentModifiers: {
     setSelectionGroup: (segment: Segment, selectionGroup: SelectionGroupAtom) => boolean;
 };
 export declare const createDataSegmentAtom: (context: StreamDataStructureContext, initialData: PartialRequired<DataSegment, 'url' | 'initSegment' | 'segmentTiming' | 'track'>) => StateAtom<DataSegment, {
     setInitSegment: (data: DataSegment, initSegment: InitSegmentAtom) => boolean;
+    setTrack: (segment: Segment, track: TrackAtom) => boolean;
     setSelectionGroup: (segment: Segment, selectionGroup: SelectionGroupAtom) => boolean;
 }>;
 export declare const createInitSegmentAtom: (context: StreamDataStructureContext, initialData: PartialRequired<InitSegment, 'url' | 'track'>) => StateAtom<InitSegment, {
+    setTrack: (segment: Segment, track: TrackAtom) => boolean;
     setSelectionGroup: (segment: Segment, selectionGroup: SelectionGroupAtom) => boolean;
 }>;
 export declare const createSelfInitSegmentAtom: (context: StreamDataStructureContext, initialData: PartialRequired<SelfInitializingSegment, 'url' | 'segmentTiming' | 'track'>) => StateAtom<SelfInitializingSegment, {
+    setTrack: (segment: Segment, track: TrackAtom) => boolean;
     setSelectionGroup: (segment: Segment, selectionGroup: SelectionGroupAtom) => boolean;
 }>;
 export declare function getReadableSegmentName(segment: SegmentAtom, pathLength?: number): string;

package/types/packages/stream-data-structure/segment/SegmentDataAtom.d.ts

@@ -1,12 +1,6 @@
-import type { MediaType } from '../../core/Constants';
+import type { ContainerFormat, MediaType } from '../../core/Constants';
 import type { DataStreamAtom } from '../../core/state/data-stream/DataStreamAtom';
 import type { ContextWithState } from '../../Types';
-export declare enum ContainerFormat {
-    MP4 = "mp4",
-    TS = "mp2t",
-    WebM = "webm",
-    Unknown = "unknown"
-}
 export interface Fragment {
     data: Uint8Array;
 }

package/types/packages/stream-data-structure/segment/SegmentUtils.d.ts

@@ -1,17 +1,18 @@
 import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
 import type { EmptyObject } from '../../../Types';
+import type { Constants, ContainerFormat } from '../../core/Constants';
 import { CoreExportNames } from '../../core/Types';
 import type { CoreUtils } from '../../core/utils/Types';
 import type { ContextWithState } from '../../Types';
 import type { DataOrSelfInitSegmentAtom, SegmentAtom } from './SegmentAtom';
-import { ContainerFormat } from './SegmentDataAtom';
 type ExtendedContext = ContextHaving<{
     [CoreExportNames.Utils]: CoreUtils;
+    [CoreExportNames.Constants]: Constants;
 }, EmptyObject, ContextWithState>;
 declare function areSegmentsOverlapping(segments: DataOrSelfInitSegmentAtom[]): boolean;
 declare function resetData(segment: SegmentAtom, { effects: { state, logger } }: ContextWithState): void;
 declare function resolveContainerFormatFromUrl(context: ExtendedContext, url: string): ContainerFormat | undefined;
-declare function resolveContainerFormatFromExtension(extension: string): ContainerFormat | undefined;
+declare function resolveContainerFormatFromExtension(context: ExtendedContext, extension: string): ContainerFormat | undefined;
 export declare const SegmentUtils: {
     areSegmentsOverlapping: typeof areSegmentsOverlapping;
     resetData: typeof resetData;

package/types/packages/stream-data-structure/selection-group/SelectionGroupAtom.d.ts

@@ -1,6 +1,6 @@
 import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
 import type { EmptyObject, PartialRequired } from '../../../Types';
-import type { Constants } from '../../core/Constants';
+import type { Constants, ContainerFormat } from '../../core/Constants';
 import type { ArrayAtom } from '../../core/state/ArrayStateAtom';
 import type { PrimitiveAtom } from '../../core/state/PrimitiveAtom';
 import type { StateAtom } from '../../core/state/Types';
@@ -8,7 +8,6 @@ import type { CoreStateAtoms } from '../../core/Types';
 import { CoreExportNames } from '../../core/Types';
 import type { CoreUtils } from '../../core/utils/Types';
 import type { ContextWithState } from '../../Types';
-import type { ContainerFormat } from '../segment/SegmentDataAtom';
 import type { AudioTrackAtom, MediaTrackAtom, SubtitleTrackAtom, TimeRange, TrackAtom, VideoTrackAtom } from '../track/TrackAtom';
 type ExtendedContext = ContextHaving<{
     [CoreExportNames.CoreStateAtoms]: CoreStateAtoms;

package/types/packages/stream-data-structure/track/Exports.d.ts

@@ -1,5 +1,6 @@
 import type { createAudioTrackAtom, createMuxedTrackAtom, createSubtitleTrackAtom, createUnknownTrackAtom, createVideoTrackAtom } from './TrackAtom';
-import type { isAudioTrack, isMediaOrSubtitleTrack, isMediaTrack, isMuxedTrack, isSubtitleTrack, isVideoTrack } from './TrackTypeGuards';
+import type { isAudioTrack, isMediaOrSubtitleTrack, isMediaTrack, isMuxedTrack, isSubtitleTrack, isUnknownTrack, isVideoTrack } from './TrackTypeGuards';
+import type { isAudioTypeDetection, isMuxedTypeDetection, isVideoTypeDetection } from './TypeDetectionTypeGuards';
 export declare const StreamDataStructureTracks = "stream-data-structure-tracks";
 export type StreamDataStructureTracks = {
     [StreamDataStructureTracks]: {
@@ -8,11 +9,15 @@ export type StreamDataStructureTracks = {
         createMuxedTrackAtom: typeof createMuxedTrackAtom;
         createSubtitleTrackAtom: typeof createSubtitleTrackAtom;
         createUnknownTrackAtom: typeof createUnknownTrackAtom;
+        isUnknownTrack: typeof isUnknownTrack;
         isAudioTrack: typeof isAudioTrack;
         isMediaTrack: typeof isMediaTrack;
         isSubtitleTrack: typeof isSubtitleTrack;
         isVideoTrack: typeof isVideoTrack;
         isMuxedTrack: typeof isMuxedTrack;
         isMediaOrSubtitleTrack: typeof isMediaOrSubtitleTrack;
+        isAudioTypeDetection: typeof isAudioTypeDetection;
+        isVideoTypeDetection: typeof isVideoTypeDetection;
+        isMuxedTypeDetection: typeof isMuxedTypeDetection;
     };
 };