export declare type Dict<T = any> = Record<string, T>;
export declare type MaybeArray<T> = T | T[];
export declare namespace StateMachine {
    type EventObject = {
        type: string;
    };
    type Event = string | EventObject;
    type EventWithSrc = EventObject & {
        src?: any;
    };
    type Expression<TContext extends Dict, TEvent extends EventObject, TReturn> = (context: TContext, event: TEvent) => TReturn;
    interface AnyEventObject extends EventObject {
        [key: string]: any;
    }
    type Action<TContext extends Dict, TEvent extends EventObject> = string | Expression<TContext, TEvent, void>;
    type Actions<TContext extends Dict, TEvent extends EventObject> = MaybeArray<Action<TContext, TEvent>>;
    type TransitionDefinition<TContext extends Dict, TState extends string, TEvent extends EventObject> = {
        target?: TState;
        actions?: Actions<TContext, TEvent>;
        cond?: Condition<TContext, TEvent>;
    };
    type TransitionDefinitionWithDelay<TContext extends Dict, TState extends string, TEvent extends EventObject> = TransitionDefinition<TContext, TState, TEvent> & {
        delay?: Delay<TContext, TEvent>;
    };
    type Delay<TContext extends Dict, TEvent extends EventObject> = string | number | Expression<TContext, TEvent, number>;
    type Transition<TContext extends Dict, TState extends string, TEvent extends EventObject> = TState | TransitionDefinition<TContext, TState, TEvent>;
    type Activity<TContext extends Dict, TEvent extends EventObject> = Expression<TContext, TEvent, VoidFunction>;
    type Activities<TContext extends Dict, TEvent extends EventObject> = MaybeArray<Activity<TContext, TEvent>>;
    type Transitions<TContext extends Dict, TState extends string, TEvent extends EventObject> = Transition<TContext, TState, TEvent> | MaybeArray<TransitionDefinition<TContext, TState, TEvent>>;
    type AfterTransitions<TContext, TState extends string, TEvent extends EventObject> = Record<string | number, TState | MaybeArray<TransitionDefinition<TContext, TState, TEvent>>> | Array<TransitionDefinition<TContext, TState, TEvent> & {
        delay: number | string | Expression<TContext, TEvent, number>;
    }>;
    type ExtractEvent<TEvent extends EventObject, K> = K extends TEvent["type"] ? Extract<TEvent, {
        type: K;
    }> : EventObject;
    type TransitionDefinitionMap<TContext, TState extends string, TEvent extends EventObject> = {
        [K in TEvent["type"]]?: TState | MaybeArray<TransitionDefinition<TContext, TState, ExtractEvent<TEvent, K>>>;
    };
    interface StateNode<TContext extends Dict, TState extends string, TEvent extends EventObject> {
        type?: "final";
        /**
         * The tags for the state node.
         */
        tags?: string[];
        /**
         * The activities to be started upon entering the state node,
         * and stopped upon exiting the state node.
         */
        activities?: Activities<TContext, TEvent>;
        /**
         * The mapping of event types to their potential transition(s).
         */
        on?: TransitionDefinitionMap<TContext, TState, TEvent>;
        /**
         * The action(s) to be executed upon entering the state node.
         */
        entry?: Actions<TContext, TEvent>;
        /**
         * The action(s) to be executed upon exiting the state node.
         */
        exit?: Actions<TContext, TEvent>;
        /**
         * The mapping (or array) of delays (in `ms`) to their potential transition(s) to run after
         * the specified delay. Uses `setTimeout` under the hood.
         */
        after?: AfterTransitions<TContext, TState, TEvent>;
        /**
         * An eventless transition that is always taken when this state is active.
         */
        always?: MaybeArray<TransitionDefinition<TContext, TState, TEvent>>;
        /**
         * The mapping (or array) of intervals (in `ms`) to their potential actions(s) to run at interval.
         *  Uses `setInterval` under the hood.
         */
        every?: Record<string | number, Actions<TContext, TEvent>> | Array<{
            interval?: number | string | Expression<TContext, TEvent, number>;
            actions: Actions<TContext, TEvent>;
            cond?: string | Expression<TContext, TEvent, boolean>;
        }>;
    }
    type ConditionHelper<TContext extends Dict, TEvent extends EventObject> = {
        exec: (guards: Dict) => Expression<TContext, TEvent, boolean>;
    };
    type Condition<TContext extends Dict, TEvent extends EventObject> = string | Expression<TContext, TEvent, boolean> | ConditionHelper<TContext, TEvent>;
    interface MachineConfig<TContext extends Dict, TState, TEvent extends EventObject> {
        /**
         * The unique identifier for the invoked machine.
         */
        id?: string;
        /**
         * The extended state used to store `data` for your machine
         */
        context?: TContext;
        /**
         * The initial state to start with
         */
        initial?: TState;
        /**
         * The mapping of state node keys to their state node configurations (recursive).
         */
        states?: Partial<Record<TState, StateNode<TContext, TState, TEvent>>>;
        /**
         * The `id` of the parent machine for this
         */
        parent?: string;
        on?: TransitionDefinitionMap<TContext, TState, TEvent>;
    }
    type SubscribeFunction<TContext> = (state: State<TContext>) => void;
    interface State<TContext extends Dict> {
        current: string;
        prev: string;
        event: string | string[];
        context: TContext;
        done: boolean;
        matches(value: string | string[]): boolean;
        hasTag(value: string): boolean;
        nextEvents: string[];
        changed: boolean;
        tags: Set<string>;
        [key: string]: any;
    }
    interface StateInfo<TContext extends Dict, TState extends string, TEvent extends EventObject> {
        transition: TransitionDefinition<TContext, TState, TEvent> | undefined;
        stateNode: StateNode<TContext, TState, TEvent> | undefined;
        hasTarget: boolean;
        isTransient: boolean;
        target: string | undefined;
    }
    type ActionsMap<TContext extends Dict, TEvent extends EventObject> = Record<string, Exclude<Action<TContext, TEvent>, string>>;
    type GuardsMap<TContext extends Dict, TEvent extends EventObject> = Record<string, Expression<TContext, TEvent, boolean>>;
    type TimersMap<TContext extends Dict, TEvent extends EventObject> = {
        [delay: string]: number | Expression<TContext, TEvent, number>;
    };
    interface MachineOptions<TContext extends Dict, TEvent extends EventObject> {
        /**
         * The computed value to derive from the current context
         */
        computed?: Dict<(context: TContext) => any>;
        guards?: GuardsMap<TContext, TEvent>;
        actions?: ActionsMap<TContext, TEvent>;
        delays?: TimersMap<TContext, TEvent>;
    }
}
//# sourceMappingURL=types.d.ts.map