sequential-workflow-designer 0.10.3

package/lib/index.d.ts

@@ -0,0 +1,858 @@
+import { Step, BranchedStep, SequentialStep, Definition, Sequence, ComponentType, Branches } from 'sequential-workflow-model';
+export * from 'sequential-workflow-model';
+
+/**
+ * @deprecated Use {@link Step} instead.
+ */
+interface TaskStep extends Step {
+    componentType: 'task';
+}
+/**
+ * @deprecated Use {@link BranchedStep} instead.
+ */
+interface SwitchStep extends BranchedStep {
+    componentType: 'switch';
+}
+/**
+ * @deprecated Use {@link SequentialStep} instead.
+ */
+interface ContainerStep extends SequentialStep {
+    componentType: 'container';
+}
+
+declare class Vector {
+    readonly x: number;
+    readonly y: number;
+    constructor(x: number, y: number);
+    add(v: Vector): Vector;
+    subtract(v: Vector): Vector;
+    multiplyByScalar(s: number): Vector;
+    divideByScalar(s: number): Vector;
+    round(): Vector;
+    distance(): number;
+}
+
+interface Behavior {
+    onStart(position: Vector): void;
+    onMove(delta: Vector): Behavior | void;
+    onEnd(interrupt: boolean, element: Element | null): void;
+}
+
+declare class BehaviorController {
+    private state?;
+    start(startPosition: Vector, behavior: Behavior): void;
+    private readonly onMouseMove;
+    private readonly onTouchMove;
+    private readonly onMouseUp;
+    private readonly onTouchEnd;
+    private readonly onTouchStart;
+    private move;
+    private stop;
+}
+
+interface DesignerConfiguration<TDefinition extends Definition = Definition> {
+    /**
+     * @description The theme of the designer.
+     * @default `light`
+     */
+    theme?: string;
+    isReadonly?: boolean;
+    undoStackSize?: number;
+    steps: StepsConfiguration;
+    /**
+     * @description The configuration of the toolbox. If not set, the toolbox will be hidden.
+     */
+    toolbox: false | ToolboxConfiguration;
+    /**
+     * @description The configuration of the smart editor. If not set, the smart editor will be hidden.
+     */
+    editors: false | EditorsConfiguration<TDefinition>;
+    /**
+     * @description If true, the control bar will be displayed. In the next version, this property will be required.
+     */
+    controlBar: boolean;
+    customActionHandler?: CustomActionHandler;
+    extensions?: DesignerExtension[];
+}
+type CustomActionHandler = (action: string, step: Step) => void;
+interface ToolboxConfiguration {
+    groups: ToolboxGroupConfiguration[];
+}
+type StepDefinition = Omit<Step, 'id'>;
+interface ToolboxGroupConfiguration {
+    name: string;
+    steps: StepDefinition[];
+}
+interface StepsConfiguration {
+    canInsertStep?: (step: Step, targetSequence: Sequence, targetIndex: number) => boolean;
+    isDraggable?: (step: Step, parentSequence: Sequence) => boolean;
+    canMoveStep?: (sourceSequence: Sequence, step: Step, targetSequence: Sequence, targetIndex: number) => boolean;
+    isDeletable?: (step: Step, parentSequence: Sequence) => boolean;
+    canDeleteStep?: (step: Step, parentSequence: Sequence) => boolean;
+    iconUrlProvider?: StepIconUrlProvider;
+    validator?: StepValidator;
+}
+type StepIconUrlProvider = (componentType: ComponentType, type: string) => string | null;
+type StepValidator = (step: Step, parentSequence: Sequence) => boolean;
+interface EditorsConfiguration<TDefinition extends Definition = Definition> {
+    stepEditorProvider: StepEditorProvider;
+    globalEditorProvider: GlobalEditorProvider<TDefinition>;
+}
+interface StepEditorContext {
+    notifyNameChanged(): void;
+    notifyPropertiesChanged(): void;
+    notifyChildrenChanged(): void;
+}
+type StepEditorProvider = (step: Step, context: StepEditorContext) => HTMLElement;
+interface GlobalEditorContext {
+    notifyPropertiesChanged(): void;
+}
+type GlobalEditorProvider<TDefinition extends Definition = Definition> = (definition: TDefinition, context: GlobalEditorContext) => HTMLElement;
+
+type Services = Required<DesignerExtension>;
+declare class ServicesResolver {
+    static resolve(extensions: DesignerExtension[] | undefined, configuration: DesignerConfiguration): Services;
+}
+
+interface SequenceContext {
+    sequence: Sequence;
+    depth: number;
+    isInputConnected: boolean;
+    isOutputConnected: boolean;
+}
+
+declare enum RectPlaceholderDirection {
+    none = 0,
+    in = 1,
+    out = 2
+}
+declare class RectPlaceholderView {
+    readonly rect: SVGElement;
+    readonly g: SVGElement;
+    static create(parent: SVGElement, x: number, y: number, width: number, height: number, direction: RectPlaceholderDirection): RectPlaceholderView;
+    private constructor();
+    setIsHover(isHover: boolean): void;
+    setIsVisible(isVisible: boolean): void;
+}
+
+declare class SequenceComponentView implements ComponentView {
+    readonly g: SVGGElement;
+    readonly width: number;
+    readonly height: number;
+    readonly joinX: number;
+    readonly placeholders: SequencePlaceholder[];
+    readonly components: StepComponent[];
+    static create(parent: SVGElement, sequenceContext: SequenceContext, componentContext: ComponentContext): SequenceComponentView;
+    private constructor();
+    setIsDragging(isDragging: boolean): void;
+    hasOutput(): boolean;
+}
+interface SequencePlaceholder {
+    view: RectPlaceholderView;
+    index: number;
+}
+
+declare class SequenceComponent implements Component {
+    readonly view: SequenceComponentView;
+    readonly hasOutput: boolean;
+    private readonly sequence;
+    static create(parentElement: SVGElement, sequenceContext: SequenceContext, context: ComponentContext): SequenceComponent;
+    private constructor();
+    resolveClick(click: ClickDetails): ResolvedClick | null;
+    findById(stepId: string): StepComponent | null;
+    getPlaceholders(result: Placeholder[]): void;
+    setIsDragging(isDragging: boolean): void;
+    updateBadges(result: BadgesResult): void;
+}
+
+interface Component {
+    view: ComponentView;
+    findById(stepId: string): StepComponent | null;
+    resolveClick(click: ClickDetails): ResolvedClick | null;
+    getPlaceholders(result: Placeholder[]): void;
+    setIsDragging(isDragging: boolean): void;
+    updateBadges(result: BadgesResult): void;
+}
+interface ClickDetails {
+    element: Element;
+    position: Vector;
+    scale: number;
+}
+interface ResolvedClick {
+    component: StepComponent;
+    command: ClickCommand;
+}
+interface ClickCommand {
+    type: ClickCommandType;
+}
+interface TriggerCustomActionClickCommand extends ClickCommand {
+    type: ClickCommandType.triggerCustomAction;
+    action: string;
+}
+declare enum ClickCommandType {
+    selectStep = 1,
+    openFolder = 2,
+    triggerCustomAction = 3
+}
+interface ComponentView {
+    g: SVGGElement;
+    width: number;
+    height: number;
+    joinX: number;
+}
+interface StepComponentView extends ComponentView {
+    sequenceComponents: SequenceComponent[] | null;
+    placeholders: Placeholder[] | null;
+    hasOutput(): boolean;
+    resolveClick(click: ClickDetails): ClickCommand | null;
+    setIsDragging(isDragging: boolean): void;
+    setIsSelected(isSelected: boolean): void;
+    setIsDisabled(isDisabled: boolean): void;
+    getClientPosition(): Vector;
+}
+interface BadgeView {
+    g: SVGGElement;
+    width: number;
+    height: number;
+}
+interface Badge {
+    view: BadgeView | null;
+    update(result: unknown): unknown;
+    resolveClick(click: ClickDetails): ClickCommand | null;
+}
+type BadgesResult = unknown[];
+interface Placeholder {
+    parentSequence: Sequence;
+    index: number;
+    getClientRect(): DOMRect;
+    setIsHover(isHover: boolean): void;
+}
+
+declare class StepComponent implements Component {
+    readonly view: StepComponentView;
+    readonly step: Step;
+    readonly parentSequence: Sequence;
+    readonly hasOutput: boolean;
+    private readonly badges;
+    static create(view: StepComponentView, stepContext: StepContext, componentContext: ComponentContext): StepComponent;
+    private isDisabled;
+    private constructor();
+    findById(stepId: string): StepComponent | null;
+    resolveClick(click: ClickDetails): ResolvedClick | null;
+    getPlaceholders(result: Placeholder[]): void;
+    setIsDragging(isDragging: boolean): void;
+    setIsSelected(isSelected: boolean): void;
+    setIsDisabled(isDisabled: boolean): void;
+    updateBadges(result: BadgesResult): void;
+}
+
+declare class StepComponentFactory {
+    private readonly stepExtensionResolver;
+    constructor(stepExtensionResolver: StepExtensionResolver);
+    create(parentElement: SVGElement, stepContext: StepContext, componentContext: ComponentContext): StepComponent;
+}
+
+declare class ComponentContext {
+    readonly configuration: StepsConfiguration;
+    readonly placeholderController: PlaceholderController;
+    readonly stepComponentFactory: StepComponentFactory;
+    readonly services: Services;
+    static create(configuration: StepsConfiguration, stepExtensionResolver: StepExtensionResolver, services: Services): ComponentContext;
+    private constructor();
+}
+
+declare class SimpleEvent<T> {
+    private readonly listeners;
+    subscribe(listener: SimpleEventListener<T>): void;
+    unsubscribe(listener: SimpleEventListener<T>): void;
+    forward(value: T): void;
+    count(): number;
+}
+type SimpleEventListener<T> = (value: T) => void;
+
+interface DefinitionChangedEvent {
+    changeType: DefinitionChangeType;
+    stepId: string | null;
+}
+declare enum DefinitionChangeType {
+    stepNameChanged = 1,
+    stepPropertyChanged = 2,
+    stepChildrenChanged = 3,
+    stepDeleted = 4,
+    stepMoved = 5,
+    stepInserted = 6,
+    globalPropertyChanged = 7,
+    rootReplaced = 8
+}
+declare class DesignerState {
+    definition: Definition;
+    isReadonly: boolean;
+    readonly onViewportChanged: SimpleEvent<Viewport>;
+    readonly onSelectedStepIdChanged: SimpleEvent<string | null>;
+    readonly onFolderPathChanged: SimpleEvent<string[]>;
+    readonly onIsReadonlyChanged: SimpleEvent<boolean>;
+    readonly onIsDraggingChanged: SimpleEvent<boolean>;
+    readonly onIsDragDisabledChanged: SimpleEvent<boolean>;
+    readonly onDefinitionChanged: SimpleEvent<DefinitionChangedEvent>;
+    viewport: Viewport;
+    selectedStepId: string | null;
+    folderPath: string[];
+    isDragging: boolean;
+    isDragDisabled: boolean;
+    constructor(definition: Definition, isReadonly: boolean);
+    setSelectedStepId(stepId: string | null): void;
+    pushStepIdToFolderPath(stepId: string): void;
+    setFolderPath(path: string[]): void;
+    tryGetLastStepIdFromFolderPath(): string | null;
+    setDefinition(definition: Definition): void;
+    notifyDefinitionChanged(changeType: DefinitionChangeType, stepId: string | null): void;
+    setViewport(viewport: Viewport): void;
+    setIsReadonly(isReadonly: boolean): void;
+    setIsDragging(isDragging: boolean): void;
+    toggleIsDragDisabled(): void;
+}
+
+declare class HistoryController {
+    private readonly state;
+    private readonly definitionModifier;
+    private readonly stackSize;
+    static create(state: DesignerState, definitionModifier: DefinitionModifier, configuration: DesignerConfiguration): HistoryController;
+    private readonly stack;
+    private currentIndex;
+    constructor(state: DesignerState, definitionModifier: DefinitionModifier, stackSize: number);
+    canUndo(): boolean;
+    undo(): void;
+    canRedo(): boolean;
+    redo(): void;
+    private remember;
+    private commit;
+}
+
+declare class LayoutController {
+    private readonly parent;
+    constructor(parent: HTMLElement);
+    isMobile(): boolean;
+}
+
+declare class Icons {
+    static folderIn: string;
+    static folderOut: string;
+    static center: string;
+    static zoomIn: string;
+    static zoomOut: string;
+    static undo: string;
+    static redo: string;
+    static move: string;
+    static delete: string;
+    static folderUp: string;
+    static close: string;
+    static options: string;
+    static expand: string;
+    static alert: string;
+    static play: string;
+    static stop: string;
+    static folder: string;
+    static appendPath(parent: SVGElement, pathClassName: string, d: string, size: number): SVGGElement;
+    static createSvg(className: string, d: string): SVGElement;
+}
+
+declare class ObjectCloner {
+    static deepClone<T>(instance: T): T;
+}
+
+interface Attributes {
+    [name: string]: string | number;
+}
+declare class Dom {
+    static svg<K extends keyof SVGElementTagNameMap>(name: K, attributes?: Attributes): SVGElementTagNameMap[K];
+    static translate(element: SVGElement, x: number, y: number): void;
+    static attrs(element: Element, attributes: Attributes): void;
+    static element<T extends keyof HTMLElementTagNameMap>(name: T, attributes?: Attributes): HTMLElementTagNameMap[T];
+    static toggleClass(element: Element, isEnabled: boolean, className: string): void;
+}
+
+declare class Uid {
+    static next(): string;
+}
+
+declare function race<A, B, C>(timeout: number, a: SimpleEvent<A>, b: SimpleEvent<B>, c?: SimpleEvent<C>): SimpleEvent<[A?, B?, C?]>;
+
+interface WorkspaceController {
+    getPlaceholders(): Placeholder[];
+    getComponentByStepId(stepId: string): StepComponent;
+    getCanvasPosition(): Vector;
+    getCanvasSize(): Vector;
+    getRootComponentSize(): Vector;
+    updateBadges(): void;
+    updateSize(): void;
+}
+declare class WorkspaceControllerWrapper implements WorkspaceController {
+    private controller?;
+    set(controller: WorkspaceController): void;
+    private get;
+    getPlaceholders(): Placeholder[];
+    getComponentByStepId(stepId: string): StepComponent;
+    getCanvasPosition(): Vector;
+    getCanvasSize(): Vector;
+    getRootComponentSize(): Vector;
+    updateBadges(): void;
+    updateSize(): void;
+}
+
+declare class DesignerContext {
+    readonly state: DesignerState;
+    readonly configuration: DesignerConfiguration;
+    readonly services: Services;
+    readonly componentContext: ComponentContext;
+    readonly stepsTraverser: StepsTraverser;
+    readonly definitionModifier: DefinitionModifier;
+    readonly layoutController: LayoutController;
+    readonly workspaceController: WorkspaceControllerWrapper;
+    readonly behaviorController: BehaviorController;
+    readonly historyController: HistoryController | undefined;
+    static create(parent: HTMLElement, startDefinition: Definition, configuration: DesignerConfiguration, services: Services): DesignerContext;
+    constructor(state: DesignerState, configuration: DesignerConfiguration, services: Services, componentContext: ComponentContext, stepsTraverser: StepsTraverser, definitionModifier: DefinitionModifier, layoutController: LayoutController, workspaceController: WorkspaceControllerWrapper, behaviorController: BehaviorController, historyController: HistoryController | undefined);
+    setWorkspaceController(controller: WorkspaceController): void;
+}
+
+type EditorRendererHandler = (step: Step | null) => void;
+declare class EditorRenderer {
+    private readonly state;
+    private readonly stepsTraverser;
+    private readonly handler;
+    static create(state: DesignerState, stepsTraverser: StepsTraverser, handler: EditorRendererHandler): EditorRenderer;
+    private currentStepId;
+    private constructor();
+    destroy(): void;
+    private render;
+    private tryRender;
+    private onDefinitionChanged;
+    private onSelectedStepIdChanged;
+}
+
+declare class EditorApi {
+    private readonly state;
+    private readonly stepsTraverser;
+    private readonly layoutController;
+    private readonly definitionModifier;
+    constructor(state: DesignerState, stepsTraverser: StepsTraverser, layoutController: LayoutController, definitionModifier: DefinitionModifier);
+    isVisibleAtStart(): boolean;
+    getDefinition(): Definition;
+    runRenderer(rendererHandler: EditorRendererHandler): EditorRenderer;
+    createStepEditorContext(stepId: string): StepEditorContext;
+    createGlobalEditorContext(): GlobalEditorContext;
+}
+
+declare class PathBarApi {
+    private readonly state;
+    private readonly stepsTraverser;
+    constructor(state: DesignerState, stepsTraverser: StepsTraverser);
+    /**
+     * @deprecated Don't use this method
+     */
+    subscribe(handler: () => void): void;
+    setFolderPath(path: string[]): void;
+    getFolderPath(): string[];
+    getFolderPathStepNames(): string[];
+}
+
+declare class ToolboxApi {
+    private readonly state;
+    private readonly designerContext;
+    private readonly behaviorController;
+    private readonly layoutController;
+    private readonly configuration;
+    constructor(state: DesignerState, designerContext: DesignerContext, behaviorController: BehaviorController, layoutController: LayoutController, configuration: StepsConfiguration);
+    isVisibleAtStart(): boolean;
+    tryGetIconUrl(step: StepDefinition): string | null;
+    /**
+     * @param position Mouse or touch position.
+     * @param step Step definition.
+     * @returns If started dragging returns true, otherwise returns false.
+     */
+    tryDrag(position: Vector, step: StepDefinition): boolean;
+}
+
+declare class ViewportApi {
+    private readonly workspaceController;
+    private readonly viewportController;
+    constructor(workspaceController: WorkspaceControllerWrapper, viewportController: ViewportController);
+    resetViewport(): void;
+    zoom(direction: boolean): void;
+    moveViewportToStep(stepId: string): void;
+}
+
+declare class WorkspaceApi {
+    private readonly state;
+    private readonly workspaceController;
+    constructor(state: DesignerState, workspaceController: WorkspaceControllerWrapper);
+    getCanvasPosition(): Vector;
+    getCanvasSize(): Vector;
+    getRootComponentSize(): Vector;
+    getViewport(): Viewport;
+    setViewport(viewport: Viewport): void;
+    updateBadges(): void;
+    updateSize(): void;
+}
+
+declare class DesignerApi {
+    readonly controlBar: ControlBarApi;
+    readonly toolbox: ToolboxApi;
+    readonly editor: EditorApi;
+    readonly workspace: WorkspaceApi;
+    readonly viewport: ViewportApi;
+    readonly pathBar: PathBarApi;
+    static create(context: DesignerContext): DesignerApi;
+    private constructor();
+}
+
+declare class InputView {
+    private readonly root;
+    static createRectInput(parent: SVGElement, x: number, y: number, iconUrl: string | null): InputView;
+    static createRoundInput(parent: SVGElement, x: number, y: number): InputView;
+    private constructor();
+    setIsHidden(isHidden: boolean): void;
+}
+
+declare class JoinView {
+    static createStraightJoin(parent: SVGElement, start: Vector, height: number): void;
+    static createJoins(parent: SVGElement, start: Vector, targets: Vector[]): void;
+}
+
+declare const LABEL_HEIGHT = 22;
+declare class LabelView {
+    readonly g: SVGGElement;
+    readonly width: number;
+    readonly height: number;
+    static create(parent: SVGElement, y: number, text: string, theme: 'primary' | 'secondary'): LabelView;
+    constructor(g: SVGGElement, width: number, height: number);
+}
+
+declare class OutputView {
+    private readonly root;
+    static create(parent: SVGElement, x: number, y: number): OutputView;
+    constructor(root: SVGElement);
+    setIsHidden(isHidden: boolean): void;
+}
+
+declare class RegionView {
+    private readonly lines;
+    private readonly width;
+    private readonly height;
+    static create(parent: SVGElement, widths: number[], height: number): RegionView;
+    constructor(lines: SVGLineElement[], width: number, height: number);
+    getClientPosition(): Vector;
+    resolveClick(click: ClickDetails): boolean;
+    setIsSelected(isSelected: boolean): void;
+}
+
+declare class TaskStepComponentView implements StepComponentView {
+    readonly g: SVGGElement;
+    readonly width: number;
+    readonly height: number;
+    readonly joinX: number;
+    private readonly rect;
+    private readonly inputView;
+    private readonly outputView;
+    static create(parentElement: SVGElement, stepContext: StepContext<Step>, configuration: StepsConfiguration, isInterrupted: boolean): TaskStepComponentView;
+    readonly sequenceComponents: null;
+    readonly placeholders: null;
+    private constructor();
+    hasOutput(): boolean;
+    getClientPosition(): Vector;
+    resolveClick(click: ClickDetails): ClickCommand | null;
+    setIsDragging(isDragging: boolean): void;
+    setIsDisabled(isDisabled: boolean): void;
+    setIsSelected(isSelected: boolean): void;
+}
+
+declare class CenteredViewportCalculator {
+    static center(margin: number, canvasSize: Vector, rootComponentSize: Vector): Viewport;
+    static focusOnComponent(canvasSize: Vector, viewport: Viewport, componentPosition: Vector, componentSize: Vector): Viewport;
+}
+
+declare class ClassicWheelController implements WheelController {
+    private readonly api;
+    static create(api: WorkspaceApi): ClassicWheelController;
+    private constructor();
+    onWheel(e: WheelEvent): void;
+}
+
+declare class ClassicWheelControllerExtension implements WheelControllerExtension {
+    readonly create: typeof ClassicWheelController.create;
+}
+
+declare class QuantifiedScaleViewportCalculator {
+    static zoom(current: Viewport, direction: boolean): Viewport;
+    static zoomByWheel(current: Viewport, e: WheelEvent, canvasPosition: Vector): Viewport | null;
+}
+
+declare class DefaultViewportController implements ViewportController {
+    private readonly api;
+    static create(api: WorkspaceApi): DefaultViewportController;
+    private readonly animator;
+    private constructor();
+    setDefault(): void;
+    zoom(direction: boolean): void;
+    focusOnComponent(componentPosition: Vector, componentSize: Vector): void;
+    animateTo(viewport: Viewport): void;
+}
+
+declare class DefaultViewportControllerExtension implements ViewportControllerExtension {
+    readonly create: typeof DefaultViewportController.create;
+}
+
+declare class RectPlaceholder implements Placeholder {
+    private readonly view;
+    readonly parentSequence: Sequence;
+    readonly index: number;
+    constructor(view: RectPlaceholderView, parentSequence: Sequence, index: number);
+    getClientRect(): DOMRect;
+    setIsHover(isHover: boolean): void;
+}
+
+interface DesignerExtension {
+    steps?: StepExtension[];
+    badges?: BadgeExtension[];
+    uiComponents?: UiComponentExtension[];
+    draggedComponent?: DraggedComponentExtension;
+    wheelController?: WheelControllerExtension;
+    viewportController?: ViewportControllerExtension;
+    placeholderController?: PlaceholderControllerExtension;
+    rootComponent?: RootComponentExtension;
+    daemons?: DaemonExtension[];
+}
+interface StepExtension<S extends Step = Step> {
+    componentType: ComponentType;
+    createComponentView(parentElement: SVGElement, stepContext: StepContext<S>, componentContext: ComponentContext): StepComponentView;
+    getChildren(step: S): StepChildren | null;
+}
+interface StepContext<S extends Step = Step> {
+    parentSequence: Sequence;
+    step: S;
+    depth: number;
+    position: number;
+    isInputConnected: boolean;
+    isOutputConnected: boolean;
+}
+interface StepChildren {
+    type: StepChildrenType;
+    sequences: Sequence | Branches;
+}
+declare enum StepChildrenType {
+    singleSequence = 1,
+    branches = 2
+}
+interface BadgeExtension {
+    createBadge(parentElement: SVGElement, stepContext: StepContext, componentContext: ComponentContext): Badge;
+    createStartValue(): unknown;
+}
+interface WheelControllerExtension {
+    create(api: WorkspaceApi): WheelController;
+}
+interface WheelController {
+    onWheel(e: WheelEvent): void;
+}
+interface UiComponentExtension {
+    create(root: HTMLElement, api: DesignerApi): UiComponent;
+}
+interface UiComponent {
+    destroy(): void;
+}
+interface DraggedComponentExtension {
+    create(parent: HTMLElement, step: Step, componentContext: ComponentContext): DraggedComponent;
+}
+interface DraggedComponent {
+    width: number;
+    height: number;
+    destroy(): void;
+}
+interface RootComponentExtension {
+    create(parentElement: SVGElement, sequence: Sequence, parentSequencePlaceIndicator: SequencePlaceIndicator | null, context: ComponentContext): Component;
+}
+interface SequencePlaceIndicator {
+    sequence: Sequence;
+    index: number;
+}
+interface PlaceholderControllerExtension {
+    create(): PlaceholderController;
+}
+interface PlaceholderController {
+    canCreate(sequence: Sequence, index: number): boolean;
+}
+interface ViewportControllerExtension {
+    create(api: WorkspaceApi): ViewportController;
+}
+interface ViewportController {
+    setDefault(): void;
+    zoom(direction: boolean): void;
+    focusOnComponent(componentPosition: Vector, componentSize: Vector): void;
+}
+interface Viewport {
+    position: Vector;
+    scale: number;
+}
+interface DaemonExtension {
+    create(api: DesignerApi): Daemon;
+}
+interface Daemon {
+    destroy(): void;
+}
+
+declare class StepExtensionResolver {
+    private readonly dict;
+    static create(services: Services): StepExtensionResolver;
+    private constructor();
+    resolve(componentType: ComponentType): StepExtension<Step>;
+}
+
+interface StepWithParentSequence {
+    step: Step;
+    /**
+     * Index of the step in the parent sequence.
+     */
+    index: number;
+    parentSequence: Sequence;
+}
+type StepOrName = Step | string;
+interface StepWithParentAndChildSequences {
+    index: number;
+    parentSequence: Sequence;
+    childSequence: Sequence;
+}
+declare class StepsTraverser {
+    private readonly stepExtensionResolver;
+    constructor(stepExtensionResolver: StepExtensionResolver);
+    private getChildren;
+    private find;
+    getParents(definition: Definition, needle: Sequence | Step): StepOrName[];
+    findParentSequence(definition: Definition, stepId: string): StepWithParentSequence | null;
+    getParentSequence(definition: Definition, stepId: string): StepWithParentSequence;
+    findById(definition: Definition, stepId: string): Step | null;
+    getById(definition: Definition, stepId: string): Step;
+    getChildAndParentSequences(definition: Definition, stepId: string): StepWithParentAndChildSequences;
+}
+
+declare class DefinitionModifier {
+    private readonly stepsTraverser;
+    private readonly state;
+    private readonly configuration;
+    constructor(stepsTraverser: StepsTraverser, state: DesignerState, configuration: DesignerConfiguration);
+    isDeletable(stepId: string): boolean;
+    tryDelete(stepId: string): boolean;
+    tryInsert(step: Step, targetSequence: Sequence, targetIndex: number): boolean;
+    isDraggable(step: Step, parentSequence: Sequence): boolean;
+    tryMove(sourceSequence: Sequence, step: Step, targetSequence: Sequence, targetIndex: number): boolean;
+    replaceDefinition(definition: Definition): void;
+    updateDependantFields(): void;
+}
+
+declare class ControlBarApi {
+    private readonly state;
+    private readonly historyController;
+    private readonly definitionModifier;
+    private readonly viewportApi;
+    constructor(state: DesignerState, historyController: HistoryController | undefined, definitionModifier: DefinitionModifier, viewportApi: ViewportApi);
+    /**
+     * @deprecated Don't use this method
+     */
+    subscribe(handler: () => void): void;
+    resetViewport(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    isDragDisabled(): boolean;
+    toggleIsDragDisabled(): void;
+    isUndoRedoSupported(): boolean;
+    tryUndo(): boolean;
+    canUndo(): boolean;
+    tryRedo(): boolean;
+    canRedo(): boolean;
+    tryDelete(): boolean;
+    canDelete(): boolean;
+}
+
+declare class Editor {
+    private readonly view;
+    private readonly renderer;
+    static create(parent: HTMLElement, api: DesignerApi, stepEditorClassName: string, stepEditorProvider: StepEditorProvider, globalEditorClassName: string, globalEditorProvider: GlobalEditorProvider): Editor;
+    private constructor();
+    destroy(): void;
+}
+
+declare class Designer<TDefinition extends Definition = Definition> {
+    private readonly view;
+    private readonly state;
+    private readonly stepsTraverser;
+    private readonly api;
+    /**
+     * Creates a designer.
+     * @param placeholder Placeholder where the designer will be attached.
+     * @param startDefinition Start definition of a flow.
+     * @param configuration Designer's configuration.
+     * @returns An instance of the designer.
+     */
+    static create<TDef extends Definition>(placeholder: HTMLElement, startDefinition: TDef, configuration: DesignerConfiguration<TDef>): Designer<TDef>;
+    private constructor();
+    /**
+     * @description Fires when the designer is initialized and ready to use.
+     */
+    readonly onReady: SimpleEvent<void>;
+    /**
+     * @description Fires when the definition has changed.
+     */
+    readonly onDefinitionChanged: SimpleEvent<TDefinition>;
+    /**
+     * @description Fires when the selected step has changed.
+     */
+    readonly onSelectedStepIdChanged: SimpleEvent<string | null>;
+    /**
+     * @returns the current definition of the workflow.
+     */
+    getDefinition(): TDefinition;
+    /**
+     * @returns the validation result of the current definition.
+     */
+    isValid(): boolean;
+    /**
+     * @returns the readonly flag.
+     */
+    isReadonly(): boolean;
+    /**
+     * @description Changes the readonly flag.
+     */
+    setIsReadonly(isReadonly: boolean): void;
+    /**
+     * @returns current selected step id or `null` if nothing is selected.
+     */
+    getSelectedStepId(): string | null;
+    /**
+     * @description Selects a step by the id.
+     */
+    selectStepById(stepId: string): void;
+    /**
+     * @description Unselects the selected step.
+     */
+    clearSelectedStep(): void;
+    /**
+     * @description Moves the viewport to the step with the animation.
+     */
+    moveViewportToStep(stepId: string): void;
+    /**
+     * @deprecated Use `moveViewportToStep` instead.
+     */
+    moveViewPortToStep(stepId: string): void;
+    /**
+     * @description Updates all badges.
+     */
+    updateBadges(): void;
+    /**
+     * @returns parent steps and branch names of the passed step or the passed sequence.
+     */
+    getStepParents(needle: Sequence | Step): StepOrName[];
+    /**
+     * @description Destroys the designer and deletes all nodes from the placeholder.
+     */
+    destroy(): void;
+}
+
+export { Attributes, Badge, BadgeExtension, BadgeView, BadgesResult, CenteredViewportCalculator, ClassicWheelControllerExtension, ClickCommand, ClickCommandType, ClickDetails, Component, ComponentContext, ComponentView, ContainerStep, ControlBarApi, CustomActionHandler, Daemon, DaemonExtension, DefaultViewportController, DefaultViewportControllerExtension, DefinitionChangeType, DefinitionChangedEvent, Designer, DesignerApi, DesignerConfiguration, DesignerContext, DesignerExtension, DesignerState, Dom, DraggedComponent, DraggedComponentExtension, Editor, EditorApi, EditorsConfiguration, GlobalEditorContext, GlobalEditorProvider, Icons, InputView, JoinView, LABEL_HEIGHT, LabelView, ObjectCloner, OutputView, PathBarApi, Placeholder, PlaceholderController, PlaceholderControllerExtension, QuantifiedScaleViewportCalculator, RectPlaceholder, RectPlaceholderDirection, RectPlaceholderView, RegionView, ResolvedClick, RootComponentExtension, SequenceComponent, SequenceComponentView, SequenceContext, SequencePlaceIndicator, SequencePlaceholder, Services, ServicesResolver, SimpleEvent, SimpleEventListener, StepChildren, StepChildrenType, StepComponent, StepComponentView, StepContext, StepDefinition, StepEditorContext, StepEditorProvider, StepExtension, StepExtensionResolver, StepIconUrlProvider, StepOrName, StepValidator, StepWithParentAndChildSequences, StepWithParentSequence, StepsConfiguration, StepsTraverser, SwitchStep, TaskStep, TaskStepComponentView, ToolboxApi, ToolboxConfiguration, ToolboxGroupConfiguration, TriggerCustomActionClickCommand, UiComponent, UiComponentExtension, Uid, Vector, Viewport, ViewportController, ViewportControllerExtension, WheelController, WheelControllerExtension, WorkspaceApi, race };