import { State } from "./state.js";
import { Transition } from "./transition.js";
export declare class StateData {
    myID: unknown;
    myState: State;
    constructor(stateID: unknown, state: State);
}
export declare class TransitionData {
    myID: unknown;
    myFromStateData: Readonly<StateData>;
    myToStateData: Readonly<StateData>;
    myTransition: Transition;
    mySkipStateFunction: SkipStateFunction;
    constructor(transitionID: unknown, fromStateData: Readonly<StateData>, toStateData: Readonly<StateData>, transition: Transition, skipStateFunction: SkipStateFunction);
}
export declare class PendingPerform {
    myID: unknown;
    myTransitionArgs: unknown[];
    constructor(transitionID: unknown, ...args: unknown[]);
}
export declare enum PerformMode {
    IMMEDIATE = 0,
    DELAYED = 1
}
export declare enum PerformDelayedMode {
    QUEUE = 0,
    KEEP_FIRST = 1,
    KEEP_LAST = 2
}
export declare enum SkipStateFunction {
    NONE = 0,
    END = 1,
    START = 2,
    BOTH = 3
}
/**
 * You can also use plain functions for state/transition if u want to do something simple and quick
 *
 * Signatures:
 *     function stateUpdate(dt, fsm, stateData)
 *     function init(fsm, stateData)
 *     function transition(fsm, transitionData)
*/
export declare class FSM {
    private _myCurrentStateData;
    private readonly _myStatesData;
    private readonly _myTransitionsData;
    private _myLogEnabled;
    private _myLogShowDelayedInfo;
    private _myLogFSMName;
    private _myPerformMode;
    private _myPerformDelayedMode;
    private readonly _myPendingPerforms;
    private _myCurrentlyPerformedTransitionData;
    private readonly _myInitEmitter;
    private readonly _myInitIDEmitters;
    private readonly _myTransitionEmitter;
    private readonly _myTransitionIDEmitters;
    constructor(performMode?: PerformMode, performDelayedMode?: PerformDelayedMode);
    addState(stateID: unknown, state?: State): void;
    addState(stateID: unknown, stateUpdateCallback?: ((dt: number, fsm: FSM, stateData: Readonly<StateData>, ...args: any[]) => void), stateStartCallback?: ((fsm: FSM, transitionData: Readonly<TransitionData>, ...args: any[]) => void), stateEndCallback?: ((fsm: FSM, transitionData: Readonly<TransitionData>, ...args: any[]) => void), stateInitCallback?: ((fsm: FSM, stateData: Readonly<StateData>, ...args: any[]) => void)): void;
    addTransition(fromStateID: unknown, toStateID: unknown, transitionID: unknown, transition?: Transition, skipStateFunction?: SkipStateFunction): void;
    addTransition(fromStateID: unknown, toStateID: unknown, transitionID: unknown, transitionPerformCallback?: ((fsm: FSM, transitionData: Readonly<TransitionData>, ...args: any[]) => void), skipStateFunction?: SkipStateFunction): void;
    init(stateID: unknown, transition?: Transition): void;
    init(stateID: unknown, transitionPerformInitCallback?: ((fsm: FSM, stateData: Readonly<StateData>, ...args: unknown[]) => void), ...args: unknown[]): void;
    update(dt: number, ...args: unknown[]): void;
    perform(transitionID: unknown, ...args: unknown[]): void;
    performDelayed(transitionID: unknown, ...args: unknown[]): boolean;
    performImmediate(transitionID: unknown, ...args: unknown[]): boolean;
    canPerform(transitionID: unknown): boolean;
    canGoTo(stateID: unknown, transitionID?: unknown): boolean;
    isInState(stateID: unknown): boolean;
    isPerformingTransition(): boolean;
    getCurrentlyPerformingTransitionData(): Readonly<TransitionData> | null;
    hasBeenInit(): boolean;
    reset(): void;
    resetCurrentState(): void;
    resetPendingPerforms(): void;
    getCurrentStateData(): Readonly<StateData> | null;
    getCurrentTransitionsData(): Readonly<TransitionData>[];
    getCurrentTransitionsDataToState(stateID: unknown): Readonly<TransitionData>[];
    getStateData(stateID: unknown): Readonly<StateData> | null;
    getStatesData(): Readonly<StateData>[];
    getTransitionsData(): Readonly<TransitionData>[];
    getTransitionsDataFromState(fromStateID: unknown): Readonly<TransitionData>[];
    getTransitionsDataFromStateToState(fromStateID: unknown, toStateID: unknown): Readonly<TransitionData>[];
    removeState(stateID: unknown): boolean;
    removeTransitionFromState(fromStateID: unknown, transitionID: unknown): boolean;
    hasState(stateID: unknown): boolean;
    hasTransitionFromState(fromStateID: unknown, transitionID: unknown): boolean;
    hasTransitionFromStateToState(fromStateID: unknown, toStateID: unknown, transitionID?: unknown): boolean;
    setPerformMode(performMode: PerformMode): void;
    getPerformMode(): PerformMode;
    setPerformDelayedMode(performDelayedMode: PerformDelayedMode): void;
    getPerformDelayedMode(): PerformDelayedMode;
    hasPendingPerforms(): boolean;
    getPendingPerforms(): Readonly<PendingPerform[]>;
    clone(deepClone?: boolean): FSM | null;
    isCloneable(deepClone?: boolean): boolean;
    setLogEnabled(active: boolean, fsmName?: string, showDelayedInfo?: boolean): void;
    registerInitEventListener(listenerID: unknown, listener: (fsm: FSM, stateData: Readonly<StateData>, ...args: unknown[]) => void): void;
    unregisterInitEventListener(listenerID: unknown): void;
    registerInitIDEventListener(stateID: unknown, listenerID: unknown, listener: (fsm: FSM, stateData: Readonly<StateData>, ...args: unknown[]) => void): void;
    unregisterInitIDEventListener(stateID: unknown, listenerID: unknown): void;
    registerTransitionEventListener(listenerID: unknown, listener: (fsm: FSM, transitionData: Readonly<TransitionData>, performMode: PerformMode, ...args: unknown[]) => void): void;
    unregisterTransitionEventListener(listenerID: unknown): void;
    /** The fsm IDs can be `null`, that means that the listener is called whenever only the valid IDs match
        This let you register to all the transitions with a specific ID and from of a specific state but to every state (`toStateID == null`) */
    registerTransitionIDEventListener(fromStateID: unknown, toStateID: unknown, transitionID: unknown, listenerID: unknown, listener: (fsm: FSM, transitionData: Readonly<TransitionData>, performMode: PerformMode, ...args: unknown[]) => void): void;
    unregisterTransitionIDEventListener(fromStateID: unknown, toStateID: unknown, transitionID: unknown, listenerID: unknown): void;
    private _perform;
    private _getTransitionsDataFromState;
}