import type { Room } from "./room/base.js";
import type { State } from "./state/state.js";
export interface ICommand<S extends State = State> {
    execute(state: S, room: Room<S>): Promise<void>;
    undo(state: S, room: Room<S>): Promise<void>;
}
export declare abstract class Command<S extends State = State> implements ICommand<S> {
    /**
     * @ignore
     */
    protected _subCommands: Command<S>[];
    private readonly _name;
    get name(): string;
    /**
     * @param name provide only if you're using `new Command()` syntax.
     * If you're extending command, just leave it empty -
     * the name will be grabbed from class name.
     */
    constructor(name?: string);
    execute(state: S, room: Room<S, Record<string, unknown>>): Promise<void>;
    /**
     * Undoes every remembered extra sub command.
     * `Command` may gather new sub commands only while executing.
     * `Sequence` will only gather sub commands upon construction.
     */
    undo(state: S, room: Room<any>): Promise<void>;
    /**
     * Execute a sub command.
     * Call ONLY during your commands `execute` method.
     * Will also remember it internally for undoing.
     */
    protected subExecute(state: S, room: Room<S>, command: Command<S>): Promise<void>;
}
export type Targets<T> = T | T[] | (() => T | T[]);
export declare class TargetsHolder<T> {
    private readonly value;
    constructor(value: Targets<T>);
    get(): T[];
}
export type Target<T> = T | (() => T);
export declare class TargetHolder<T> {
    private readonly value;
    constructor(value: Target<T>);
    get(): T;
}