@obliczeniowo/elementary/modeller/index.d.ts

Library made in Angular version 20

import * as i0 from '@angular/core';
import { Type, ElementRef, ChangeDetectorRef, ViewContainerRef, ComponentRef, SimpleChanges, EventEmitter, QueryList } from '@angular/core';
import { IPoint2D, Point2D } from '@obliczeniowo/elementary/classes';
import * as i24 from '@obliczeniowo/elementary/menu';
import { MenuItem } from '@obliczeniowo/elementary/menu';
import { EventEmitterExt } from '@obliczeniowo/elementary/rx-js-ext';
import * as i21 from '@obliczeniowo/elementary/connectors';
import { Connector, RelationConnectorComponent } from '@obliczeniowo/elementary/connectors';
import * as i23 from '@obliczeniowo/elementary/dropdown-select';
import { DropdownSelectItem } from '@obliczeniowo/elementary/dropdown-select';
import * as i20 from '@angular/common';
import * as i22 from '@obliczeniowo/elementary/input';
import * as i25 from '@obliczeniowo/elementary/buttons';
import * as i26 from '@angular/forms';

interface BoxItemModel {
    id: string;
    subId?: string;
    options?: {
        position: IPoint2D;
        [key: string]: any;
    };
}

type BoxItemType = 'input' | 'output' | 'in-out';

interface ComponentData {
    id: string;
    type: Type<any>;
    inputOutputComponent?: Type<any>;
    value?: any;
    removable?: boolean;
    connectorType?: BoxItemType;
}

interface BoxModel {
    title: string;
    components: ComponentData[];
    type: BoxItemType;
    box?: Type<ModellerBoxComponent>;
    translations?: {
        [id: string]: string;
    };
}

interface ModellerConnectorModel extends Connector {
    start?: IPoint2D;
    end?: IPoint2D;
}

declare class ModellerBoxComponent {
    protected ref: ElementRef<HTMLElement>;
    changes: ChangeDetectorRef;
    protected modeller: ModellerService;
    model?: BoxModel;
    /** world (global translation) */
    world: Point2D;
    /** local box only translation */
    translate: Point2D;
    /** translation for dragging this stuff */
    offset: Point2D;
    index: number;
    /** Unique per box type registration */
    id?: string;
    /** globally unique id as meany the same type boxes can exists */
    subId?: string;
    /** used only for 'input'/'output' type of model */
    inputModel?: {
        [key: string]: any;
    };
    /** parent */
    parent?: ModellerSpaceComponent;
    /** */
    options?: {
        [key: string]: any;
    };
    /** used only for 'input'/'output' type of model */
    outputChanged: EventEmitterExt<any>;
    /** */
    optionsChanged: EventEmitterExt<void>;
    dragBox: EventEmitterExt<{
        mouse: MouseEvent;
        component: ModellerBoxComponent;
    }>;
    connector: EventEmitterExt<ModellerConnectorModel>;
    remove: EventEmitterExt<ModellerBoxComponent>;
    /** remove connector by id */
    removeConnector: EventEmitterExt<string>;
    protected connectors?: RelationConnectorComponent[];
    protected userModel?: {
        [key: string]: any;
    } | any[];
    protected dynamic?: boolean;
    protected type: 'input' | 'button';
    get zIndex(): number;
    get transform(): string;
    containerRef: ViewContainerRef;
    protected components: ComponentRef<any>[];
    constructor(ref: ElementRef<HTMLElement>, changes: ChangeDetectorRef, modeller: ModellerService);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    allConnectors(): RelationConnectorComponent[];
    getBoxItemModel(): BoxItemModel;
    setConnectors(connectors: RelationConnectorComponent[]): void;
    protected clear(): void;
    protected toDynamic(): void;
    protected transformUserModel(): {
        [key: string]: any;
    } | undefined;
    protected reload(): void;
    protected setRemove(component: ComponentRef<any>, com: ComponentData): void;
    protected restoreConnectors(): void;
    protected add(name?: string): void;
    item(parentId: string, subId: string, id: string): ComponentRef<any> | undefined;
    recalc(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModellerBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModellerBoxComponent, "obl-modeller-box", never, { "model": { "alias": "model"; "required": false; }; "world": { "alias": "world"; "required": false; }; "translate": { "alias": "translate"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "index": { "alias": "index"; "required": false; }; "id": { "alias": "id"; "required": false; }; "subId": { "alias": "subId"; "required": false; }; "inputModel": { "alias": "inputModel"; "required": false; }; "parent": { "alias": "parent"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "outputChanged": "outputChanged"; "optionsChanged": "optionsChanged"; "dragBox": "dragBox"; "connector": "connector"; "remove": "remove"; "removeConnector": "removeConnector"; }, never, never, false, never>;
}

declare class ConnectorItemComponent {
    protected ref: ElementRef<HTMLElement>;
    protected changes: ChangeDetectorRef;
    /** */
    left?: RelationConnectorComponent;
    /** */
    right?: RelationConnectorComponent;
    /** */
    parent?: ModellerBoxComponent;
    /** Unique per box type registration */
    id?: string;
    /** Globally unique id as meany the same type boxes can exists */
    subId?: string;
    /** */
    inputOutputComponent?: Type<any>;
    /** */
    type: BoxItemType;
    /** reserved only for input/output */
    value: any;
    /** if you can remove item */
    removable?: boolean;
    /** */
    options?: {
        [key: string]: any;
    };
    /** */
    translations?: {
        [id: string]: any;
    };
    connector: EventEmitterExt<ModellerConnectorModel>;
    /** emit id to remove item */
    remove: EventEmitterExt<string>;
    changed: EventEmitterExt<any>;
    optionsChanged: EventEmitterExt<void>;
    protected component?: ComponentRef<any>;
    containerRef: ViewContainerRef;
    getFullId(): string;
    constructor(ref: ElementRef<HTMLElement>, changes: ChangeDetectorRef);
    setConnector(side: 'left' | 'right', connector?: RelationConnectorComponent): void;
    clicked(side: 'left' | 'right', connPoint: HTMLDivElement): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    getPos(el: HTMLDivElement): Point2D;
    recalc(): void;
    protected transformed: (value: any) => void;
    protected reload(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectorItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConnectorItemComponent, "obl-connector-item", never, { "left": { "alias": "left"; "required": false; }; "right": { "alias": "right"; "required": false; }; "parent": { "alias": "parent"; "required": false; }; "id": { "alias": "id"; "required": false; }; "subId": { "alias": "subId"; "required": false; }; "inputOutputComponent": { "alias": "inputOutputComponent"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "options": { "alias": "options"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; }, { "connector": "connector"; "remove": "remove"; "changed": "changed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class ModellerService {
    protected models: Map<string, BoxModel>;
    protected translations: {
        [en: string]: string;
    };
    menuItems: MenuItem[];
    constructor();
    setTranslations(translations: {
        [en: string]: string;
    }): void;
    getTranslations(): {
        [en: string]: string;
    };
    getConnector(): typeof ConnectorItemComponent;
    register(id: string, model: BoxModel): void;
    create(id: string, container: ViewContainerRef, subId?: string, options?: {
        position: IPoint2D;
    }): i0.ComponentRef<ModellerBoxComponent>;
    setMenuItems(): void;
    getTranslation(en: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModellerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModellerService>;
}

declare class ModellerSpaceComponent {
    protected modeller: ModellerService;
    protected ref: ElementRef<HTMLElement>;
    boxes: BoxItemModel[];
    /** */
    connectorsSet: Connector[];
    /** Inputs values to filtering out */
    input: {
        [key: string]: any;
    };
    /**  */
    output: EventEmitter<any>;
    /** */
    connectorsSetChanged: EventEmitter<Connector[]>;
    /** */
    boxesChanged: EventEmitter<BoxItemModel[]>;
    /** Output filtered out values */
    protected _output: {
        [key: string]: any;
    };
    protected components: (ComponentRef<ModellerBoxComponent> | any)[];
    protected translation: Point2D;
    protected buttons: number;
    protected mouse: Point2D;
    protected mousePos: Point2D;
    protected clickedPlace: Point2D;
    protected selected?: ModellerBoxComponent;
    protected source?: string;
    protected connectors: ModellerConnectorModel[];
    protected create?: ModellerConnectorModel;
    protected connectorsComponents: QueryList<RelationConnectorComponent>;
    containerRef: ViewContainerRef;
    timer: any;
    mousemove(event: MouseEvent): void;
    mousedown(event: MouseEvent): void;
    mouseup(event: MouseEvent): void;
    protected moveCreated(): void;
    protected setBoxes(): void;
    constructor(modeller: ModellerService, ref: ElementRef<HTMLElement>);
    recalcPos(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    setInputOutput(): void;
    setConnectors(after?: () => void): void;
    removeEmptyConnector(fullId: string, side: 'left' | 'right'): boolean;
    reload(): void;
    getById(id: string): ComponentRef<any> | undefined;
    /** by assumption first one should be an output and should always exist */
    getInput(): ComponentRef<ModellerBoxComponent>;
    /** by assumption second one should be an output and should always exist */
    getOutput(): ComponentRef<ModellerBoxComponent>;
    protected menuClicked(command: string): void;
    protected removeConnector(connector: ModellerConnectorModel): void;
    protected emitConnectorsSet(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModellerSpaceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ModellerSpaceComponent, "obl-modeller-space", never, { "boxes": { "alias": "boxes"; "required": false; }; "connectorsSet": { "alias": "connectorsSet"; "required": false; }; "input": { "alias": "input"; "required": false; }; }, { "output": "output"; "connectorsSetChanged": "connectorsSetChanged"; "boxesChanged": "boxesChanged"; }, never, never, false, never>;
}

interface OblConverter {
    toTransform?: any;
    options?: {
        [key: string]: any;
    };
    translations?: {
        [en: string]: string;
    };
    transformed: EventEmitterExt<any>;
    optionsChanged: EventEmitterExt<void>;
}

declare class IntegerFilterConnectorComponent implements OblConverter {
    toTransform?: number | number[] | undefined;
    /** */
    options?: {
        [key: string]: any;
    };
    /** */
    translations?: {
        [id: string]: string;
    };
    transformed: EventEmitterExt<number | number[] | undefined>;
    optionsChanged: EventEmitterExt<void>;
    value: number | number[] | undefined;
    items: DropdownSelectItem<string>[];
    selected: string | number;
    changed(item: DropdownSelectItem<any>): void;
    transform(): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IntegerFilterConnectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IntegerFilterConnectorComponent, "obl-integer-filter-connector", never, { "toTransform": { "alias": "toTransform"; "required": false; }; "options": { "alias": "options"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; }, { "transformed": "transformed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class ConvertToHistogramComponent implements OblConverter {
    toTransform?: number[] | undefined;
    /** */
    options?: {
        [key: string]: any;
    };
    /** */
    translations?: {
        [en: string]: string;
    };
    transformed: EventEmitterExt<number[] | undefined>;
    optionsChanged: EventEmitterExt<void>;
    value?: number[];
    protected ranges: number;
    transform(): void;
    changed(event: any): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConvertToHistogramComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConvertToHistogramComponent, "obl-convert-to-histogram", never, { "toTransform": { "alias": "toTransform"; "required": false; }; "options": { "alias": "options"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; }, { "transformed": "transformed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class RangeFilterComponent implements OblConverter {
    toTransform?: number[] | undefined;
    /** */
    options?: {
        [key: string]: any;
    };
    /** */
    translations?: {
        [en: string]: string;
    };
    transformed: EventEmitterExt<number[]>;
    optionsChanged: EventEmitterExt<void>;
    max: number;
    min: number;
    value: number[] | undefined;
    updateOptions(): void;
    setMin(event: any): void;
    setMax(event: any): void;
    transform(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RangeFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RangeFilterComponent, "obl-range-filter", never, { "toTransform": { "alias": "toTransform"; "required": false; }; "options": { "alias": "options"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; }, { "transformed": "transformed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class StringConverterComponent implements OblConverter {
    toTransform?: string;
    /** */
    options?: {
        [key: string]: any;
    };
    /** */
    translations?: {
        [en: string]: string;
    };
    transformed: EventEmitterExt<string | string[]>;
    optionsChanged: EventEmitterExt<void>;
    items: DropdownSelectItem<string>[];
    selected: string | number;
    lastError: any;
    value: string | string[] | undefined;
    protected split: string;
    protected start: number;
    protected end: number;
    transform(): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    changed(item: DropdownSelectItem<any>): void;
    splitChanged(event: any): void;
    startChanged(event: any): void;
    endChanged(event: any): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StringConverterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StringConverterComponent, "obl-string-converter", never, { "toTransform": { "alias": "toTransform"; "required": false; }; "options": { "alias": "options"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; }, { "transformed": "transformed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class SplitBoxComponent extends ModellerBoxComponent {
    protected reload(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SplitBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SplitBoxComponent, "obl-split-box", never, {}, {}, never, never, false, never>;
}

declare class MathBoxComponent extends ModellerBoxComponent {
    values?: {
        left?: number;
        right?: number;
    };
    setConnectors(connectors: RelationConnectorComponent[]): void;
    protected reload(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MathBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MathBoxComponent, "obl-math-box", never, {}, {}, never, never, false, never>;
}

declare class ValueInputComponent implements OblConverter {
    id: string;
    translations?: {
        [en: string]: string;
    };
    toTransform?: number[] | number | undefined;
    header: string;
    options?: {
        [en: string]: any;
    };
    transformed: EventEmitterExt<number | number[] | undefined>;
    optionsChanged: EventEmitterExt<void>;
    transform(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ValueInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ValueInputComponent, "obl-value-input", never, { "id": { "alias": "id"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; "toTransform": { "alias": "toTransform"; "required": false; }; "header": { "alias": "header"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "transformed": "transformed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class MathOperatorComponent implements OblConverter {
    toTransform?: {
        left?: number | number[];
        right?: number | number[];
    };
    /** */
    options?: {
        [key: string]: any;
    };
    /** */
    translations?: {
        [en: string]: string;
    };
    transformed: EventEmitterExt<number | number[]>;
    optionsChanged: EventEmitterExt<void>;
    items: DropdownSelectItem<string>[];
    selected: string | number;
    value: number | number[] | undefined;
    lastError: any;
    transform(): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    changed(item: DropdownSelectItem<any>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MathOperatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MathOperatorComponent, "obl-math-operator", never, { "toTransform": { "alias": "toTransform"; "required": false; }; "options": { "alias": "options"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; }, { "transformed": "transformed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class ConstOrValueComponent implements OblConverter {
    toTransform: number;
    /** */
    options?: {
        [key: string]: any;
    };
    /** */
    translations?: {
        [en: string]: string;
    };
    transformed: EventEmitterExt<string | number | number[]>;
    optionsChanged: EventEmitterExt<void>;
    items: DropdownSelectItem<string>[];
    selected: string | number;
    value: number | string | any | undefined;
    lastError: any;
    values: {
        [key: string]: number | string;
    };
    transform(): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    changed(item: DropdownSelectItem<any>): void;
    variableChanged(variable: any): void;
    stringChanged(variable: any): void;
    jsonChanged(variable: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConstOrValueComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConstOrValueComponent, "obl-const-or-value", never, { "toTransform": { "alias": "toTransform"; "required": false; }; "options": { "alias": "options"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; }, { "transformed": "transformed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class JoinArrayToObjectBoxComponent extends ModellerBoxComponent {
    protected dynamic: boolean;
    protected reload(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JoinArrayToObjectBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JoinArrayToObjectBoxComponent, "obl-join-array-to-object-box", never, {}, {}, never, never, false, never>;
}

declare class SplitInputBoxComponent extends ModellerBoxComponent {
    protected dynamic?: boolean;
    protected reload(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SplitInputBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SplitInputBoxComponent, "obl-split-input-box", never, {}, {}, never, never, false, never>;
}

declare class GenerateComponent implements OblConverter {
    toTransform?: number[] | undefined;
    /** */
    options?: {
        [key: string]: any;
    };
    /** */
    translations?: {
        [en: string]: string;
    };
    transformed: EventEmitterExt<number[] | undefined>;
    optionsChanged: EventEmitterExt<void>;
    items: DropdownSelectItem<string>[];
    selected: string | number;
    value: number[] | undefined;
    start: number;
    end: number;
    step: number;
    count: number;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    changed(item: DropdownSelectItem<any>): void;
    transform(): void;
    ngOnDestroy(): void;
    set(field: string, ev: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenerateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GenerateComponent, "obl-generate", never, { "toTransform": { "alias": "toTransform"; "required": false; }; "options": { "alias": "options"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; }, { "transformed": "transformed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class ConcatArrayBoxComponent extends ModellerBoxComponent {
    protected ref: ElementRef<HTMLElement>;
    changes: ChangeDetectorRef;
    protected modeller: ModellerService;
    constructor(ref: ElementRef<HTMLElement>, changes: ChangeDetectorRef, modeller: ModellerService);
    protected reload(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConcatArrayBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConcatArrayBoxComponent, "obl-concat-array-box", never, {}, {}, never, never, false, never>;
}

declare class FormulaBoxComponent extends ModellerBoxComponent {
    protected dynamic: boolean;
    protected reload(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormulaBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormulaBoxComponent, "obl-formula-box", never, {}, {}, never, never, false, never>;
}

declare class FormulaComponent implements OblConverter {
    toTransform?: {
        [name: string]: number | number[];
    } | undefined;
    /** */
    options?: {
        [key: string]: any;
    };
    /** */
    translations?: {
        [en: string]: string;
    };
    transformed: EventEmitterExt<number | number[] | undefined>;
    optionsChanged: EventEmitterExt<void>;
    formula: string;
    value?: number | number[];
    transform(): void;
    changed(event: any): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormulaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormulaComponent, "obl-formula", never, { "toTransform": { "alias": "toTransform"; "required": false; }; "options": { "alias": "options"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; }, { "transformed": "transformed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class GetRequestComponent implements OblConverter {
    /** */
    options?: {
        [key: string]: any;
    };
    /** */
    translations?: {
        [en: string]: string;
    };
    transformed: EventEmitterExt<any>;
    optionsChanged: EventEmitterExt<void>;
    path: string;
    toTransform: any;
    ngOnInit(): void;
    get(): Promise<void>;
    ngOnChanges(changes: SimpleChanges): void;
    transform(): void;
    changed(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GetRequestComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GetRequestComponent, "obl-get-request", never, { "options": { "alias": "options"; "required": false; }; "translations": { "alias": "translations"; "required": false; }; "toTransform": { "alias": "toTransform"; "required": false; }; }, { "transformed": "transformed"; "optionsChanged": "optionsChanged"; }, never, never, false, never>;
}

declare class ModellerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ModellerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ModellerModule, [typeof ModellerSpaceComponent, typeof ModellerBoxComponent, typeof ConnectorItemComponent, typeof IntegerFilterConnectorComponent, typeof ConvertToHistogramComponent, typeof RangeFilterComponent, typeof StringConverterComponent, typeof SplitBoxComponent, typeof MathBoxComponent, typeof ValueInputComponent, typeof MathOperatorComponent, typeof ConstOrValueComponent, typeof JoinArrayToObjectBoxComponent, typeof SplitInputBoxComponent, typeof GenerateComponent, typeof ConcatArrayBoxComponent, typeof FormulaBoxComponent, typeof FormulaComponent, typeof GetRequestComponent], [typeof i20.CommonModule, typeof i21.ConnectorsModule, typeof i22.InputModule, typeof i23.DropdownSelectModule, typeof i24.MenuModule, typeof i25.ButtonsModule, typeof i26.FormsModule], [typeof ModellerSpaceComponent, typeof ConnectorItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ModellerModule>;
}

export { ConnectorItemComponent, ModellerModule, ModellerService, ModellerSpaceComponent };
export type { BoxItemModel, BoxItemType, BoxModel, ModellerConnectorModel };