import { ICombinator, ParsingActionOwner } from '../../combinators/abstract';
import { Rule } from '../../rules/rule';
import { Grammar } from '../../grammar';
import { RuleComponent } from '../../abstract/component';
export declare type PeggificationMachineGenerator = (currentContext: SerializationContext) => SerializationContext | Generator<any, any, any>;
export declare type PeggificationMachine = Map<any, PeggificationMachineGenerator>;
declare type ContextParameters = {
    parent?: SerializationContext;
    grammar: Grammar;
    component?: RuleComponent;
    machine?: PeggificationMachine;
    serializer?: MutatorMap<any>;
};
export declare type Mutator<T> = (pattern: ICombinator | any, context: SerializationContext<T>) => Promise<T>;
export interface MutatorMap<T> extends Map<any, Mutator<T>> {
    normalize(component: Rule | RuleComponent | ParsingActionOwner, parentContext: SerializationContext<T>, fragment: T): Promise<T>;
}
export declare class ParsingScene {
    protected _openContexts: Set<SerializationContext<unknown>>;
    get openContexts(): Set<SerializationContext>;
    open(context: SerializationContext): this;
    close(context: SerializationContext): this;
}
export declare class SerializationContext<T = unknown> {
    private readonly _parentContext;
    private readonly _component;
    private readonly _nestingLevel;
    private readonly _scene;
    private readonly _serializers;
    private readonly _grammar;
    constructor({ parent, component, serializer, grammar }: ContextParameters);
    get grammar(): Grammar;
    get component(): RuleComponent | undefined;
    get serializers(): MutatorMap<any>;
    get scene(): ParsingScene;
    get nestingLevel(): number;
    get parentContext(): SerializationContext | undefined;
    enter<RType>(parameters: Partial<ContextParameters>): SerializationContext<RType>;
    exit({}: {
        component: RuleComponent;
        closeParents?: boolean;
    }): SerializationContext<unknown>;
}
export {};