import { Environment, ValueType, Expression, Pattern } from './types';
type TokenMap = {
    [placeKey: string]: Token[];
};
type PlaceExtensions = {
    [key: string]: any;
};
type PlaceObject = {
    key: string;
    displayName: string;
    extensions: PlaceExtensions;
};
declare class Place {
    readonly key: string;
    readonly displayName: string;
    readonly extensions: PlaceExtensions;
    constructor(key: string, displayName: string, extensions: PlaceExtensions);
    static fromObject(net: PetriNet, data: PlaceObject): Place;
    toObject(): PlaceObject;
}
type TokenObject = {
    readonly color: ValueType;
};
declare class Token {
    readonly color: ValueType;
    constructor(color: ValueType);
    static fromObject(data: TokenObject): Token;
    toObject(): TokenObject;
}
type ConcurrentMoveObject = {
    readonly marking: MarkingObject;
    readonly moves: MoveObject[];
};
declare class ConcurrentMove {
    readonly net: PetriNet;
    readonly marking: Marking;
    readonly moves: Move[];
    constructor(net: PetriNet, marking: Marking, moves: Move[]);
    toObject(): ConcurrentMoveObject;
}
type MoveObject = {
    readonly marking: MarkingObject | null;
    readonly transition: string;
    readonly consumedTokens: {
        [placeKey: string]: TokenObject[];
    };
    readonly environment: Environment;
    readonly producedTokens: {
        [placeKey: string]: TokenObject[];
    };
};
declare class Move {
    readonly net: PetriNet;
    readonly marking: Marking | null;
    readonly transition: Transition;
    readonly consumedTokens: {
        [placeKey: string]: Token[];
    };
    readonly environment: Environment;
    readonly producedTokens: {
        [placeKey: string]: Token[];
    };
    constructor(net: PetriNet, marking: Marking | null, transition: Transition, consumedTokens: {
        [placeKey: string]: Token[];
    }, environment: Environment, producedTokens: {
        [placeKey: string]: Token[];
    });
    toObject(): MoveObject;
}
type MarkingExtensions = {
    [key: string]: any;
};
type MarkingObject = {
    readonly tokens: {
        [placeKey: string]: TokenObject[];
    };
    readonly extensions: MarkingExtensions;
};
declare class Marking {
    readonly net: PetriNet;
    readonly tokens: TokenMap;
    readonly extensions: MarkingExtensions;
    readonly previousMarking: Marking | null;
    constructor(net: PetriNet, tokens: TokenMap, extensions: MarkingExtensions, previousMarking: Marking | null);
    static fromObject(net: PetriNet, data: MarkingObject): Marking;
    toObject(): MarkingObject;
    /**
     * Returns something equivalent to `JSON.stringify(toObject())`, but guarantees that two equivalent markings return an identical string.
     * This is done by ensuring keys are sorted.
     * **Careful:** This only supports extensions that have [[TokenValue]]-like types.
     */
    toStableJSON(): string;
    cloneTokens(): TokenMap;
    enabledMoves(options?: {
        ignoreInFlowTokenCounts: boolean;
    }): Move[];
    enabledConcurrentMoves(options: {
        ignoreInFlowTokenCounts: boolean;
    }): ConcurrentMove[];
}
type TransitionExtensions = {
    [key: string]: any;
};
type InFlow = {
    readonly source: Place;
    readonly pattern: string | null;
    readonly compiledPattern: Pattern | null;
};
type InFlowObject = {
    source: string;
    pattern: string | null;
};
type InFlowIntermediate = {
    readonly source: Place;
    readonly pattern: string | null;
};
type OutFlow = {
    readonly target: Place;
    readonly expression: string | null;
    readonly compiledExpression: Expression | null;
};
type OutFlowObject = {
    target: string;
    expression: string | null;
};
type OutFlowIntermediate = {
    readonly target: Place;
    readonly expression: string | null;
};
type TransitionObject = {
    key: string;
    displayName: string;
    guard: string | null;
    inFlows: InFlowObject[];
    outFlows: OutFlowObject[];
    extensions: TransitionExtensions;
};
declare class Transition {
    private static _registeredTransitionTypes;
    static get registeredTransitionTypes(): {
        [key: string]: {
            type: typeof Transition;
        };
    };
    static readonly registerTransitionType: (name: string, type: typeof Transition) => void;
    readonly key: string;
    readonly displayName: string;
    readonly guard: string | null;
    private readonly compiledGuard;
    readonly inFlows: InFlow[];
    readonly outFlows: OutFlow[];
    readonly extensions: TransitionExtensions;
    constructor(key: string, displayName: string, guard: string | null, inFlows: InFlowIntermediate[], outFlows: OutFlowIntermediate[], extensions: TransitionExtensions);
    static fromObject(net: PetriNet, data: TransitionObject): Transition;
    inFlowsAsObject(): InFlowObject[];
    outFlowsAsObject(): OutFlowObject[];
    toObject(): TransitionObject;
    enabledMovesForMarking(marking: Marking, options?: {
        ignoreInFlowTokenCounts: boolean;
    }): Move[];
}
type PetriNetExtensions = {
    [key: string]: any;
};
type PetriNetObject = {
    readonly places: PlaceObject[];
    readonly transitions: TransitionObject[];
    readonly initialMarking: MarkingObject;
    readonly extensions: PetriNetExtensions;
};
declare class PetriNet {
    private _places;
    private _transitions;
    private _initialMarking;
    private _extensions;
    get places(): {
        [placeKey: string]: Place;
    };
    get transitions(): {
        [transitionKey: string]: Transition;
    };
    get initialMarking(): Marking;
    get extensions(): PetriNetExtensions;
    static fromObject(data: PetriNetObject): PetriNet;
    toObject(): PetriNetObject;
}
export { Place, PlaceObject, Transition, TransitionObject, InFlow, OutFlow, InFlowIntermediate, OutFlowIntermediate, InFlowObject, OutFlowObject, TransitionExtensions, Token, TokenObject, Move, MoveObject, Marking, MarkingObject, MarkingExtensions, PetriNet, PetriNetObject };