import { Setter, Accessor, Signal } from 'solid-js';
import { CloneFn } from '../useCloned/index.js';
import '@solidjs-use/shared';
import 'solid-js/types/reactive/signal';

interface UseHistoryTravelRecord<T> {
    snapshot: T;
    timestamp: number;
}
interface UseManualHistoryTravelOptions<Raw, Serialized = Raw> {
    /**
     * Maximum number of history to be kept. Default to unlimited.
     */
    capacity?: number;
    /**
     * Clone when taking a snapshot, shortcut for dump: JSON.parse(JSON.stringify(value)).
     * Default to false
     *
     * @default false
     */
    clone?: boolean | CloneFn<Raw>;
    /**
     * Serialize data into the history
     */
    dump?: (v: Raw) => Serialized;
    /**
     * Deserialize data from the history
     */
    parse?: (v: Serialized) => Raw;
    /**
     * set data source
     */
    setSource?: (setSource: Setter<Raw>, v: Raw) => void;
}
interface UseManualHistoryTravelAccessorReturn<Raw, Serialized> {
    /**
     * Bypassed tracking Accessor from the argument
     */
    source: Accessor<Raw>;
    /**
     * An array of history records for undo, newest comes to first
     */
    history: Accessor<Array<UseHistoryTravelRecord<Serialized>>>;
    /**
     * Last history point, source can be different if paused
     */
    last: Accessor<UseHistoryTravelRecord<Serialized>>;
    /**
     * Same as {@link UseManualHistoryTravelReturn.history | history}
     */
    undoStack: Accessor<Array<UseHistoryTravelRecord<Serialized>>>;
    /**
     * Records array for redo
     */
    redoStack: Accessor<Array<UseHistoryTravelRecord<Serialized>>>;
    /**
     * A Accessor representing if undo is possible (non empty undoStack)
     */
    canUndo: Accessor<boolean>;
    /**
     * A Accessor representing if redo is possible (non empty redoStack)
     */
    canRedo: Accessor<boolean>;
    /**
     * Clear all the history
     */
    clear: () => void;
    /**
     * Create a new history record
     */
    commit: () => void;
}
interface UseManualHistoryTravelSignalReturn<Raw, Serialized> extends UseManualHistoryTravelAccessorReturn<Raw, Serialized> {
    /**
     * Undo changes
     */
    undo: () => void;
    /**
     * Redo changes
     */
    redo: () => void;
    /**
     * Reset Accessor's value with latest history
     */
    reset: () => void;
}
/**
 * Manually track the change history of a `Signal` or `Accessor` when the using calls `commit()`, when the parameter is a Signal, it provides undo and redo functionality.
 *
 * @see https://solidjs-use.github.io/solidjs-use/core/useManualHistoryTravel
 */
declare function useManualHistoryTravel<Raw, Serialized = Raw>(source: Accessor<Raw>, options?: UseManualHistoryTravelOptions<Raw, Serialized>): UseManualHistoryTravelAccessorReturn<Raw, Serialized>;
declare function useManualHistoryTravel<Raw, Serialized = Raw>(source: Signal<Raw>, options?: UseManualHistoryTravelOptions<Raw, Serialized>): UseManualHistoryTravelSignalReturn<Raw, Serialized>;

export { UseHistoryTravelRecord, UseManualHistoryTravelAccessorReturn, UseManualHistoryTravelOptions, UseManualHistoryTravelSignalReturn, useManualHistoryTravel };