export declare interface AttributesUpdateData {
    id: number;
    value: string | boolean;
    key: string;
}

declare type Attrs = {
    [key: string]: string;
};

export declare interface AudioData {
    src: string;
    opts: AudioOptionsData;
    bufferStrList: string[];
    subtitles: SubtitlesData[];
}

export declare interface AudioOptions {
    type: 'opts';
    data: AudioOptionsData;
}

export declare interface AudioOptionsData {
    sampleBits: 8 | 16;
    sampleRate: 8000 | 16000 | 22050 | 24000 | 44100 | 48000;
    channelCount: 1 | 2;
}

export declare type AudioRecord = BaseRecord<RecordType.AUDIO, AudioStrList | AudioOptions>;

export declare interface AudioStrList {
    type: 'base64';
    data: string[];
}

export declare interface BaseRecord<T, D = any> {
    type: T;
    data: D;
    time: number;
    relatedId: string;
}

export declare interface CanvasInitSnapshotData {
    id: number;
    src: string;
}

export declare interface CanvasInitStatusData {
    id: number;
    status: {
        [key: string]: string | number;
    };
}

export declare interface CanvasMutationRecordData {
    id: number;
    strokes: {
        name: keyof CanvasRenderingContext2D | number;
        args: any[];
    }[];
}

export declare type CanvasRecord = BaseRecord<RecordType.CANVAS, CanvasRecordData>;

export declare type CanvasRecordData = CanvasMutationRecordData | CanvasInitSnapshotData | CanvasInitStatusData;

export declare type CanvasSnapshotRecord = BaseRecord<RecordType.CANVAS_SNAPSHOT, CanvasSnapshotRecordData>;

export declare interface CanvasSnapshotRecordData {
    id: number;
    src: string;
}

export declare interface CharacterDataUpdateData {
    parentId: number;
    value: string;
    id: number;
}

declare type Children = (VNode | VSNode)[];

export declare interface Constructable<T> {
    new (...args: any): T;
}

export declare type CustomRecord = BaseRecord<RecordType.CUSTOM, CustomRecordData>;

export declare type CustomRecordData = {
    [key: string]: any;
};

export declare type DBRecordData = {
    id: number;
} & RecordData;

export declare type DOMRecord = BaseRecord<RecordType.DOM, DOMRecordData>;

export declare interface DOMRecordData {
    addedNodes?: UpdateNodeData[];
    movedNodes?: movedNodesData[];
    removedNodes?: RemoveUpdateData[];
    attrs?: AttributesUpdateData[];
    texts?: CharacterDataUpdateData[];
}

declare type Extra = {
    props: {
        textContent: string;
        value: string;
        checked: boolean;
        selected: boolean;
        scroll?: {
            top: number;
            left: number;
        };
    };
    isSVG: boolean;
};

export declare type FontRecord = BaseRecord<RecordType.FONT, FontRecordData>;

export declare interface FontRecordData {
    family: string;
    source: string;
}

export declare enum FormElementEvent {
    'PROP' = 0,
    'INPUT' = 1,
    'CHANGE' = 2,
    'FOCUS' = 3,
    'BLUR' = 4
}

export declare type FormElementRecord = BaseRecord<RecordType.FORM_EL, FormElementRecordData>;

export declare interface FormElementRecordData {
    type: FormElementEvent;
    id: number;
    key?: string;
    value?: string;
    patches?: FormElementStrPatches[];
}

declare interface FormElementStrPatches {
    index: number;
    type: 'add' | 'rm';
    value?: string | undefined;
    len?: number | undefined;
}

export declare type HeadRecord = BaseRecord<RecordType.HEAD, ReplayHead>;

export declare interface InfoData {
    doctype: DocumentType;
    href: string;
    width: number;
    height: number;
    scrollLeft: number;
    scrollTop: number;
    frameId: number | null;
}

export declare type IRecorderStatus = 'PAUSE' | 'RECORDING' | 'STOP';

export declare type LocationRecord = BaseRecord<RecordType.LOCATION, LocationRecordData>;

export declare interface LocationRecordData {
    href: string;
    path: string;
    hash: string;
    title: string;
    contextNodeId: number;
}

export declare enum MouseEventType {
    'MOVE' = 0,
    'CLICK' = 1
}

export declare type MouseRecord = BaseRecord<RecordType.MOUSE, MouseRecordData>;

export declare interface MouseRecordData {
    type: MouseEventType;
    x: number;
    y: number;
    id?: number;
}

export declare interface movedNodesData {
    parentId: number;
    id: number;
    nextId: number | null;
}

export declare type PreFetchRecord = BaseRecord<RecordType.PATCH, PreFetchRecordData>;

export declare interface PreFetchRecordData {
    id: number;
    tag: string;
    key: string;
    time: number;
    url: string;
    text: string;
}

export declare type RecordData = HeadRecord | SnapshotRecord | FormElementRecord | DOMRecord | MouseRecord | WindowRecord | ScrollRecord | AudioRecord | LocationRecord | CanvasRecord | TerminateRecord | FontRecord | PreFetchRecord | CustomRecord | WebGLRecord | CanvasSnapshotRecord;

export declare type RecordEvent<T extends RecordData> = (e: T) => void;

export declare enum RecordType {
    'HEAD' = 0,
    'SNAPSHOT' = 1,
    'WINDOW' = 2,
    'SCROLL' = 3,
    'MOUSE' = 4,
    'DOM' = 5,
    'FORM_EL' = 6,
    'LOCATION' = 7,
    'AUDIO' = 8,
    'CANVAS' = 9,
    'TERMINATE' = 10,
    'FONT' = 11,
    'PATCH' = 12,
    'CUSTOM' = 13,
    'WEBGL' = 14,
    'CANVAS_SNAPSHOT' = 15
}

export declare interface RemoveUpdateData {
    parentId: number;
    id: number;
}

export declare interface ReplayData {
    index?: number;
    head?: HeadRecord;
    snapshot: SnapshotRecord;
    records: RecordData[];
    audio: AudioData;
}

export declare interface ReplayHead {
    version: string;
    href: string;
    title: string;
    relatedId: string;
    userAgent: string;
    platform: string;
    beginTime: number;
    endTime?: number;
    extra?: {
        [key: string]: string;
    };
}

export declare interface ReplayInternalOptions extends ReplayOptions {
    destroyStore: Set<Function>;
    fastForward: number[];
    autoplay: boolean;
    mode: 'live' | 'default';
    target: string | HTMLElement | Window;
    timeMode: 'recordingTime' | 'durationTime';
}

export declare interface ReplayOptions {
    exportName?: string;
    mode?: 'live' | 'default';
    receiver?: (sender: (data: RecordData) => void) => void;
    autoplay?: boolean;
    records?: RecordData[];
    target?: string | HTMLElement | Window;
    heatPoints?: boolean;
    timeMode?: 'recordingTime' | 'durationTime';
    fastForward?: number[];
    disableScaling?: boolean;
    disableScrolling?: boolean;
}

export declare type ScrollRecord = BaseRecord<RecordType.SCROLL, ScrollRecordData>;

export declare interface ScrollRecordData {
    id: number | null;
    top: number;
    left: number;
    behavior?: 'auto';
}

export declare type SnapshotRecord = BaseRecord<RecordType.SNAPSHOT, {
    vNode: VNode;
} & InfoData>;

declare interface SubtitlesData {
    start: string;
    end: string;
    text: string;
}

export declare type TerminateRecord = BaseRecord<RecordType.TERMINATE, null>;

export declare enum TransactionMode {
    'READONLY' = "readonly",
    'READWRITE' = "readwrite",
    'VERSIONCHANGE' = "versionchange"
}

export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

export declare interface UpdateNodeData<T = VSNode | VNode | number> {
    parentId: number;
    nextId: number | null;
    node: T;
}

export declare type ValueOf<T> = T[keyof T];

export declare type ValueOfKey<T, K extends keyof T> = T[K];

export declare interface VNode {
    type: number;
    id: number;
    tag: string;
    attrs: Attrs;
    children: Children;
    extra: Extra;
}

export declare interface VSNode {
    id: number;
    type: number;
    value: string;
}

export declare type WatcherArgs<T extends RecordData | HeadRecord, WatchersInstance = any, Recorder = any> = {
    recorder: Recorder;
    context: Window;
    listenStore: Set<Function>;
    emit: RecordEvent<T>;
    relatedId: string;
    watchers: WatchersInstance;
};

export declare type WebGLRecord = BaseRecord<RecordType.WEBGL, WebGLRecordData>;

export declare interface WebGLRecordData {
    id: number;
    args: any[];
}

export declare type WindowRecord = BaseRecord<RecordType.WINDOW, WindowRecordData>;

export declare interface WindowRecordData {
    id: number | null;
    width: number;
    height: number;
}

export { }