import { BuilderService, ElementService, NodeService, Statement } from '../../classes';
import { AbstractBaseGroup } from '../../classes/nodes';
import { AutoLayoutService } from '../../layout/layout.service';
import { BpmnStatementNode, CustomBpmnModdle, ModdleElement, RecordOfAnyType } from '../../types';
import { ActionWithInput, EventWithInput } from '../../types/base.types';
import { UtilsService } from '../utils.service';
import { LocalizationProviderService } from '../localization-provider.service';
import * as i0 from "@angular/core";
export declare class BpmnBuilderService extends BuilderService<ModdleElement, RecordOfAnyType> {
    private readonly moddle;
    private readonly baseXML;
    private readonly elements;
    private readonly nodes;
    private readonly layout;
    private readonly utils;
    private readonly localizationSvc;
    private root?;
    private base;
    constructor(moddle: CustomBpmnModdle, baseXML: string, elements: ElementService<ModdleElement>, nodes: NodeService<ModdleElement>, layout: AutoLayoutService, utils: UtilsService, localizationSvc: LocalizationProviderService);
    /**
     * It takes a statement and an else statement, and returns a promise that resolves to a string of XML
     * @param statement - Statement<ModdleElement>
     * @param elseStatement - The else statement that is to be added to the main flow.
     * @returns The XML of the process
     */
    build(statement: Statement<ModdleElement>, elseStatement: Statement<ModdleElement>): Promise<string>;
    /**
     * > It creates a new instance of a StartElement, StartOnIntervalElement, or StartElement depending
     * on the type of trigger
     * @param trigger - StatementNode<ModdleElement>
     * @returns A start event.
     */
    private getStartEvent;
    /**
     * It traverses the tree and sets the tags for each node.
     * @param root - The root node of the tree.
     */
    traverseToSetTags(root: BpmnStatementNode): void;
    /**
     * It traverses the tree and links the nodes.
     * @param root - The root node of the tree.
     */
    traverseToLink(root: BpmnStatementNode): void;
    /**
     * It adds the else statement to the main flow
     * @param elseStatement - Statement<ModdleElement> - the statement that contains the else flow
     * @param statement - Statement<ModdleElement> - the statement that is being parsed
     * @returns The return statement stops the execution of a function and returns a value from that
     * function.
     */
    private addElseIntoMainFlow;
    /**
     * It creates a new tag for the element and adds it to the base
     * @param element - StatementNode<ModdleElement>
     */
    setTags(element: BpmnStatementNode): void;
    /**
     * It links the nodes in the diagram.
     * @param element - StatementNode<ModdleElement>
     */
    linkNodes(element: BpmnStatementNode): void;
    /**
     * It takes an XML string, converts it to a moddle object, and then returns an object with the
     * actions, events, groups, state, and process
     * @param {string} xml - The XML string that you want to restore.
     * @returns An object with the following properties:
     * - actions: An array of ActionWithInput objects
     * - elseActions: An array of ActionWithInput objects
     * - events: An array of EventWithInput objects
     * - groups: An array of AbstractBaseGroup objects
     * - state: An object with the following properties:
     *   - name: A string
     *   - description: A string
     *   -
     */
    restore(xml: string): Promise<{
        actions: ActionWithInput<ModdleElement>[];
        elseActions: ActionWithInput<ModdleElement>[];
        events: EventWithInput<ModdleElement>[];
        groups: AbstractBaseGroup<ModdleElement>[];
        state: RecordOfAnyType;
        process: ModdleElement;
    }>;
    /**
     * It creates a new ProcessPropertiesElement, which is a class that extends the Element class, and
     * passes it the node and state
     * @param state - The state of the process.
     * @param node - The node that is being processed.
     * @returns A new ProcessPropertiesElement
     */
    private saveProperties;
    /**
     * It gets the extension elements of the element, then gets the properties of the extension elements,
     * then sets the state of the property
     * @param {ModdleElement} element - ModdleElement - the element that we want to get the properties
     * from
     * @returns An object with the properties of the element.
     */
    private getProperties;
    /**
     * It takes a property and a state object, and it sets the state object's value to the property's
     * value
     * @param {ModdleElement} property - ModdleElement - this is the property that is being set
     * @param {RecordOfAnyType} state - The state object that we're going to be updating.
     */
    private setState;
    static ɵfac: i0.ɵɵFactoryDeclaration<BpmnBuilderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BpmnBuilderService>;
}
