ngx-t-forms 0.0.1

package/lib/components/t-dynamic-data-edit/elements/form-input-selector/form-input-selector.component.d.ts

@@ -0,0 +1,48 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { NgControl } from '@angular/forms';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import * as i0 from "@angular/core";
+interface IFormColumnUiList extends FormColumnInputs {
+    selected: boolean;
+    illustration: string;
+}
+export declare class FormInputSelectorComponent implements MatFormFieldControl<string | undefined> {
+    ngControl: NgControl;
+    private _elementRef;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    errors: IConfigElementError[] | undefined;
+    id: string;
+    placeholder: string;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLElement>);
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    required: boolean;
+    get errorState(): boolean;
+    controlType?: string | undefined;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    disableAutomaticLabeling?: boolean | undefined;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    touched: boolean;
+    onTouched: () => void;
+    markAsTouched(): void;
+    _value: BehaviorSubject<string | undefined>;
+    set value(value: string | undefined);
+    get value(): string | undefined;
+    get value$(): Observable<string | undefined>;
+    formInputs: Array<FormColumnInputs>;
+    disabled: boolean;
+    change: EventEmitter<any>;
+    selectInput(id: string): void;
+    get filteredInputs$(): Observable<Array<IFormColumnUiList>>;
+    getInputIllustration(input: FormColumnInputs): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormInputSelectorComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormInputSelectorComponent, "lib-form-input-selector", never, { "errors": { "alias": "errors"; "required": false; }; "value": { "alias": "value"; "required": false; }; "formInputs": { "alias": "formInputs"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+}
+export {};

package/lib/components/t-dynamic-data-edit/elements/json-editor/json-editor.component.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class JsonEditorComponent implements OnChanges, OnDestroy {
+    private fb;
+    jsonForm: FormGroup;
+    subscriptions: Subscription;
+    constructor(fb: FormBuilder);
+    ngOnDestroy(): void;
+    private _value;
+    ngOnChanges(changes: SimpleChanges): void;
+    value: Object;
+    valueChange: EventEmitter<{
+        value: Object | Array<any>;
+        valid: boolean;
+    }>;
+    jsonText: string;
+    errorMessage: string | null;
+    init(): void;
+    private parseAndBeautifyJson;
+    private getDetailedJsonError;
+    private getErrorExcerpt;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JsonEditorComponent, "app-json-editor", never, { "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/mat-chip-list-editor/mat-chip-list-editor.component.d.ts

@@ -0,0 +1,43 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import { NgControl } from '@angular/forms';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import * as i0 from "@angular/core";
+export declare class MatChipListEditorComponent implements MatFormFieldControl<{
+    label: string;
+    value: any;
+}[]> {
+    ngControl: NgControl;
+    private _elementRef;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    id: string;
+    placeholder: string;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLElement>);
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    disabled: boolean;
+    get errorState(): boolean;
+    controlType?: string | undefined;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    disableAutomaticLabeling?: boolean | undefined;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    touched: boolean;
+    onTouched: () => void;
+    markAsTouched(): void;
+    errors: IConfigElementError[] | undefined;
+    value: any;
+    required: boolean;
+    options: {
+        label: string;
+        value: any;
+    }[] | undefined;
+    valueChange: EventEmitter<any>;
+    valueListChanged(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatChipListEditorComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatChipListEditorComponent, "lib-mat-chip-list-editor", never, { "errors": { "alias": "errors"; "required": false; }; "value": { "alias": "value"; "required": false; }; "required": { "alias": "required"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/mat-slider-editor/mat-slider-editor.component.d.ts

@@ -0,0 +1,44 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import { NgControl } from '@angular/forms';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import * as i0 from "@angular/core";
+export declare class MatSliderEditorComponent implements MatFormFieldControl<number> {
+    ngControl: NgControl;
+    private _elementRef;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    id: string;
+    placeholder: string;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLElement>);
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    disabled: boolean;
+    get errorState(): boolean;
+    controlType?: string | undefined;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    disableAutomaticLabeling?: boolean | undefined;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    touched: boolean;
+    onTouched: () => void;
+    markAsTouched(): void;
+    _required: boolean;
+    set required(value: boolean);
+    get required(): boolean;
+    errors: IConfigElementError[] | undefined;
+    label: string;
+    min: number;
+    max: number;
+    step: number;
+    value: number;
+    format?: (value: any) => any;
+    formatLabel: (value: any) => any;
+    valueChange: EventEmitter<number>;
+    valueChangedSlider(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSliderEditorComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSliderEditorComponent, "lib-mat-slider-editor", never, { "required": { "alias": "required"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "label": { "alias": "label"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "value": { "alias": "value"; "required": false; }; "format": { "alias": "format"; "required": false; }; "formatLabel": { "alias": "formatLabel"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/mat-slider-toggle-editor/mat-slider-toggle-editor.component.d.ts

@@ -0,0 +1,48 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs/internal/Subject';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import * as i0 from "@angular/core";
+export declare class MatSliderToggleEditorComponent implements MatFormFieldControl<boolean>, ControlValueAccessor {
+    ngControl: NgControl;
+    private _elementRef;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    focused: boolean;
+    touched: boolean;
+    disabled: boolean;
+    controlType: string;
+    autofilled: boolean;
+    name: string | undefined;
+    label: string;
+    errors: IConfigElementError[] | undefined;
+    valueChange: EventEmitter<boolean>;
+    private _required;
+    get required(): boolean;
+    set required(value: boolean);
+    private _value;
+    get value(): boolean;
+    set value(val: boolean);
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    id: string;
+    describedBy: string;
+    get shouldLabelFloat(): boolean;
+    get empty(): boolean;
+    get errorState(): boolean;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLElement>);
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    markAsTouched(): void;
+    valueToggleChanged(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatSliderToggleEditorComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatSliderToggleEditorComponent, "lib-mat-slider-toggle-editor", never, { "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/mscoa-segment-config/mscoa-segment-config.component.d.ts

@@ -0,0 +1,75 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { FormGroup, FormBuilder, NgControl } from '@angular/forms';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { IGetTreeResponse } from 'ngx-t-forms-types';
+import { MatSlideToggleChange } from '@angular/material/slide-toggle';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import * as i0 from "@angular/core";
+interface IIncludedSegmentConfig {
+    segment: string;
+    label: string;
+    readOnly: boolean;
+    singleSelect: boolean;
+}
+export declare class MscoaSegmentConfigComponent implements OnInit, OnDestroy, MatFormFieldControl<IIncludedSegmentConfig[]> {
+    private fb;
+    ngControl: NgControl;
+    private _elementRef;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    id: string;
+    placeholder: string;
+    constructor(fb: FormBuilder, ngControl: NgControl, _elementRef: ElementRef<HTMLElement>);
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    required: boolean;
+    disabled: boolean;
+    get errorState(): boolean;
+    controlType?: string | undefined;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    disableAutomaticLabeling?: boolean | undefined;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    touched: boolean;
+    onTouched: () => void;
+    markAsTouched(): void;
+    errors: IConfigElementError[] | undefined;
+    set value(val: IIncludedSegmentConfig[]);
+    get value(): IIncludedSegmentConfig[];
+    _getMscoaTree: Observable<IGetTreeResponse> | undefined;
+    _showAllSegments: boolean;
+    set showAllSegments(val: boolean);
+    get showAllSegments(): boolean;
+    set getMscoaTree(options$: Observable<IGetTreeResponse> | undefined);
+    valueChanged: EventEmitter<IIncludedSegmentConfig[]>;
+    private _value;
+    private destroy$;
+    mscoaTree: IGetTreeResponse | null;
+    treeSegments: IIncludedSegmentConfig[];
+    error$: BehaviorSubject<string | null>;
+    segmentForm: FormGroup;
+    editingIndex: number | null;
+    isAddingNew: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getMscoaError: string | undefined;
+    private loadMscoa;
+    private createSegmentForm;
+    private listenToFormChanges;
+    startAddNew(): void;
+    startEdit(index: number): void;
+    cancelEdit(): void;
+    saveSegment(): void;
+    readOnly(event: MatSlideToggleChange): void;
+    singleSelectChange(event: MatSlideToggleChange): void;
+    removeSegment(index: number): void;
+    private toTitleCase;
+    alreadyExists(segment: string): IIncludedSegmentConfig | undefined;
+    checkShowAllSegments(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MscoaSegmentConfigComponent, [null, { optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MscoaSegmentConfigComponent, "app-mscoa-segment-config", never, { "errors": { "alias": "errors"; "required": false; }; "value": { "alias": "value"; "required": false; }; "showAllSegments": { "alias": "showAllSegments"; "required": false; }; "getMscoaTree": { "alias": "getMscoaTree"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+export {};

package/lib/components/t-dynamic-data-edit/elements/pipeline-generator/elements/aggregate-stage-editor/aggregate-stage-editor.component.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { IAllowedStage } from '../../../../../../services/hhtpResources/Pipeline/pipeline.service';
+import { MatSelectChange } from '@angular/material/select';
+import * as i0 from "@angular/core";
+export declare class AggregateStageEditorComponent implements OnInit {
+    subscription: Subscription;
+    selectedStage: any;
+    isRunningPipeline: boolean;
+    saveStage: EventEmitter<IAllowedStage | undefined>;
+    deleteStage: EventEmitter<void>;
+    ngOnDestroy(): void;
+    constructor();
+    activeStage: IAllowedStage | undefined;
+    allowedStages: {
+        stage: string;
+        description: string;
+        config: any;
+    }[];
+    configValidationError: string | undefined;
+    ngOnInit(): void;
+    handleChange(event: MatSelectChange): void;
+    handleConfigChange(event: any): void;
+    validateConfig(): void;
+    canSaveConfig(): boolean;
+    saveConfiguration(): void;
+    trackByStage(index: number, stage: any): string;
+    get allowedStageNames(): string[];
+    get activeDescription(): string | undefined;
+    deleteActive(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AggregateStageEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AggregateStageEditorComponent, "app-aggregate-stage-editor", never, { "selectedStage": { "alias": "selectedStage"; "required": false; }; "isRunningPipeline": { "alias": "isRunningPipeline"; "required": false; }; }, { "saveStage": "saveStage"; "deleteStage": "deleteStage"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/pipeline-generator/pipeline-generator.component.d.ts

@@ -0,0 +1,92 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Subject, Observable } from 'rxjs';
+import { MongoDbPipeLineConfigInterface } from "ngx-t-forms-types";
+import { IWorkflowOption } from "ngx-t-forms-types";
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import * as i0 from "@angular/core";
+export declare class PipelineGeneratorComponent implements OnInit, OnDestroy, MatFormFieldControl<MongoDbPipeLineConfigInterface> {
+    ngControl: NgControl;
+    private _elementRef;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    NGX_T_FORMS_CONFIG: import("ngx-t-forms-types").NgxTFormsConfig;
+    id: string;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLElement>);
+    placeholder: string;
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    required: boolean;
+    disabled: boolean;
+    get errorState(): boolean;
+    controlType?: string | undefined;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    disableAutomaticLabeling?: boolean | undefined;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    touched: boolean;
+    onTouched: () => void;
+    markAsTouched(): void;
+    textareaElementRef: ElementRef;
+    set value(value: MongoDbPipeLineConfigInterface);
+    workflowOptions: IWorkflowOption[];
+    loadingWorkflowOptions: boolean;
+    workflowsInitialized: boolean;
+    set getWorkflowOptions(options$: Observable<IWorkflowOption[]> | undefined);
+    userName: string | undefined;
+    _value: MongoDbPipeLineConfigInterface;
+    valueChanged: EventEmitter<MongoDbPipeLineConfigInterface>;
+    errors: IConfigElementError[] | undefined;
+    destroy$: Subject<void>;
+    private pipeline;
+    ngOnInit(): void;
+    initiated: boolean;
+    initiateSubscription: () => void;
+    ngOnDestroy(): void;
+    workflowChanged(event: any): void;
+    get workflowId(): Observable<string | undefined>;
+    get stages(): Observable<{
+        name: string | undefined;
+        stage: string | undefined;
+        config: any;
+        valid: boolean;
+    }[]>;
+    get pipeLineResults(): Observable<unknown>;
+    get prompt(): Observable<string | undefined>;
+    get aiIsGeneratingPipeline(): boolean;
+    get activeStageIndex(): Observable<number | undefined>;
+    get activeStage(): Observable<{
+        name: string;
+        config: import("mongoose").PipelineStage;
+    } | undefined>;
+    get isRunningPipeline(): boolean;
+    get cannotAddStage(): Observable<boolean>;
+    get schemaLoadError$(): Observable<string | undefined>;
+    get chatHistory(): Observable<{
+        user: string;
+        assistance: import("ngx-t-forms-types").IPipelineGenerationResponse;
+        date: Date;
+    }[]>;
+    cursorPosition: number;
+    showSuggestions: boolean;
+    onTextChange(event: Event): void;
+    selectSuggestionInput(suggestion: string): void;
+    applyNewValueToPrompt(suggestion: any): void;
+    optionsSearch: string;
+    onSearchChange(event: any): void;
+    promptSubmit(): void;
+    trackById: (index: number, stage: any) => number;
+    setActiveStage(index: number | undefined): void;
+    addStage(): void;
+    get getSchemaProperties(): Observable<{
+        label: string;
+        value: string;
+    }[]>;
+    deleteStage(index: number): void;
+    saveStage(index: number, stage: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PipelineGeneratorComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PipelineGeneratorComponent, "app-pipeline-generator", never, { "value": { "alias": "value"; "required": false; }; "getWorkflowOptions": { "alias": "getWorkflowOptions"; "required": false; }; "userName": { "alias": "userName"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/postman-collections/functions/convertPostmanCollectionToTree.d.ts

@@ -0,0 +1,4 @@
+import { IFolderItem } from 'ngx-t-forms-types';
+import { TreeNode } from 'ngx-t-forms-types';
+export declare function convertPostmanFolderItemsToTree(obj: IFolderItem[] | undefined, parentPath?: string[]): TreeNode[];
+export declare function flatApiList(obj: IFolderItem[] | undefined): IFolderItem[];

package/lib/components/t-dynamic-data-edit/elements/postman-collections/functions/filterCollectionItems.d.ts

@@ -0,0 +1,3 @@
+import { IFolderItem, IGetPostmanCollections } from 'ngx-t-forms-types';
+export declare function filterCollectionItems(collections: IGetPostmanCollections, searchKey: string): IFolderItem[];
+export declare function searchInItems(items: IFolderItem[], searchText: string): boolean;

package/lib/components/t-dynamic-data-edit/elements/postman-collections/functions/methodColors.d.ts

@@ -0,0 +1 @@
+export declare function methodColor(method: string): string;

package/lib/components/t-dynamic-data-edit/elements/postman-collections/postman-collections.component.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { TreeComponent } from '../api-value-access-rules/functions/convertDataToTree';
+import { IFolderItem, IGetPostmanCollections, IPostmanCollectionConfig } from "ngx-t-forms-types";
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class PostmanCollectionsComponent implements OnInit {
+    private readonly httpClient;
+    private _collection$;
+    get collection$(): Observable<IGetPostmanCollections | undefined>;
+    treeComponent: TreeComponent;
+    nodeSelectionChanged: EventEmitter<IFolderItem>;
+    constructor(httpClient: HttpClient);
+    ngOnInit(): void;
+    _searchKey: string;
+    postmanCollectionConfig: IPostmanCollectionConfig | undefined;
+    loadingEndPoints: string[];
+    selectNode(node: IFolderItem): void;
+    private isValidConfig;
+    error: HttpErrorResponse | undefined;
+    loading: boolean;
+    private initializePostmanService;
+    methodColor(method: string): string;
+    searchTree(event: any): void;
+    getNodeLines(level: number): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PostmanCollectionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PostmanCollectionsComponent, "app-postman-collections", never, { "postmanCollectionConfig": { "alias": "postmanCollectionConfig"; "required": false; }; "loadingEndPoints": { "alias": "loadingEndPoints"; "required": false; }; }, { "nodeSelectionChanged": "nodeSelectionChanged"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/required-inputs/required-inputs.component.d.ts

@@ -0,0 +1,57 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { MinimumInputRequiredInterface, MinInputTypes } from 'ngx-t-forms-types';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import * as i0 from "@angular/core";
+interface MapToInputs extends FormColumnInputs {
+    illustration: string;
+    activated: boolean;
+}
+export declare class RequiredInputsComponent implements MatFormFieldControl<MinimumInputRequiredInterface[]> {
+    ngControl: NgControl;
+    private _elementRef;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    id: string;
+    placeholder: string;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLElement>);
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    required: boolean;
+    disabled: boolean;
+    errors: IConfigElementError[] | undefined;
+    get errorState(): boolean;
+    controlType?: string | undefined;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    disableAutomaticLabeling?: boolean | undefined;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    touched: boolean;
+    onTouched: () => void;
+    markAsTouched(): void;
+    private _value;
+    set value(v: Array<MinimumInputRequiredInterface>);
+    get value(): Array<MinimumInputRequiredInterface>;
+    formInputs: FormColumnInputs[];
+    valueChanged: EventEmitter<any>;
+    activeInput: string;
+    minInputTypes: typeof MinInputTypes;
+    minInputValueType(type: MinInputTypes): void;
+    get minInputInEdit(): MinimumInputRequiredInterface;
+    set minInputInEdit(v: MinimumInputRequiredInterface);
+    save(): void;
+    inputIsDisabled(input: FormColumnInputs): boolean;
+    mapTo(input: FormColumnInputs): void;
+    inputMappedTo(formControlName: string): boolean;
+    getInputIllustration(input: FormColumnInputs): string;
+    get formInputsToMapTo(): MapToInputs[];
+    get activatedInputs(): MapToInputs | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequiredInputsComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RequiredInputsComponent, "app-required-inputs", never, { "errors": { "alias": "errors"; "required": false; }; "value": { "alias": "value"; "required": false; }; "formInputs": { "alias": "formInputs"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+export {};

package/lib/components/t-dynamic-data-edit/elements/rest-api-call-setup/rest-api-call-setup.component.d.ts

@@ -0,0 +1,46 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { IFolderItem, IPostmanCollectionConfig } from "ngx-t-forms-types";
+import { APIDataFetchingConfigurationInterface } from 'ngx-t-forms-types';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Observable, Subject } from 'rxjs';
+import { NgControl } from '@angular/forms';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import * as i0 from "@angular/core";
+export declare class RestApiCallSetupComponent implements MatFormFieldControl<APIDataFetchingConfigurationInterface | undefined> {
+    ngControl: NgControl;
+    private _elementRef;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    id: string;
+    placeholder: string;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLElement>);
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    required: boolean;
+    disabled: boolean;
+    get errorState(): boolean;
+    controlType?: string | undefined;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    disableAutomaticLabeling?: boolean | undefined;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    touched: boolean;
+    onTouched: () => void;
+    markAsTouched(): void;
+    postmanCollectionConfig: IPostmanCollectionConfig | undefined;
+    httpGetDataFunction: ((url: string, options: any) => Observable<any>) | undefined;
+    private _value;
+    set value(val: APIDataFetchingConfigurationInterface | undefined);
+    get value(): APIDataFetchingConfigurationInterface | undefined;
+    errors: IConfigElementError[] | undefined;
+    valueChanged: EventEmitter<APIDataFetchingConfigurationInterface | undefined>;
+    loadingEndPoints: string[];
+    nodeSelectionChanged(node: IFolderItem): Promise<void>;
+    clearValue(): void;
+    methodColor(method: string | undefined): string;
+    get hasValidValue(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RestApiCallSetupComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RestApiCallSetupComponent, "lib-rest-api-call-setup", never, { "postmanCollectionConfig": { "alias": "postmanCollectionConfig"; "required": false; }; "httpGetDataFunction": { "alias": "httpGetDataFunction"; "required": false; }; "value": { "alias": "value"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/selection-options-editor/selection-options-editor.component.d.ts

@@ -0,0 +1,48 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { FormGroup, NgControl } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import * as i0 from "@angular/core";
+export declare class SelectionOptionsEditorComponent implements MatFormFieldControl<any> {
+    ngControl: NgControl;
+    private _elementRef;
+    value: any;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    errors: IConfigElementError[] | undefined;
+    id: string;
+    placeholder: string;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLElement>);
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    required: boolean;
+    disabled: boolean;
+    get errorState(): boolean;
+    controlType?: string | undefined;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    disableAutomaticLabeling?: boolean | undefined;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    touched: boolean;
+    onTouched: () => void;
+    markAsTouched(): void;
+    private _options;
+    get options(): any;
+    set options(val: any);
+    valueChanged: EventEmitter<any>;
+    inEdit: any;
+    form: FormGroup;
+    add(): void;
+    remove(option: any): void;
+    createForm(inEdit: any): void;
+    closeEdit(): void;
+    save(): void;
+    overrideObjectById(array: any[], newObj: any): any[];
+    addObjectToArray(array: any[], newObj: any): any[];
+    removeObjectById(array: any[], id: number): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionOptionsEditorComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectionOptionsEditorComponent, "app-selection-options-editor", never, { "errors": { "alias": "errors"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/t-workflow-picker/t-workflow-picker.component.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { IWorkflowOption } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class TWorkflowPickerComponent implements OnInit {
+    private _workflowOptions;
+    set getWorkflowOptions(value: IWorkflowOption[]);
+    value: string | undefined | null;
+    valueChanged: EventEmitter<string | undefined>;
+    constructor();
+    error: any;
+    loading: boolean;
+    ngOnInit(): void;
+    get workflowOptions(): IWorkflowOption[];
+    unbindInput(): void;
+    bindInput(workflow: IWorkflowOption): void;
+    get selectedWorkflow(): IWorkflowOption | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TWorkflowPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TWorkflowPickerComponent, "lib-t-workflow-picker", never, { "getWorkflowOptions": { "alias": "getWorkflowOptions"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}