import { Deque } from './collections';
import { Store } from '../vuer/vuer-store/store';
import { EventType } from '../vuer/interfaces';
import { EventEmitter } from '../vuer/emitter';
export type stateSetter<T> = (value: T | ((T: any) => T)) => void;
export interface Frame extends EventType {
    ts: number;
    etype: string;
    data: unknown;
}
export type ClipData = {
    name?: string;
    start?: number;
    end?: number;
    frames: Frame[];
};
export interface Clip extends EventType {
    ts: number;
    etype: 'FRAME_CLIP';
    data: ClipData;
}
export declare class Range {
    start: number;
    end: number;
    constructor(start: number, end: number);
}
export interface RangeOption {
    start?: number | ((start: number) => number);
    end?: number | ((end: number) => number);
}
/**
 * Creates a method decorator that emits an event after the method's execution.
 *
 * The `sentinel` function is designed to enhance class methods in such a way that,
 * after a method's execution, an event of a specified type is emitted. This is particularly
 * useful for automatically triggering updates or notifications in response to method invocations.
 *
 * Usage:
 * To use, simply annotate a class method with `@sentinel('EVENT_TYPE')`, where 'EVENT_TYPE'
 * is the string identifier of the event you wish to emit after the method executes.
 *
 * ```typescript
 * import React from 'react';
 * import { sentinel, Playback } from './path/to/your/code';
 *
 * class VideoPlayer extends Playback {
 *   constructor() {
 *     super();
 *     // Initialize with default values or configurations
 *   }
 *
 *   @sentinel('PLAY')
 *   play() {
 *     console.log('Playing video...');
 *     // Logic to play video
 *   }
 *
 *   @sentinel('PAUSE')
 *   pause() {
 *     console.log('Pausing video...');
 *     // Logic to pause video
 *   }
 *
 *   @sentinel('STOP')
 *   stop() {
 *     console.log('Stopping video...');
 *     // Logic to stop video
 *   }
 * }
 *
 * // Example usage
 * const videoPlayer = new VideoPlayer();
 * videoPlayer.play(); // This will also emit a 'PLAY' event after executing
 * videoPlayer.pause(); // This will also emit a 'PAUSE' event after executing
 * videoPlayer.stop(); // This will also emit a 'STOP' event after executing
 * ```
 *
 * Note:
 * - The decorator expects the target class to have a `signal` property that is an instance of `EventEmitter`.
 * - It will log an error if attempted to be applied to a class property that is not a method.
 *
 *
 * @param etype The event type to emit after the method execution. This should be a string that uniquely identifies the event.
 * @returns A method decorator function that takes the target object, property key, and property descriptor as arguments,
 *          and modifies the method to emit an event upon completion.
 **/
export declare function sentinel<This extends {
    signal: EventEmitter;
}, Args extends any[], ReturnType>(etype: string): (target: any, key: any, descriptor: any) => any;
export declare class Playback {
    maxlen: number;
    fps: number;
    speed: number;
    start: number;
    end: number;
    curr: number;
    isPaused: boolean;
    isRecording: boolean;
    loop: boolean;
    private _keyFrames;
    private clips;
    /** this is the out-bound stream for events. **/
    store: Store<Frame>;
    range: Range;
    signal: EventEmitter;
    /**
     * A Playback container for a sequence of keyframes
     *
     * @param maxlen {number} test this
     * @param speed {number} test this
     * @param fps {number} test this
     * @param keyFrames {Array<Frame>} test this
     * @param start {number} test this
     * @param end {number} test this
     * @param curr {number} test this
     * @param rangeStart {number} test this
     * @param rangeEnd {number} test this
     * @param pause {boolean} test this
     * @param loop {boolean} test this
     * @param record {boolean} test this
     * **/
    constructor(maxlen?: number, fps?: number, speed?: number, keyFrames?: Array<Frame>, start?: number, end?: number, curr?: number, rangeStart?: number, rangeEnd?: number, pause?: boolean, loop?: boolean, record?: boolean);
    get keyFrames(): Deque<Frame>;
    loadFrameBuffer(keyFrames: Frame[]): void;
    changeBufferLength: (maxlen: number) => void;
    setMaxlen: (maxlen: number) => void;
    get duration(): number;
    get progress(): number;
    private step;
    private timeFrac;
    /**
     * onFrame callback, should be called inside useFrame
     * @param deltaTime
     **/
    render: (deltaTime: any) => void;
    addKeyFrame: (frame: Frame, force?: boolean) => void;
    addClip: ({ data }: Clip) => void;
    moveClip: (name: string, start?: number, end?: number) => void;
    clear: () => void;
    seekNext: () => void;
    seekPrevious: () => void;
    reset: () => void;
    seekEnd: () => void;
    emitSeek: (frame: any) => void;
    get currentFrame(): Frame;
    get firstFrame(): Frame;
    get lastFrame(): Frame;
    setFrameRate: (fps: number) => void;
    setSpeed: (speed: number) => void;
    setRange: ({ start, end }: RangeOption) => void;
    toggleRecording: () => void;
    pausePlayback: () => void;
    togglePlayback: () => void;
    toggleLoop: () => void;
}