import { default as SDK } from '..';
import { EditorAPI } from '../types/CommonTypes';
/**
 * The UndoManagerController is responsible for all communication regarding the Undo-Manager.
 * Methods inside this controller can be called by `window.SDK.undoManager.{method-name}`
 */
export declare class UndoManagerController {
    #private;
    /**
     * @ignore
     */
    constructor(children: EditorAPI, sdk: SDK);
    /**
     * This method undoes the last operation
     * @returns
     */
    undo: () => Promise<import('..').EditorResponse<null>>;
    /**
     * This method redoes the last operation
     * @returns
     */
    redo: () => Promise<import('..').EditorResponse<null>>;
    /**
     * This method adds custom data that will be saved and restored when undoing and redoing.
     * Duplicate values are overwritten. The data is exposed via the onCustomUndoDataChanged event.
     *
     * @param key The key of the custom data
     * @param value The value of the custom data
     * @returns
     */
    addCustomData: (key: string, value: string) => Promise<import('..').EditorResponse<null>>;
    /**
     * Record any operations in the current scope. This will automatically begin
     * the undo operation. Once you leave the record scope, it will end the undo operation.
     * Even if you throw an exception inside the record scope it will still end it properly.
     * @returns
     */
    record: (operationName: string, undoOperationCallback: (sdk: SDK) => Promise<void>) => Promise<void>;
    /**
     * This method pauses the undo manager
     * @returns
     */
    pause: () => Promise<import('..').EditorResponse<null>>;
    /**
     * This method resumes the undo manager
     * @returns
     */
    resume: () => Promise<import('..').EditorResponse<null>>;
    /**
     * This method clears the undo stack
     * @returns
     */
    clear: () => Promise<import('..').EditorResponse<null>>;
    /**
     * Advanced undo manager functionality for manually controlling undo operations.
     * This will start a new undo operation.
     * This will throw an exception when there is already an undo operation recording.
     * @experimental This method is experimental and may change in future versions.
     * @returns
     */
    advanced: {
        /**
         * This will start a new undo operation.
         * This will throw an exception when there is already an undo operation recording.
         * @experimental This method is experimental and may change in future versions.
         * @returns
         */
        begin: (operationName: string) => Promise<import('..').EditorResponse<null>>;
        /**
         * This will start a new undo operation if there is no other undo operation recording.
         * This does not throw.
         * @experimental This method is experimental and may change in future versions.
         * @returns
         */
        beginIfNoneActive: (operationName: string) => Promise<import('..').EditorResponse<null>>;
        /**
         * Ends the currently active recording operation.
         * If there is no recording operation currently running this will throw an exception.
         * @experimental This method is experimental and may change in future versions.
         * @returns
         */
        end: () => Promise<import('..').EditorResponse<null>>;
        /**
         * Aborts the currently active recording operation.
         * If there is no recording operation currently running this will throw an exception.
         * @experimental This method is experimental and may change in future versions.
         * @returns
         */
        abort: () => Promise<import('..').EditorResponse<null>>;
    };
}
export declare class AdvancedUndoManagerController {
    #private;
    /**
     * @ignore
     */
    constructor(children: EditorAPI);
    /**
     * This will start a new undo operation.
     * This will throw an exception when there is already an undo operation recording.
     * @returns
     */
    begin: (operationName: string) => Promise<import('..').EditorResponse<null>>;
    /**
     * This will start a new undo operation if there is no other undo operation recording.
     * This does not throw.
     * @returns
     */
    beginIfNoneActive: (operationName: string) => Promise<import('..').EditorResponse<null>>;
    /**
     * Ends the currently active recording operation.
     * If there is no recording operation currently running this will throw an exception.
     * @returns
     */
    end: () => Promise<import('..').EditorResponse<null>>;
    /**
     * Aborts the currently active recording operation.
     * If there is no recording operation currently running this will throw an exception.
     * @returns
     */
    abort: () => Promise<import('..').EditorResponse<null>>;
}