import type { ArrayAtom } from '../../core/state/ArrayStateAtom';
import type { PrimitiveAtom } from '../../core/state/PrimitiveAtom';
import type { Transient } from '../../core/utils/StateUtils';
import type { DataOrSelfInitSegmentAtom } from '../segment/SegmentAtom';
import type { SelectionGroupAtom } from '../selection-group/SelectionGroupAtom';
import type { MediaTrackAtom, TrackAtom } from '../track/TrackAtom';
import type { StreamDataStructureContext } from '../Types';
export type SelectionGroupsAtom = ArrayAtom<SelectionGroupAtom>;
export type TracksAtom = ArrayAtom<TrackAtom>;
export type PlaybackTimeMismatchTransientPayload = {
    track: MediaTrackAtom;
    segment: DataOrSelfInitSegmentAtom;
    expectedTime: number;
    actualTime: number;
};
export type DurationMismatchTransientPayload = {
    track: MediaTrackAtom;
    segment: DataOrSelfInitSegmentAtom;
    expectedDuration: number;
    actualDuration: number;
};
export declare enum StreamType {
    Live = "live",
    VoD = "vod"
}
type Stream = {
    type: StreamType;
    duration: PrimitiveAtom<number>;
    tracks: ArrayAtom<TrackAtom>;
    selectionGroups: SelectionGroupsAtom;
    onPlaybackTimeMismatch: Transient<PlaybackTimeMismatchTransientPayload>;
    onDurationMismatch: Transient<DurationMismatchTransientPayload>;
};
declare function setType(stream: Stream, type: StreamType): boolean;
export type StreamAtom = ReturnType<typeof createStreamAtom>;
export declare const createStreamAtom: (context: StreamDataStructureContext, type: StreamType) => import("../../core/state/Types").StateAtom<{
    tracks: ArrayAtom<TrackAtom>;
    selectionGroups: ArrayAtom<SelectionGroupAtom>;
    type: StreamType;
    duration: import("../../core/state/Types").StateAtom<{
        value: number;
    }, {
        setValue: (data: {
            value: number;
        }, value: number) => boolean;
    }>;
    onPlaybackTimeMismatch: import("../../core/state/Types").StateAtom<{
        value: PlaybackTimeMismatchTransientPayload | undefined;
    }, {
        trigger: (t: {
            value: PlaybackTimeMismatchTransientPayload | undefined;
        }, value: PlaybackTimeMismatchTransientPayload) => boolean;
    }>;
    onDurationMismatch: import("../../core/state/Types").StateAtom<{
        value: DurationMismatchTransientPayload | undefined;
    }, {
        trigger: (t: {
            value: DurationMismatchTransientPayload | undefined;
        }, value: DurationMismatchTransientPayload) => boolean;
    }>;
}, {
    setType: typeof setType;
}>;
export {};