declare abstract class Element$1 {
    private _id;
    protected constructor(id: string);
    get id(): string;
    set id(value: string);
    compare(other: Element$1): number;
}

declare class I18nString {
    private _name?;
    private _value;
    constructor(translation: string, name?: string);
    get name(): string | undefined;
    set name(value: string | undefined);
    get value(): string;
    set value(value: string);
    clone(): I18nString;
    isEmpty(): boolean;
}

declare abstract class NodeElement extends Element$1 {
    private _x;
    private _y;
    private _label;
    protected constructor(id: string, x: number, y: number, label: I18nString);
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get label(): I18nString;
    set label(value: I18nString);
}

declare enum ArcType {
    REGULAR_PT = "regular_pt",
    REGULAR_TP = "regular_tp",
    READ = "read",
    RESET = "reset",
    INHIBITOR = "inhibitor"
}
declare enum XmlArcType {
    REGULAR = "regular",
    READ = "read",
    RESET = "reset",
    INHIBITOR = "inhibitor"
}

declare class Breakpoint {
    private _x;
    private _y;
    constructor(x: number, y: number);
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    clone(): Breakpoint;
}

declare abstract class Arc<S extends NodeElement, D extends NodeElement> extends Element$1 {
    private _source;
    private _destination;
    private _multiplicity;
    private _reference?;
    private _breakpoints;
    constructor(source: S, target: D, id: string);
    static arcTypeMapping: Map<ArcType, XmlArcType>;
    abstract get type(): ArcType;
    get source(): S;
    set source(value: S);
    get destination(): D;
    set destination(value: D);
    get multiplicity(): number;
    set multiplicity(value: number);
    get reference(): string | undefined;
    set reference(value: string | undefined);
    get breakpoints(): Array<Breakpoint>;
    set breakpoints(value: Array<Breakpoint>);
    cloneAttributes(cloned: Arc<S, D>): void;
    abstract clone(): Arc<S, D>;
}

declare class I18nWithDynamic extends I18nString {
    private _dynamic;
    constructor(value: string, name?: string, dynamic?: boolean);
    get dynamic(): boolean;
    set dynamic(value: boolean);
    clone(): I18nWithDynamic;
}

declare enum IconType {
    MATERIAL = "material",
    SVG = "svg"
}

declare class Icon {
    private _key;
    private _icon;
    private _type;
    constructor(key: string, icon: string, type?: IconType);
    get key(): string;
    set key(value: string);
    get icon(): string;
    set icon(value: string);
    get type(): IconType;
    set type(value: IconType);
    clone(): Icon;
}

declare class Property {
    private _key;
    private _value;
    constructor(key: string, value: string);
    get key(): string;
    set key(value: string);
    get value(): string;
    set value(value: string);
    clone(): Property;
}

declare class Component {
    private _name;
    private _properties;
    private _icons;
    constructor(name: string);
    get name(): string;
    set name(value: string);
    get properties(): Array<Property>;
    set properties(value: Array<Property>);
    get icons(): Array<Icon>;
    set icons(value: Array<Icon>);
    clone(): Component;
}

declare class Action extends Element$1 {
    private _definition;
    constructor(id: string, definition: string);
    get definition(): string;
    set definition(value: string);
    clone(): Action;
}

declare enum EventPhase {
    PRE = "pre",
    POST = "post"
}

declare abstract class Event<T> extends Element$1 {
    private _type;
    private readonly _preActions;
    private readonly _postActions;
    private _message;
    protected constructor(type: T, id: string);
    get type(): T;
    set type(value: T);
    get preActions(): Array<Action>;
    get postActions(): Array<Action>;
    get message(): I18nString;
    set message(value: I18nString);
    addAction(action: Action, phase: EventPhase): void;
    isEmpty(): boolean;
}

declare abstract class EventSource<T extends Event<S>, S> {
    private readonly _events;
    protected constructor();
    protected get events(): Map<S, T>;
    getEvents(): Array<T>;
    getEvent(type: S): T | undefined;
    addEvent(event: T): void;
    removeEvent(type: S): void;
    mergeEvent(event: T): void;
}

declare enum DataEventType {
    SET = "set",
    GET = "get"
}

declare class DataEvent extends Event<DataEventType> {
    constructor(type: DataEventType, id: string);
    clone(): DataEvent;
}

declare abstract class DataEventSource extends EventSource<DataEvent, DataEventType> {
    addAction(action: Action, type: DataEventType, phase?: EventPhase): void;
}

declare enum DataType {
    NUMBER = "number",
    TEXT = "text",
    ENUMERATION = "enumeration",
    ENUMERATION_MAP = "enumeration_map",
    MULTICHOICE = "multichoice",// cspell:disable-line
    MULTICHOICE_MAP = "multichoice_map",// cspell:disable-line
    BOOLEAN = "boolean",
    DATE = "date",
    DATETIME = "dateTime",// cspell:disable-line
    FILE = "file",
    FILE_LIST = "fileList",
    USER = "user",
    USER_LIST = "userList",
    BUTTON = "button",
    TASK_REF = "taskRef",
    CASE_REF = "caseRef",
    FILTER = "filter",
    I18N = "i18n"
}

declare class Expression {
    private _dynamic;
    private _expression;
    constructor(expression: string, dynamic?: boolean);
    get dynamic(): boolean;
    set dynamic(value: boolean);
    get expression(): string;
    set expression(value: string);
    clone(): Expression;
}

declare class Option {
    private _key;
    private _value;
    constructor(key?: string, value?: I18nString);
    get key(): string;
    set key(value: string);
    get value(): I18nString;
    set value(value: I18nString);
    static of(key: string, value: I18nString): Option;
    clone(): Option;
}

declare class Validation {
    private _expression?;
    private _message;
    constructor();
    get expression(): Expression | undefined;
    set expression(value: Expression | undefined);
    get message(): I18nString;
    set message(value: I18nString);
    clone(): Validation;
}

declare class DataVariable extends DataEventSource {
    private _id;
    private _title;
    private _placeholder;
    private _desc;
    private _options;
    private _optionsInit?;
    private _validations;
    private _init?;
    private _inits;
    private _component?;
    private _type;
    private _immediate;
    private _encryption?;
    private _remote?;
    private _actionRef;
    private _length?;
    private _allowedNets;
    constructor(id: string, type: DataType);
    get id(): string;
    set id(value: string);
    get title(): I18nString;
    set title(value: I18nString);
    get placeholder(): I18nString;
    set placeholder(value: I18nString);
    get desc(): I18nString;
    set desc(value: I18nString);
    get options(): Array<Option>;
    set options(value: Array<Option>);
    get optionsInit(): Expression | undefined;
    set optionsInit(value: Expression | undefined);
    get validations(): Array<Validation>;
    set validations(value: Array<Validation>);
    get init(): I18nWithDynamic | undefined;
    set init(value: I18nWithDynamic | undefined);
    get inits(): Array<I18nWithDynamic>;
    set inits(value: Array<I18nWithDynamic>);
    get component(): Component | undefined;
    set component(value: Component | undefined);
    get type(): DataType;
    set type(value: DataType);
    get immediate(): boolean;
    set immediate(value: boolean);
    get encryption(): string | undefined;
    set encryption(value: string | undefined);
    get remote(): boolean | undefined;
    set remote(value: boolean | undefined);
    get actionRef(): Array<string>;
    set actionRef(value: Array<string>);
    get length(): number | undefined;
    set length(value: number | undefined);
    get allowedNets(): Array<string>;
    set allowedNets(value: Array<string>);
    clone(): DataVariable;
    compare(other: DataVariable): number;
}

declare class I18nTranslations {
    private _locale;
    private _i18ns;
    constructor(locale: string);
    get locale(): string;
    set locale(value: string);
    getI18ns(): Array<I18nString>;
    getI18n(name: string): I18nString | undefined;
    addI18n(value: I18nString): void;
    removeI18n(name: string): void;
    clone(): I18nTranslations;
}

declare enum CaseEventType {
    CREATE = "create",
    DELETE = "delete"
}

declare class CaseEvent extends Event<CaseEventType> {
    constructor(type: CaseEventType, id: string);
    clone(): CaseEvent;
}

declare enum Appearance {
    LEGACY = "legacy",
    STANDARD = "standard",
    FILL = "fill",
    OUTLINE = "outline"
}

declare enum Alignment {
    TOP = "top",
    CENTER = "center",
    BOTTOM = "bottom"
}

declare abstract class Layout {
    private _rows?;
    private _cols?;
    private _offset?;
    private _alignment?;
    get rows(): number | undefined;
    set rows(value: number | undefined);
    get cols(): number | undefined;
    set cols(value: number | undefined);
    get offset(): number | undefined;
    set offset(value: number | undefined);
    get alignment(): Alignment | undefined;
    set alignment(value: Alignment | undefined);
}

declare enum Template {
    MATERIAL = "material",
    NETGRIF = "netgrif"
}

declare class DataLayout extends Layout {
    private _x;
    private _y;
    private _template;
    private _appearance;
    constructor(x?: number, y?: number, template?: Template, appearance?: Appearance);
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    get template(): Template;
    set template(value: Template);
    get appearance(): Appearance;
    set appearance(value: Appearance);
    clone(): DataLayout;
}

declare enum DataRefBehavior {
    REQUIRED = "required",
    IMMEDIATE = "immediate",
    OPTIONAL = "optional",
    VISIBLE = "visible",
    EDITABLE = "editable",
    HIDDEN = "hidden",
    FORBIDDEN = "forbidden"
}

declare class DataRefLogic {
    private _behavior;
    private _required;
    private _immediate;
    private _actionRefs;
    constructor();
    get behavior(): DataRefBehavior;
    set behavior(value: DataRefBehavior);
    get required(): boolean;
    set required(value: boolean);
    get immediate(): boolean;
    set immediate(value: boolean);
    get actionRefs(): Array<string>;
    set actionRefs(value: Array<string>);
    clone(): DataRefLogic;
}

declare class DataRef extends DataEventSource {
    private _id;
    private _logic;
    private _layout;
    private _component?;
    constructor(id: string);
    get id(): string;
    set id(value: string);
    get logic(): DataRefLogic;
    set logic(value: DataRefLogic);
    get layout(): DataLayout;
    set layout(value: DataLayout);
    get component(): Component | undefined;
    set component(value: Component | undefined);
    clone(): DataRef;
}

declare enum CompactDirection {
    UP = "up",
    NONE = "none"
}

declare enum HideEmptyRows {
    ALL = "all",
    COMPACTED = "compacted",
    NONE = "none"
}

declare enum LayoutType {
    FLOW = "flow",
    GRID = "grid",
    LEGACY = "legacy"
}

declare class DataGroup {
    private _id;
    private _cols?;
    private _rows?;
    private _title?;
    private _layout?;
    private _alignment?;
    private _stretch;
    private _hideEmptyRows?;
    private _compactDirection?;
    private _dataRefs;
    constructor(id: string);
    get id(): string;
    set id(value: string);
    get cols(): number | undefined;
    set cols(value: number | undefined);
    get rows(): number | undefined;
    set rows(value: number | undefined);
    get title(): I18nString | undefined;
    set title(value: I18nString | undefined);
    get layout(): LayoutType | undefined;
    set layout(value: LayoutType | undefined);
    get alignment(): Alignment | undefined;
    set alignment(value: Alignment | undefined);
    get stretch(): boolean;
    set stretch(value: boolean);
    get hideEmptyRows(): HideEmptyRows | undefined;
    set hideEmptyRows(value: HideEmptyRows | undefined);
    get compactDirection(): CompactDirection | undefined;
    set compactDirection(value: CompactDirection | undefined);
    getDataRefs(): Array<DataRef>;
    getDataRef(id: string): DataRef | undefined;
    addDataRef(ref: DataRef): void;
    removeDataRef(id: string): void;
    clone(): DataGroup;
}

declare abstract class PermissionRef<T> {
    private _id;
    private _logic;
    protected constructor(id: string, logic: T);
    get id(): string;
    set id(value: string);
    get logic(): T;
    set logic(value: T);
    compare(ref: PermissionRef<T>): number;
}

declare class Logic {
    private _perform?;
    private _delegate?;
    private _cancel?;
    private _assign?;
    private _view?;
    get perform(): boolean | undefined;
    set perform(value: boolean | undefined);
    get delegate(): boolean | undefined;
    set delegate(value: boolean | undefined);
    get cancel(): boolean | undefined;
    set cancel(value: boolean | undefined);
    get assign(): boolean | undefined;
    set assign(value: boolean | undefined);
    get view(): boolean | undefined;
    set view(value: boolean | undefined);
    clone(): Logic;
}

declare class TransitionPermissionRef extends PermissionRef<Logic> {
    constructor(id: string);
    clone(): TransitionPermissionRef;
}

declare enum TriggerType {
    AUTO = "auto",
    USER = "user",
    TIME = "time"
}

declare class Trigger {
    private _type;
    private _delay?;
    private _exact?;
    constructor(type?: TriggerType);
    get type(): TriggerType;
    set type(value: TriggerType);
    get delay(): string | undefined;
    set delay(value: string | undefined);
    get exact(): Date | undefined;
    set exact(value: Date | undefined);
    clone(): Trigger;
}

declare class Mapping extends Element$1 {
    private _transitionRef;
    private _roleRef;
    private _dataRef;
    private _dataGroup;
    private _trigger;
    constructor(id: string, transRef: string);
    get transitionRef(): string;
    set transitionRef(value: string);
    get roleRef(): Array<TransitionPermissionRef>;
    set roleRef(value: Array<TransitionPermissionRef>);
    get dataRef(): Array<DataRef>;
    set dataRef(value: Array<DataRef>);
    get dataGroup(): Array<DataGroup>;
    set dataGroup(value: Array<DataGroup>);
    get trigger(): Array<Trigger>;
    set trigger(value: Array<Trigger>);
    clone(): Mapping;
}

declare enum FunctionScope {
    NAMESPACE = "namespace",
    PROCESS = "process"
}

declare class PetriflowFunction {
    private _name;
    private _scope;
    private _definition;
    constructor(name: string, scope: FunctionScope, definition?: string);
    get name(): string;
    set name(value: string);
    get scope(): FunctionScope;
    set scope(value: FunctionScope);
    get definition(): string;
    set definition(value: string);
    clone(): PetriflowFunction;
    compare(other: PetriflowFunction): number;
}

declare class Place extends NodeElement {
    private _static;
    private _marking;
    constructor(x: number, y: number, isStatic: boolean, id: string);
    get static(): boolean;
    set static(value: boolean);
    get marking(): number;
    set marking(value: number);
    clone(): Place;
}

declare enum ProcessEventType {
    UPLOAD = "upload"
}

declare class ProcessEvent extends Event<ProcessEventType> {
    constructor(type: ProcessEventType, id: string);
    clone(): ProcessEvent;
}

declare class CaseLogic {
    private _create?;
    private _delete?;
    private _view?;
    get create(): boolean | undefined;
    set create(value: boolean | undefined);
    get delete(): boolean | undefined;
    set delete(value: boolean | undefined);
    get view(): boolean | undefined;
    set view(value: boolean | undefined);
    clone(): CaseLogic;
}

declare class ProcessPermissionRef extends PermissionRef<CaseLogic> {
    constructor(id: string);
    clone(): ProcessPermissionRef;
}

declare class Transaction extends Element$1 {
    private _title;
    constructor(id: string, title: I18nString);
    get title(): I18nString;
    set title(value: I18nString);
    clone(): Transaction;
}

declare enum RoleEventType {
    ASSIGN = "assign",
    CANCEL = "cancel"
}

declare class RoleEvent extends Event<RoleEventType> {
    private _title;
    constructor(type: RoleEventType, id: string);
    get title(): I18nString;
    set title(value: I18nString);
    clone(): RoleEvent;
    isEmpty(): boolean;
}

declare class Role extends EventSource<RoleEvent, RoleEventType> {
    static readonly ANONYMOUS = "anonymous";
    static readonly DEFAULT = "default";
    private _id;
    private _title;
    private _global;
    constructor(id: string);
    get id(): string;
    set id(value: string);
    get title(): I18nString;
    set title(value: I18nString);
    get global(): boolean;
    set global(value: boolean);
    clone(): Role;
    compare(other: Role): number;
}

declare enum AssignPolicy {
    MANUAL = "manual",
    AUTO = "auto"
}

declare class AssignedUser {
    private _cancel?;
    private _reassign?;
    get cancel(): boolean | undefined;
    set cancel(value: boolean | undefined);
    get reassign(): boolean | undefined;
    set reassign(value: boolean | undefined);
    clone(): AssignedUser;
}

declare enum DataFocusPolicy {
    MANUAL = "manual",
    AUTO_EMPTY_REQUIRED = "auto_empty_required"
}

declare enum FinishPolicy {
    MANUAL = "manual",
    AUTO_NO_DATA = "auto_no_data"
}

declare enum TransitionEventType {
    ASSIGN = "assign",
    FINISH = "finish",
    CANCEL = "cancel",
    DELEGATE = "delegate"
}

declare class TransitionEvent extends Event<TransitionEventType> {
    private _title;
    constructor(type: TransitionEventType, id: string);
    get title(): I18nString;
    set title(value: I18nString);
    clone(): TransitionEvent;
    isEmpty(): boolean;
}

declare class TransitionEventSource extends EventSource<TransitionEvent, TransitionEventType> {
    constructor();
}

declare class TransitionLayout extends Layout {
    private _type?;
    private _hideEmptyRows?;
    private _compactDirection?;
    get type(): LayoutType | undefined;
    set type(value: LayoutType | undefined);
    get hideEmptyRows(): HideEmptyRows | undefined;
    set hideEmptyRows(value: HideEmptyRows | undefined);
    get compactDirection(): CompactDirection | undefined;
    set compactDirection(value: CompactDirection | undefined);
    empty(): boolean;
    clone(): TransitionLayout;
}

declare class Transition extends NodeElement {
    private _layout?;
    private _icon?;
    private _priority?;
    private _assignPolicy;
    private _finishPolicy;
    private _dataFocusPolicy;
    private _triggers;
    private _transactionRef?;
    private _roleRefs;
    private _userRefs;
    private _dataGroups;
    private _assignedUser?;
    private _eventSource;
    private _tags;
    constructor(x: number, y: number, id: string);
    get layout(): TransitionLayout | undefined;
    set layout(value: TransitionLayout | undefined);
    get icon(): string | undefined;
    set icon(value: string | undefined);
    get priority(): number | undefined;
    set priority(value: number | undefined);
    get assignPolicy(): AssignPolicy;
    set assignPolicy(value: AssignPolicy);
    get finishPolicy(): FinishPolicy;
    set finishPolicy(value: FinishPolicy);
    get dataFocusPolicy(): DataFocusPolicy;
    set dataFocusPolicy(value: DataFocusPolicy);
    get triggers(): Array<Trigger>;
    set triggers(value: Array<Trigger>);
    get transactionRef(): string | undefined;
    set transactionRef(value: string | undefined);
    get roleRefs(): Array<TransitionPermissionRef>;
    set roleRefs(value: Array<TransitionPermissionRef>);
    get userRefs(): Array<TransitionPermissionRef>;
    set userRefs(value: Array<TransitionPermissionRef>);
    get dataGroups(): Array<DataGroup>;
    set dataGroups(value: Array<DataGroup>);
    get assignedUser(): AssignedUser | undefined;
    set assignedUser(value: AssignedUser | undefined);
    get eventSource(): TransitionEventSource;
    set eventSource(value: TransitionEventSource);
    get tags(): Map<string, string>;
    set tags(value: Map<string, string>);
    clone(): Transition;
}

declare class PetriNet {
    private _id;
    private _version;
    private _lastChanged;
    private _initials;
    private _title;
    private _icon;
    private _defaultRole;
    private _anonymousRole;
    private _transitionRole;
    private _caseName;
    private _roleRefs;
    private _userRefs;
    private _processEvents;
    private _caseEvents;
    private _transactions;
    private _roles;
    private _functions;
    private _data;
    private _mappings;
    private _i18ns;
    private _transitions;
    private _places;
    private _arcs;
    private _tags;
    constructor();
    get id(): string;
    set id(value: string);
    get version(): string;
    set version(value: string);
    get lastChanged(): number;
    set lastChanged(value: number);
    get initials(): string;
    set initials(value: string);
    get title(): I18nString;
    set title(value: I18nString);
    get icon(): string;
    set icon(value: string);
    get defaultRole(): boolean;
    set defaultRole(value: boolean);
    get anonymousRole(): boolean;
    set anonymousRole(value: boolean);
    get transitionRole(): boolean;
    set transitionRole(value: boolean);
    get caseName(): I18nWithDynamic;
    set caseName(value: I18nWithDynamic);
    getRoleRefs(): Array<ProcessPermissionRef>;
    getRoleRef(id: string): ProcessPermissionRef | undefined;
    addRoleRef(roleRef: ProcessPermissionRef): void;
    removeRoleRef(id: string): void;
    getUserRefs(): Array<ProcessPermissionRef>;
    getUserRef(id: string): ProcessPermissionRef | undefined;
    addUserRef(userRef: ProcessPermissionRef): void;
    removeUserRef(id: string): void;
    getProcessEvents(): Array<ProcessEvent>;
    getProcessEvent(type: ProcessEventType): ProcessEvent | undefined;
    addProcessEvent(event: ProcessEvent): void;
    removeProcessEvent(type: ProcessEventType): void;
    getCaseEvents(): Array<CaseEvent>;
    getCaseEvent(type: CaseEventType): CaseEvent | undefined;
    addCaseEvent(event: CaseEvent): void;
    removeCaseEvent(type: CaseEventType): void;
    getTransactions(): Array<Transaction>;
    getTransaction(id: string): Transaction | undefined;
    addTransaction(transaction: Transaction): void;
    removeTransaction(id: string): void;
    getRoles(): Array<Role>;
    getRole(id: string): Role | undefined;
    addRole(role: Role): void;
    removeRole(id: string): void;
    get functions(): Array<PetriflowFunction>;
    set functions(value: Array<PetriflowFunction>);
    addFunction(value: PetriflowFunction): void;
    getDataSet(): Array<DataVariable>;
    getData(id: string): DataVariable | undefined;
    addData(dataVariable: DataVariable): void;
    removeData(id: string): void;
    getMappings(): Array<Mapping>;
    getMapping(id: string): Mapping | undefined;
    addMapping(mapping: Mapping): void;
    removeMapping(id: string): void;
    getI18ns(): Array<I18nTranslations>;
    getI18n(locale: string): I18nTranslations | undefined;
    addI18n(i18n: I18nTranslations): void;
    removeI18n(locale: string): void;
    getTransitions(): Array<Transition>;
    getTransition(id: string): Transition | undefined;
    addTransition(transition: Transition): void;
    removeTransition(id: string): void;
    getPlaces(): Array<Place>;
    getPlace(id: string): Place | undefined;
    addPlace(place: Place): void;
    removePlace(id: string): void;
    getArcs(): Array<Arc<NodeElement, NodeElement>>;
    getArc(id: string): Arc<NodeElement, NodeElement> | undefined;
    addArc(arc: Arc<NodeElement, NodeElement>): void;
    removeArc(id: string): void;
    get tags(): Map<string, string>;
    set tags(value: Map<string, string>);
    clone(): PetriNet;
}

declare abstract class PlaceTransitionArc extends Arc<Place, Transition> {
    abstract consume(): number;
    abstract canFire(): boolean;
    assertCanFire(): void;
}

declare class InhibitorArc extends PlaceTransitionArc {
    /**
     * Inhibitor arc does not consume any tokens from input place.
     * @returns always 0
     * @throws Error if firing precondition is not fulfilled.
     */
    consume(): number;
    /**
     * Inhibitor arc enables transition to fire if the input place contains fewer
     * tokens than the multiplicity of arc.
     * @returns true if place marking < multiplicity, false otherwise
     */
    canFire(): boolean;
    get type(): ArcType;
    clone(): InhibitorArc;
}

declare class ReadArc extends PlaceTransitionArc {
    /**
     * Read arc does not consume any tokens from input place.
     * @returns always 0
     * @throws Error if firing precondition is not fulfilled.
     */
    consume(): number;
    /**
     * Read arc enables transition to fire if the input place contains at least as
     * many tokens as the multiplicity of arc.
     * @returns true if place marking >= multiplicity, false otherwise
     */
    canFire(): boolean;
    get type(): ArcType;
    clone(): ReadArc;
}

declare class RegularPlaceTransitionArc extends PlaceTransitionArc {
    /**
     * Regular arc consumes number of tokens equal to its multiplicity.
     * @returns number of consumed tokens = multiplicity of arc
     * @throws Error if firing precondition is not fulfilled.
     */
    consume(): number;
    /**
     * Regular arc enables transition to fire if the input place contains at
     * least as many tokens as the multiplicity of arc.
     * @returns true if place marking >= multiplicity, false otherwise
     */
    canFire(): boolean;
    get type(): ArcType;
    clone(): RegularPlaceTransitionArc;
}

declare abstract class TransitionPlaceArc extends Arc<Transition, Place> {
    abstract produce(): void;
}

declare class RegularTransitionPlaceArc extends TransitionPlaceArc {
    /**
     * Regular arc produces number of tokens equal to its multiplicity.
     */
    produce(): void;
    get type(): ArcType;
    clone(): RegularTransitionPlaceArc;
}

declare class ResetArc extends PlaceTransitionArc {
    /**
     * Reset arc consumes all tokens from the input place. Since reset arc does
     * not impose any precondition on firing, this function does not throw any
     * error.
     * @returns number of consumed tokens = number of tokens in input place.
     */
    consume(): number;
    /**
     * Reset arc does not impose a precondition on firing.
     * @returns always true
     */
    canFire(): boolean;
    get type(): ArcType;
    clone(): ResetArc;
}

declare class ImportUtils {
    private eventIdCounter;
    private actionIdCounter;
    tagValue(xmlTag: Element | Document | null, child: string): string;
    parseI18n(xmlTag: Element | Document, child: string): I18nString;
    parseI18nWithDynamic(xmlTag: Element | Document, child: string): I18nWithDynamic;
    tagAttribute(xmlTag: Element | null, attribute: string): string;
    parseAction(actionTag: Element): Action;
    parseFunction(xmlFunction: Element): PetriflowFunction;
    parseDefinition(tag: Element): string;
    removeExcessiveIndents(action: string): string;
    parseEncryption(xmlTag: Element): string | undefined;
    parseViewAndComponent(xmlTag: Element): Component | undefined;
    parseComponent(xmlTag: Element): Component | undefined;
    parseProperty(property: Element): Property;
    resolveLogic(xmlRoleRefLogic: Element, roleRef: TransitionPermissionRef): void;
    resolveLogicValue(logicValue: string): boolean | undefined;
    resolveCaseLogic(xmlRoleRefLogic: Element, roleRef: ProcessPermissionRef): void;
    checkVariability(model: PetriNet, arc: Arc<NodeElement, NodeElement>, reference: string | undefined): void;
    attachReference(arc: Arc<NodeElement, NodeElement>, reference: Place | DataVariable): void;
    /**
     * Determines whether the given value is an initial numeric value.
     * This method checks if the provided `value` is defined, has a `value` property,
     * and passes the `initValueNumberTest` logic.
     *
     * @param {I18nWithDynamic} [value] - The value to be checked.
     * @return {boolean} Returns `true` if the value is an initial numeric value, otherwise `false`.
     */
    static isInitValueNumber(value?: I18nWithDynamic): boolean;
    /**
     * Validates whether the provided value in an I18nWithDynamic object is a valid positive number string.
     *
     * @param {I18nWithDynamic} [value] - The object containing the value to be tested.
     * @return {boolean} Returns true if the value exists, is non-empty, and matches the regex pattern for a positive number; otherwise, returns false.
     */
    static initValueNumberTest(value?: I18nWithDynamic): boolean;
    parseTrigger(xmlTrigger: Element): Trigger;
    parseRoleRef(xmlRoleRef: Element): TransitionPermissionRef;
    parseDataRef(xmlDataRef: Element, index: number): DataRef;
    parseDataLayout(xmlLayout: Element | null): DataLayout;
    parseDataGroup(xmlDataGroup: Element): DataGroup;
    parsePlaceStatic(xmlPlace: Element): boolean;
    parseArcType(xmlArc: Element): XmlArcType;
    parseEvent<T>(xmlEvent: Element, event: Event<T>): void;
    resolveInits(xmlData: Element): Array<I18nWithDynamic>;
    resolveInit(xmlData: Element): I18nWithDynamic | undefined;
    resolveInitValue(elementValue: Element | undefined): I18nWithDynamic | undefined;
    checkLengthAndNodes(element: Element, name: string): boolean;
    resolveFormat(xmlData: Element, data: DataVariable): void;
    parseNumberValue(element: Element | null, name: string): number | undefined;
    parseExpression(xmlTag: Element, name: string): Expression | undefined;
    private getNextEventId;
    private getNextActionId;
    resetEventId(): void;
    resetActionId(): void;
    resetIds(): void;
    parseTags(xmlDoc: Element | Document): Map<string, string>;
    parseTag(tags: Map<string, string>, tagElement: Element): void;
}

declare class PetriNetResult {
    private _model;
    private readonly _errors;
    private readonly _warnings;
    private readonly _info;
    constructor(model?: PetriNet);
    get model(): PetriNet;
    set model(value: PetriNet);
    get errors(): Array<string>;
    addError(error: string, e: Error): void;
    get warnings(): Array<string>;
    addWarning(warning: string): void;
    get info(): Array<string>;
    addInfo(value: string): void;
}

declare class ImportService {
    protected importUtils: ImportUtils;
    private static readonly PARSE_ERROR_LINE_EXTRACTION_REGEX;
    private static readonly DEFAULT_ROLE_DEFAULT_VALUE;
    private static readonly ANONYMOUS_ROLE_DEFAULT_VALUE;
    private static readonly TRANSITION_ROLE_DEFAULT_VALUE;
    constructor(importUtils?: ImportUtils);
    private parseXml;
    parseFromXml(txt: string): PetriNetResult;
    private importFromXml;
    importModel(modelResult: PetriNetResult, xmlDoc: Document): void;
    importRoles(modelResult: PetriNetResult, xmlDoc: Document): void;
    parseRole(model: PetriNet, xmlRole: Element, role: Role): void;
    importFunctions(modelResult: PetriNetResult, xmlDoc: Document): void;
    importEvents(modelResult: PetriNetResult, xmlDoc: Document): void;
    importData(modelResult: PetriNetResult, xmlDoc: Document): void;
    parseData(result: PetriNetResult, xmlData: Element, data: DataVariable): void;
    importTransitions(modelResult: PetriNetResult, xmlDoc: Document): void;
    parseTransition(result: PetriNetResult, xmlTrans: Element, trans: Transition): void;
    private importTransitionRoleRefs;
    private importTransitionUserRefs;
    private importTransitionTriggers;
    private importTransitionDataGroups;
    private importTransitionLayout;
    private importTransitionMetadata;
    private importTransitionEvents;
    private importTransitionEvent;
    private importTransactionRef;
    private importAssignedUser;
    importTransactions(modelResult: PetriNetResult, xmlDoc: Document): void;
    importProcessRefs(modelResult: PetriNetResult, xmlDoc: Document): void;
    importPlaces(modelResult: PetriNetResult, xmlDoc: Document): void;
    importPlace(modelResult: PetriNetResult, xmlPlace: Element): void;
    parsePlace(model: PetriNet, xmlPlace: Element, place: Place): void;
    importArcs(modelResult: PetriNetResult, xmlDoc: Document): void;
    parseArc(result: PetriNetResult, xmlArc: Element): Arc<NodeElement, NodeElement>;
    resolveArc(source: string, target: string, parsedArcType: XmlArcType, arcId: string, result: PetriNetResult): Arc<NodeElement, NodeElement>;
    getPlaceTransition(result: PetriNetResult, placeId: string, transitionId: string, arcId: string): [Place, Transition];
    importBreakPoints(xmlArc: Element, arc: Arc<NodeElement, NodeElement>, result: PetriNetResult): void;
    importI18n(modelResult: PetriNetResult, xmlDoc: Document): void;
    parseI18n(result: PetriNetResult, xmlI18n: Element, i18nNode: I18nTranslations): void;
    importMapping(modelResult: PetriNetResult, xmlDoc: Document): void;
    parseMapping(model: PetriNet, xmlMap: Element, mapping: Mapping): void;
    private checkI18ns;
    private static checkI18n;
}

declare class ExportUtils {
    protected xmlConstructor: XMLDocument;
    exportTag(doc: Element, name: string, value: string | undefined, force?: boolean, attributes?: Array<{
        key: string;
        value: string;
    }>, cdata?: boolean): void;
    exportExpression(doc: Element, name: string, value: Expression | undefined): void;
    exportOption(doc: Element, name: string, value: Option | undefined): void;
    exportI18nString(doc: Element, name: string, value: I18nString | undefined, force?: boolean): void;
    exportI18nWithDynamic(doc: Element, name: string, value: I18nWithDynamic | undefined): void;
    exportActions<T>(element: Element, event: Event<T>, phase: string): void;
    exportAction(element: Element, action: Action): void;
    exportFunction(element: Element, _function: PetriflowFunction): void;
    exportLogic(element: Element, logic: Logic, type: string): void;
    exportCaseLogic(element: Element, logic: CaseLogic, type: string): void;
    exportArcType(type: ArcType): XmlArcType;
    createCDATA(content: string): CDATASection;
    exportTags(doc: Element, tags: Map<string, string>): void;
}

declare class ExportService {
    protected _exportUtils: ExportUtils;
    static readonly PETRIFLOW_SCHEMA_URL = "https://petriflow.com/petriflow.schema.xsd";
    protected xmlConstructor: XMLDocument;
    constructor(_exportUtils?: ExportUtils);
    exportXml(model: PetriNet): string;
    generateXml(model: PetriNet): Element;
    exportModel(doc: Element, model: PetriNet): void;
    exportTransactions(doc: Element, model: PetriNet): void;
    exportRoles(doc: Element, model: PetriNet): void;
    exportFunctions(doc: Element, model: PetriNet): void;
    exportEvent<T>(element: Element, event: Event<T>): void;
    exportProcessRefs(doc: Element, model: PetriNet): void;
    exportProcessRef(element: Element, ref: ProcessPermissionRef, name: string): void;
    exportTransitionRef(element: Element, ref: TransitionPermissionRef, name: string): void;
    exportProcessEvents(doc: Element, model: PetriNet): void;
    exportData(doc: Element, model: PetriNet): void;
    exportI18n(doc: Element, model: PetriNet): void;
    exportTransitions(doc: Element, model: PetriNet): void;
    exportDataRef(element: Element, dataRef: DataRef): void;
    exportComponent(element: Element, component: Component): void;
    exportDataRefLayout(element: Element, layout: DataLayout): void;
    exportTransitionLayout(element: Element, layout: TransitionLayout): void;
    exportDataGroup(element: Element, dataGroup: DataGroup): void;
    exportPlaces(doc: Element, model: PetriNet): void;
    exportArcs(doc: Element, model: PetriNet): void;
    exportBreakpoints(exportArc: Element, arc: Arc<NodeElement, NodeElement>): void;
    dataRefOrder(a: DataRef, b: DataRef): number;
    alphabetically(a: string, b: string): number;
}

declare abstract class Simulation {
    static readonly ARC_ORDER: ArcType[];
    private readonly _originalModel;
    private _simulationModel;
    private _inputArcs;
    private _outputArcs;
    private _assignedTasks;
    private _consumedTokens;
    constructor(model: PetriNet);
    fire(transitionId: string): void;
    abstract assign(transitionId: string): void;
    abstract finish(transitionId: string): void;
    abstract cancel(transitionId: string): void;
    abstract isEnabled(transitionId: string): boolean;
    abstract enabled(): Array<Transition>;
    abstract isAssigned(transitionId: string): boolean;
    abstract assigned(): Array<Transition>;
    reset(): void;
    get simulationModel(): PetriNet;
    get originalModel(): PetriNet;
    get inputArcs(): Map<string, Array<Arc<NodeElement, NodeElement>>>;
    get outputArcs(): Map<string, Array<Arc<NodeElement, NodeElement>>>;
    get assignedTasks(): Set<string>;
    get consumedTokens(): Map<string, number>;
}

declare class BasicSimulation extends Simulation {
    private dataVariables;
    constructor(model: PetriNet, dataVariables?: Map<string, number>);
    reset(): void;
    updateData(dataVariables: Map<string, number>): void;
    updatePlaceReferences(): void;
    assign(transitionId: string): void;
    finish(transitionId: string): void;
    cancel(transitionId: string): void;
    isEnabled(transitionId: string): boolean;
    enabled(): Array<Transition>;
    isAssigned(transitionId: string): boolean;
    assigned(): Array<Transition>;
    protected updateIOArc(arc: Arc<NodeElement, NodeElement>): void;
    protected insertArc(arcs: Map<string, Array<Arc<NodeElement, NodeElement>>>, arc: Arc<NodeElement, NodeElement>, id: string): void;
    protected updateDataReference(arc: Arc<NodeElement, NodeElement>): void;
    protected updatePlaceReference(arc: Arc<NodeElement, NodeElement>): void;
    protected arcOrder(a: Arc<NodeElement, NodeElement>, b: Arc<NodeElement, NodeElement>): number;
}

export { Action, Alignment, Appearance, Arc, ArcType, AssignPolicy, AssignedUser, BasicSimulation, Breakpoint, CaseEvent, CaseEventType, CaseLogic, CompactDirection, Component, DataEvent, DataEventSource, DataEventType, DataFocusPolicy, DataGroup, DataLayout, DataRef, DataRefBehavior, DataRefLogic, DataType, DataVariable, Element$1 as Element, Event, EventPhase, EventSource, ExportService, ExportUtils, Expression, FinishPolicy, FunctionScope, HideEmptyRows, I18nString, I18nTranslations, I18nWithDynamic, Icon, IconType, ImportService, ImportUtils, InhibitorArc, Layout, LayoutType, Logic, Mapping, NodeElement, Option, PermissionRef, PetriNet, PetriNetResult, PetriflowFunction, Place, PlaceTransitionArc, ProcessEvent, ProcessEventType, ProcessPermissionRef, Property, ReadArc, RegularPlaceTransitionArc, RegularTransitionPlaceArc, ResetArc, Role, RoleEvent, RoleEventType, Template, Transaction, Transition, TransitionEvent, TransitionEventSource, TransitionEventType, TransitionLayout, TransitionPermissionRef, TransitionPlaceArc, Trigger, TriggerType, Validation, XmlArcType };