import { Patch } from 'immer';
import { Stage, Track, Uid, TrackElement, StyleObject, Transform, Source, Crop } from '../state/types.js';

interface PayloadBase<T> {
    payload: T;
    noHistory?: boolean;
}
interface ChangedBase<T> {
    changed: T;
}
declare const CHANGE_SUFFIX = ":changed";
/**
 * ----------stage----------
 */
declare const STAGE_PREFIX = "stage";
declare const STAGE_INIT = "stage:init";
type StageInitPayload = PayloadBase<Stage>;
declare const STAGE_CHANGED = "stage:changed";
type StageChangedPayload = PayloadBase<Stage>;
declare const STAGE_RESIZE = "stage:resize";
type StageResizePayload = PayloadBase<{
    width: number;
    height: number;
}>;
declare const STAGE_SEEKTO = "stage:seekTo";
type StageSeekToPayload = PayloadBase<{
    currentTime: number;
}>;
declare const STAGE_PLAY = "stage:play";
type StagePlayPayload = PayloadBase<undefined>;
declare const STAGE_PAUSE = "stage:pause";
type StagePausePayload = PayloadBase<undefined>;
declare const STAGE_DURATION_CHANGED = "stage:durationChanged";
type StageDurationChangedPayload = PayloadBase<{
    duration: number;
}>;
declare const STAGE_CURRENT_TIME_CHANGED = "stage:currentTimeChanged";
type StageCurrentTimeChangedPayload = PayloadBase<{
    currentTime: number;
}>;
declare const STAGE_PLAY_STATUS_CHANGED = "stage:playStatusChanged";
type PlayStatus = 'stop' | 'ready' | 'play' | 'pause' | 'disabled';
type StagePlayStatusChangedPayload = PayloadBase<{
    status: PlayStatus;
}>;
/**
 * ----------track----------
 */
declare const TRACK_PREFIX = "track";
declare const TRACK_ADD = "track:add";
type TrackAddPayload = PayloadBase<Required<Pick<Track, 'id' | 'type' | 'isMain'>> & Partial<Omit<Track, 'id' | 'type' | 'isMain'>>>;
declare const TRACK_ADD_CHANGED = "track:add:changed";
type TrackAddChangedPayload = TrackAddPayload & ChangedBase<{
    track: Array<Track>;
}>;
declare const TRACK_DELETE = "track:delete";
type TrackDeletePayload = PayloadBase<{
    id: Uid;
}>;
declare const TRACK_DELETE_CHANGED = "track:delete:changed";
type TrackDeleteChangedPayload = TrackDeletePayload & ChangedBase<{
    track: Array<Track>;
}>;
declare const TRACK_VOLUME = "track:volume";
type TrackVolumePayload = PayloadBase<{
    id: Uid;
    volume: number;
}>;
declare const TRACK_MUTE = "track:mute";
type TrackMutePayload = PayloadBase<{
    id: Uid;
    mute: boolean;
    volumn: number;
}>;
/**
 * ----------layer----------
 */
declare const LAYER_PREFIX = "layer";
declare const LAYER_ADD = "layer:add";
type LayerAddPayload = PayloadBase<TrackElement>;
declare const LAYER_ADD_CHANGED = "layer:add:changed";
type LayerAddChangedPayload = LayerAddPayload & ChangedBase<{
    track: Track;
    trackItemsMap: Record<Uid, TrackElement>;
}>;
declare const LAYER_DELETE = "layer:delete";
type LayerDeletePayload = PayloadBase<{
    id: Uid;
}>;
declare const LAYER_DELETE_CHANGED = "layer:delete:changed";
type LayerDeleteChangedPayload = LayerDeletePayload & ChangedBase<{
    track: Track;
    trackItemsMap: Record<Uid, TrackElement>;
}>;
declare const LAYER_MOVE = "layer:move";
type LayerMovePayload = PayloadBase<{
    id: Uid;
    startPos: number;
    trackId?: Uid;
    layerData?: TrackElement;
}>;
declare const LAYER_MOVE_CHANGED = "layer:move:changed";
type LayerMoveChangedPayload = LayerMovePayload & ChangedBase<{
    track: Array<Track>;
    trackItemsMap: Record<Uid, TrackElement>;
}>;
declare const LAYER_SPLIT = "layer:split";
type LayerSplitPayload = PayloadBase<{
    id: Uid;
    splitPos: number;
}>;
declare const LAYER_SPLIT_CHANGED = "layer:split:changed";
type LayerSplitChangedPayload = LayerSplitPayload & ChangedBase<{
    track: Track;
    trackItemsMap: Record<Uid, TrackElement>;
}>;
declare const LAYER_TRIM = "layer:trim";
type LayerTrimPayload = PayloadBase<{
    id: Uid;
    trim: {
        direction: 'start' | 'end';
        pos: number;
    };
    minDuration?: number;
}>;
declare const LAYER_TRIM_CHANGED = "layer:trim:changed";
type LayerTrimChangedPayload = LayerTrimPayload & ChangedBase<{
    trackItemsMap: Record<Uid, TrackElement>;
}>;
declare const LAYER_UPDATE = "layer:update";
type LayerUpdatePayload = PayloadBase<{
    id: Uid;
    style?: Partial<StyleObject>;
    transform?: Partial<Transform>;
    extendInfo?: Record<string, any>;
}>;
/**
 * ----------edit----------
 */
declare const EDIT_PREFIX = "edit";
declare const EDIT_SOURCE = "edit:source";
type EditSourcePayload = PayloadBase<{
    id: Uid;
    src: Partial<Source>;
}>;
declare const EDIT_SOURCE_CHANGED = "edit:source:changed";
type EditSourceChangedPayload = EditSourcePayload & ChangedBase<undefined>;
declare const EDIT_STYLE = "edit:style";
type EditStylePayload = PayloadBase<{
    id: Uid;
    style: Partial<StyleObject>;
}>;
declare const EDIT_TRANSFORM = "edit:transform";
type EditTransformPayload = PayloadBase<{
    id: Uid;
    transform: Partial<Transform>;
}>;
declare const EDIT_VOLUME = "edit:volume";
type EditVolumePayload = PayloadBase<{
    id: Uid;
    volume: number;
}>;
declare const EDIT_MUTE = "edit:mute";
type EditMutePayload = PayloadBase<{
    id: Uid;
    mute: boolean;
    volume: number;
}>;
declare const EDIT_SPEED = "edit:speed";
type EditSpeedPayload = PayloadBase<{
    id: Uid;
    speed: number;
}>;
declare const EDIT_TRANSITION = "edit:transition";
type EditTransitionPayload = PayloadBase<{
    id: Uid;
    path: string;
}>;
declare const EDIT_SPEED_CHANGED = "edit:speed:changed";
type EditSpeedChangedPayload = EditSpeedPayload & ChangedBase<{
    trackItemsMap: Record<Uid, TrackElement>;
}>;
declare const EDIT_CROP = "edit:crop";
type EditCropPayload = PayloadBase<{
    id: Uid;
    crop: Crop;
}>;
/**
 * ----------history----------
 */
declare const HISTORY_PREFIX = "history";
declare const HISTORY_UNDO = "history:undo";
type HistoryUndoPayload = PayloadBase<number>;
declare const HISTORY_REDO = "history:redo";
type HistoryRedoPayload = PayloadBase<number>;
declare const HISTORY_RESET = "history:reset";
type HistoryResetPayload = PayloadBase<undefined>;
declare const HISTORY_CHANGED = "history:changed";
interface HistorySingleChangedDetail {
    type: keyof PayloadMap;
    diff: {
        patchs: Patch[];
        inversePatches: Patch[];
    };
}
interface HistoryBatchChangedDetail {
    type: typeof BATCH;
    diff: Array<HistorySingleChangedDetail>;
}
type HistoryChangedDetail = HistorySingleChangedDetail | HistoryBatchChangedDetail;
type HistoryChangedPayload = PayloadBase<{
    undos: Array<HistoryChangedDetail>;
    redos: Array<HistoryChangedDetail>;
}>;
/**
 * ----------batch----------
 */
interface SinglePayloadMap {
    [STAGE_INIT]: StageInitPayload;
    [STAGE_RESIZE]: StageResizePayload;
    [STAGE_CHANGED]: StageChangedPayload;
    [STAGE_SEEKTO]: StageSeekToPayload;
    [STAGE_PLAY]: StagePlayPayload;
    [STAGE_PAUSE]: StagePausePayload;
    [STAGE_DURATION_CHANGED]: StageDurationChangedPayload;
    [STAGE_CURRENT_TIME_CHANGED]: StageCurrentTimeChangedPayload;
    [STAGE_PLAY_STATUS_CHANGED]: StagePlayStatusChangedPayload;
    [TRACK_ADD]: TrackAddPayload;
    [TRACK_DELETE]: TrackDeletePayload;
    [TRACK_VOLUME]: TrackVolumePayload;
    [TRACK_MUTE]: TrackMutePayload;
    [LAYER_ADD]: LayerAddPayload;
    [LAYER_DELETE]: LayerDeletePayload;
    [LAYER_MOVE]: LayerMovePayload;
    [LAYER_SPLIT]: LayerSplitPayload;
    [LAYER_TRIM]: LayerTrimPayload;
    [LAYER_UPDATE]: LayerUpdatePayload;
    [EDIT_SOURCE]: EditSourcePayload;
    [EDIT_STYLE]: EditStylePayload;
    [EDIT_TRANSFORM]: EditTransformPayload;
    [EDIT_VOLUME]: EditVolumePayload;
    [EDIT_MUTE]: EditMutePayload;
    [EDIT_SPEED]: EditSpeedPayload;
    [EDIT_TRANSITION]: EditTransitionPayload;
    [EDIT_CROP]: EditCropPayload;
    [HISTORY_UNDO]: HistoryUndoPayload;
    [HISTORY_REDO]: HistoryRedoPayload;
    [HISTORY_RESET]: HistoryResetPayload;
    [HISTORY_CHANGED]: HistoryChangedPayload;
}
declare const BATCH = "batch";
type BatchPayload = PayloadBase<Array<{
    [K in keyof SinglePayloadMap]: {
        key: K;
    } & SinglePayloadMap[K] & {
        callback?: (value: any) => void;
    };
}[keyof SinglePayloadMap]>>;
interface SingleChangedPayloadMap {
    [TRACK_ADD_CHANGED]: TrackAddChangedPayload;
    [TRACK_DELETE_CHANGED]: TrackDeleteChangedPayload;
    [LAYER_ADD_CHANGED]: LayerAddChangedPayload;
    [LAYER_DELETE_CHANGED]: LayerDeleteChangedPayload;
    [LAYER_MOVE_CHANGED]: LayerMoveChangedPayload;
    [LAYER_SPLIT_CHANGED]: LayerSplitChangedPayload;
    [LAYER_TRIM_CHANGED]: LayerTrimChangedPayload;
    [EDIT_SPEED_CHANGED]: EditSpeedChangedPayload;
    [EDIT_SOURCE_CHANGED]: EditSourceChangedPayload;
}
declare const BATCH_CHANGED = "batch:changed";
type BatchChangedPayload = PayloadBase<Array<{
    [K in keyof SingleChangedPayloadMap]: {
        key: K;
    } & SingleChangedPayloadMap[K] & {
        callback?: (value: any) => void;
    };
}[keyof SingleChangedPayloadMap]>>;
type ChangedPayloadMap = SingleChangedPayloadMap & {
    [BATCH_CHANGED]: BatchChangedPayload;
};
type PayloadMap = SinglePayloadMap & {
    [BATCH]: BatchPayload;
} & ChangedPayloadMap;
type EventData<K extends keyof PayloadMap = keyof PayloadMap> = {
    key: K;
    value: PayloadMap[K];
    callback?: (value: any) => void;
};
type Dispatcher = <K extends keyof PayloadMap = keyof PayloadMap>(key: K, value: PayloadMap[K], callback?: (value: any) => void) => void;

export { BATCH, BATCH_CHANGED, CHANGE_SUFFIX, EDIT_CROP, EDIT_MUTE, EDIT_PREFIX, EDIT_SOURCE, EDIT_SOURCE_CHANGED, EDIT_SPEED, EDIT_SPEED_CHANGED, EDIT_STYLE, EDIT_TRANSFORM, EDIT_TRANSITION, EDIT_VOLUME, HISTORY_CHANGED, HISTORY_PREFIX, HISTORY_REDO, HISTORY_RESET, HISTORY_UNDO, LAYER_ADD, LAYER_ADD_CHANGED, LAYER_DELETE, LAYER_DELETE_CHANGED, LAYER_MOVE, LAYER_MOVE_CHANGED, LAYER_PREFIX, LAYER_SPLIT, LAYER_SPLIT_CHANGED, LAYER_TRIM, LAYER_TRIM_CHANGED, LAYER_UPDATE, STAGE_CHANGED, STAGE_CURRENT_TIME_CHANGED, STAGE_DURATION_CHANGED, STAGE_INIT, STAGE_PAUSE, STAGE_PLAY, STAGE_PLAY_STATUS_CHANGED, STAGE_PREFIX, STAGE_RESIZE, STAGE_SEEKTO, TRACK_ADD, TRACK_ADD_CHANGED, TRACK_DELETE, TRACK_DELETE_CHANGED, TRACK_MUTE, TRACK_PREFIX, TRACK_VOLUME };
export type { BatchChangedPayload, BatchPayload, ChangedBase, ChangedPayloadMap, Dispatcher, EditCropPayload, EditMutePayload, EditSourceChangedPayload, EditSourcePayload, EditSpeedChangedPayload, EditSpeedPayload, EditStylePayload, EditTransformPayload, EditTransitionPayload, EditVolumePayload, EventData, HistoryBatchChangedDetail, HistoryChangedDetail, HistoryChangedPayload, HistoryRedoPayload, HistoryResetPayload, HistorySingleChangedDetail, HistoryUndoPayload, LayerAddChangedPayload, LayerAddPayload, LayerDeleteChangedPayload, LayerDeletePayload, LayerMoveChangedPayload, LayerMovePayload, LayerSplitChangedPayload, LayerSplitPayload, LayerTrimChangedPayload, LayerTrimPayload, LayerUpdatePayload, PayloadBase, PayloadMap, PlayStatus, SingleChangedPayloadMap, SinglePayloadMap, StageChangedPayload, StageCurrentTimeChangedPayload, StageDurationChangedPayload, StageInitPayload, StagePausePayload, StagePlayPayload, StagePlayStatusChangedPayload, StageResizePayload, StageSeekToPayload, TrackAddChangedPayload, TrackAddPayload, TrackDeleteChangedPayload, TrackDeletePayload, TrackMutePayload, TrackVolumePayload };