import type { ActionArgs, ActionFunction, EventObject, MachineContext, MachineEvent, MachineSnapshot, ResolvedMachineImplementations } from "../types/index.js";
import type { MachineModel, MachineState, ModelGuard, Transition } from "./model.js";
/** A custom (named or inline) action handed to the executor. The executor calls `exec(args, params)`. */
export interface ExecutableCustomAction<TContext extends MachineContext, TEvent extends EventObject> {
    /** Action name, `fn.name` or `"(anonymous)"`. */
    readonly type: string;
    readonly exec: ActionFunction<TContext, MachineEvent<TEvent>, unknown>;
    /** `{ context, event }` with the context as of this action (earlier assigns applied). */
    readonly args: ActionArgs<TContext, MachineEvent<TEvent>>;
    readonly params: unknown;
}
export interface ScheduleRequest<TEvent extends EventObject> {
    readonly event: MachineEvent<TEvent>;
    /** Milliseconds, already resolved (named delays and delay functions applied). */
    readonly delay: number;
    /** `raise` / `after` id for `cancel`; `undefined` means "not cancellable by id". */
    readonly id: string | undefined;
}
/**
 * Side-effect boundary of the core. The engine (`Statechart`) implements it;
 * unit tests use a recording executor.
 */
export interface ActionExecutor<TContext extends MachineContext, TEvent extends EventObject> {
    custom(action: ExecutableCustomAction<TContext, TEvent>): void;
    /** Delayed `raise` (including `after`). */
    schedule(request: ScheduleRequest<TEvent>): void;
    /** `cancel(id)` builtin and the synthesized `after` cancels. */
    cancel(id: string): void;
    /** `log` builtin; `label` is `undefined` when absent. */
    log(value: unknown, label: string | undefined): void;
}
export interface InterpreterScope<TContext extends MachineContext, TEvent extends EventObject> {
    readonly implementations: ResolvedMachineImplementations<TContext, TEvent>;
    readonly executor: ActionExecutor<TContext, TEvent>;
    /** Throws `Error("Infinite loop detected: ...")` when a macrostep exceeds it. */
    readonly maxMicrosteps: number;
}
export interface StepResult<TContext extends MachineContext, TEvent extends EventObject> {
    /** The same object as the input state when nothing changed. */
    readonly state: MachineState<TContext, TEvent>;
}
/**
 * XState `evaluateGuard`: names resolve through `implementations.guards`
 * (recursively — an implementation may itself be a builtin), `{ type, params }`
 * resolves dynamic params, builtins `and` / `or` / `not` / `stateIn` are
 * evaluated structurally. Throws `Error("Guard '<name>' is not implemented.")`.
 */
export declare function evaluateGuard<TContext extends MachineContext, TEvent extends EventObject>(guard: ModelGuard<TContext, TEvent>, args: ActionArgs<TContext, MachineEvent<TEvent>>, model: MachineModel<TContext, TEvent>, state: MachineState<TContext, TEvent>, scope: InterpreterScope<TContext, TEvent>): boolean;
/**
 * XState `getTransitionData` + `next`: the enabled transitions for `event`
 * (guards evaluated, first match per node, descendants shadow ancestors,
 * parallel regions concatenated). Empty when nothing is enabled.
 */
export declare function selectTransitions<TContext extends MachineContext, TEvent extends EventObject>(model: MachineModel<TContext, TEvent>, state: MachineState<TContext, TEvent>, event: MachineEvent<TEvent>, scope: InterpreterScope<TContext, TEvent>): readonly Transition<TContext, TEvent>[];
/**
 * Initial macrostep: pre-initial state (`context` factory, root only) ->
 * initial microstep (`reenter: true` into the initial nodes, no exits) ->
 * `macrostep` with the `xstate.init` event draining the internal queue.
 * Port of `StateMachine.getInitialSnapshot` + `initialMicrostep`.
 */
export declare function initialize<TContext extends MachineContext, TEvent extends EventObject>(model: MachineModel<TContext, TEvent>, scope: InterpreterScope<TContext, TEvent>): StepResult<TContext, TEvent>;
/**
 * One full macrostep for `event` (XState `macrostep`): select transitions,
 * microstep, then loop over `always` transitions and the internal queue until
 * stable or `status !== "active"`. `xstate.stop` -> `status: "stopped"`
 * without running any action. Throws whatever an action/guard/delay threw
 * (guard errors wrapped like XState); the caller commits the error status.
 *
 * A state that is no longer `active` (done / error / stopped) is returned
 * unchanged for any event: XState never lets a finished actor transition.
 */
export declare function step<TContext extends MachineContext, TEvent extends EventObject>(model: MachineModel<TContext, TEvent>, state: MachineState<TContext, TEvent>, event: MachineEvent<TEvent>, scope: InterpreterScope<TContext, TEvent>): StepResult<TContext, TEvent>;
/**
 * XState `snapshot.can`: some selected transition has a target or actions
 * (a "forbidden" transition alone does not count). Always `false` when the
 * state is not `active`.
 */
export declare function canHandle<TContext extends MachineContext, TEvent extends EventObject>(model: MachineModel<TContext, TEvent>, state: MachineState<TContext, TEvent>, event: MachineEvent<TEvent>, scope: InterpreterScope<TContext, TEvent>): boolean;
/** Builds the public, frozen snapshot of a state (value, tags, status, context, output, error). */
export declare function createSnapshot<TContext extends MachineContext, TEvent extends EventObject, TOutput = unknown>(model: MachineModel<TContext, TEvent>, state: MachineState<TContext, TEvent>): MachineSnapshot<TContext, TOutput>;