import { WorkflowAction, WorkflowEvent } from '../../classes/nodes';
import { NodeService } from '../../classes/services';
import { NodeTypes } from '../../enum';
import { BaseGroup, BpmnNodePrompt, Constructor, ConstructorWithIdentifier, WorkflowNode } from '../../types';
import { UtilsService } from '../utils.service';
import { LocalizationProviderService } from '../localization-provider.service';
import * as i0 from "@angular/core";
export declare class BpmnNodesService<E> extends NodeService<E> {
    private readonly nodes;
    private readonly groups;
    private readonly inputs;
    private readonly utils;
    private readonly localizationSvc;
    actions: Map<string, Constructor<WorkflowAction<E>>>;
    events: Map<string, Constructor<WorkflowEvent<E>>>;
    constructor(nodes: ConstructorWithIdentifier<WorkflowNode<E>>[], groups: ConstructorWithIdentifier<BaseGroup<E>>[], inputs: BpmnNodePrompt[], utils: UtilsService, localizationSvc: LocalizationProviderService);
    /**
     * > Get all the nodes that are of type `ACTION`
     *
     * The function is a bit more complicated than that, but that's the gist of it
     * @returns An array of action nodes.
     */
    getActions(): WorkflowNode<E>[];
    /**
     * > Get all the events from the nodes array, filter out the ones that are not of type `EVENT` and
     * then filter out the ones that are not triggers
     * @param [trigger=false] - boolean - If true, only return events that are triggers. If false, only
     * return events that are not triggers.
     * @returns An array of WorkflowEvent<E> instances.
     */
    getEvents(trigger?: boolean): WorkflowNode<E>[];
    /**
     * It returns an array of groups, each of which is a new instance of the Group class, with a unique
     * ID, and the type and isElseGroup parameters passed in
     * @param [trigger=false] - The trigger to filter by. If not provided, all groups will be returned.
     * @param type - The type of node you want to get.
     * @param [isElseGroup=false] - This is a boolean value that determines whether the group is an else
     * group or not.
     * @returns An array of groups
     */
    getGroups(trigger?: boolean, type?: NodeTypes, isElseGroup?: boolean): BaseGroup<E>[];
    /**
     * It takes a string, and returns a new instance of a class that has a name property that matches the
     * string
     * @param {string} name - The name of the node.
     * @param {string} groupName - The name of the group that the node belongs to.
     * @param {string} groupId - The id of the group that the node belongs to.
     * @param {string} [id] - The id of the node. If not provided, a new id will be generated.
     * @param {boolean} [isElseAction] - If the node is an else action, it will be set to true.
     * @returns A new instance of the node class that matches the name passed in.
     */
    getNodeByName(name: string, groupName: string, groupId: string, id?: string, isElseAction?: boolean): WorkflowNode<E>;
    /**
     * It takes a name, a node type, an id, and a boolean, and returns a new instance of a class that
     * extends BaseGroup
     * @param {string} name - The name of the group you want to create.
     * @param {NodeTypes} nodeType - The type of node. This is used to determine the type of node to
     * create.
     * @param {string} [id] - The id of the group.
     * @param {boolean} [isElseGroup] - This is a boolean value that indicates whether the group is an
     * else group.
     * @returns A new instance of the group class that matches the name passed in.
     */
    getGroupByName(name: string, nodeType: NodeTypes, id?: string, isElseGroup?: boolean): BaseGroup<E>;
    /**
     * It takes an array of prompts, and returns an array of inputs
     * @param node - typeof WorkflowNode
     * @returns An array of input instances.
     */
    mapInputs(node: WorkflowNode<E>): import("../../classes/nodes").WorkflowPrompt[];
    static ɵfac: i0.ɵɵFactoryDeclaration<BpmnNodesService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BpmnNodesService<any>>;
}
