import { Machine, type AnyMachine } from './Machine';
import type { Config, ConfigTypes, IsAsyncConfig, Param, StateDefinition } from './types';
export type InterpreterOptions<TC> = {
    overflow?: number;
} & (object extends TC ? {
    context?: TC;
} : {
    context: TC;
});
declare class Interpreter<const C extends Config, const T extends ConfigTypes<C> = ConfigTypes<C>> {
    #private;
    protected _context: T['context'];
    protected _currentState: StateDefinition<T['events'], T['context'], T['data']>;
    constructor(machine: Machine<C, T>, options?: InterpreterOptions<T['context']>);
    get machine(): Machine<C, T>;
    protected readonly _initializeStates: () => void;
    protected readonly _setCurrentState: (value: string) => void;
    setInitialContext: (context: T["context"]) => void;
    readonly build: (...events: Param<T["events"]>) => NonNullable<T["data"]>;
    readonly buildAsync: (...events: Param<T["events"]>) => Promise<NonNullable<T["data"]>>;
}
export { type Interpreter };
type ReturnAsync<Async extends boolean, TA, R> = true extends Async ? (...events: Param<TA>) => Promise<NonNullable<R>> : (...events: Param<TA>) => NonNullable<R>;
export declare function interpret<const M extends AnyMachine>(machine: M, options?: InterpreterOptions<M['__types']['context']>): ReturnAsync<IsAsyncConfig<M['__config']>, M['__types']['events'], M['__types']['data']>;
//# sourceMappingURL=interpreter.d.ts.map