ngx-t-forms 0.0.1

package/lib/components/forms/store/Forms-Effects.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from "rxjs";
+import { FormsStoreService } from "./forms-store.service";
+import { FormInterface } from "ngx-t-forms-types";
+import { FormListSection } from "ngx-t-forms-types";
+export declare function formsStoreEffects(store: FormsStoreService): {
+    createForm$: (observableOrValue: FormInterface | Observable<FormInterface>) => import("rxjs").Subscription;
+    loadForms$: (observableOrValue?: void | Observable<void> | undefined) => import("rxjs").Subscription;
+    loadForm$: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    updateForm$: (observableOrValue: FormInterface | Observable<FormInterface>) => import("rxjs").Subscription;
+    archiveForm$: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    setListSection$: (observableOrValue: FormListSection | Observable<FormListSection>) => import("rxjs").Subscription;
+    unArchiveForm$: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    deleteForm$: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+};

package/lib/components/forms/store/Forms-selectors.d.ts

@@ -0,0 +1,24 @@
+import { LocalFormStateSelectorInterface } from "ngx-t-forms-types";
+import { FormsStoreService } from "./forms-store.service";
+export declare function formsStoreSelectors(store: FormsStoreService): {
+    state$: import("rxjs").Observable<import("ngx-t-forms-types").IFormsInitStateInterface>;
+    selectForms$: import("rxjs").Observable<LocalFormStateSelectorInterface[]>;
+    selectFormInEdit$: import("rxjs").Observable<import("ngx-t-forms-types").DatabaseFormInterface | null>;
+    selectFormBuilderIsBusy$: import("rxjs").Observable<boolean>;
+    selectLoadingForm$: import("rxjs").Observable<boolean>;
+    selectLoadingForms$: import("rxjs").Observable<boolean>;
+    selectFormId$: import("rxjs").Observable<string | null>;
+    selectErrors$: import("rxjs").Observable<{
+        ArchiveForm: string | undefined;
+        CreateForm: string | undefined;
+        UpdateForm: string | undefined;
+        GetForm: string | undefined;
+        LoadForms: string | undefined;
+    } | null>;
+    selectFormListSection$: import("rxjs").Observable<import("ngx-t-forms-types").FormListSection>;
+    selectFormUpdated$: import("rxjs").Observable<string | Date | null>;
+    selectRouterState$: import("rxjs").Observable<import("@angular/router").ActivatedRouteSnapshot | null>;
+    selectSubmittingForm$: import("rxjs").Observable<boolean>;
+    selectFormInitialValues$: import("rxjs").Observable<Record<string, any> | null>;
+    selectInputInEditId$: import("rxjs").Observable<string | null>;
+};

package/lib/components/forms/store/forms-store.service.d.ts

@@ -0,0 +1,246 @@
+import { ComponentStore } from '@ngrx/component-store';
+import { FormListSection, IFormsInitStateInterface, InClassFormUtilsInterface } from "ngx-t-forms-types";
+import { Observable } from 'rxjs';
+import { DatabaseFormInterface, FormInterface, NgxTFormsConfig } from "ngx-t-forms-types";
+import { HttpClient } from '@angular/common/http';
+import { IWorkflowOption } from "ngx-t-forms-types";
+import { IGetTreeResponse } from "ngx-t-forms-types";
+import { FileUploadFn } from '../functions/formHttpSubmissions';
+import { IUserSignature } from "ngx-t-forms-types";
+import { PointGroup } from 'signature_pad';
+import { AbstractControl } from '@angular/forms';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { HintType } from '../../../shared/functions/textIconsForUserHints';
+import * as i0 from "@angular/core";
+export interface ActionButton {
+    icon: string;
+    color: string;
+    onClick: () => void;
+}
+export interface IStoreFunctions {
+    [x: string]: any;
+    formsCloseButton: ActionButton;
+    formBuilderCloseButton: ActionButton;
+    createForm: (form: FormInterface) => Observable<DatabaseFormInterface>;
+    updateForm: (form: FormInterface) => Observable<DatabaseFormInterface>;
+    archiveForm: (formId: string) => Observable<{
+        message: string;
+    }>;
+    unArchiveForm: (formId: string) => Observable<{
+        message: string;
+    }>;
+    deleteForm: (formId: string) => Observable<{
+        message: string;
+    }>;
+    getForm: (formId: string) => Observable<DatabaseFormInterface | null>;
+    loadForms: () => Observable<DatabaseFormInterface[]>;
+    loadArchivedForms: () => Observable<DatabaseFormInterface[]>;
+    toastSuccess: (message: string) => void;
+    toastError: (message: string) => void;
+    workflows: () => Observable<IWorkflowOption[]>;
+    getScoaTree: () => Observable<IGetTreeResponse>;
+    getSCOAAccount(SCOAAccount: string): Observable<any>;
+    editForm: (formId: string) => void;
+    addNewForm: () => void;
+    saveFormData: (formId: string, data: {
+        [key: string]: any;
+    }) => Observable<void>;
+    setListSection: (section: FormListSection) => void;
+    runMongoDbPipeLine: (pipeline: any, workflowId: string) => Observable<{
+        results: any;
+        message: string;
+    }>;
+    fileUpload: FileUploadFn;
+    formSubmittedSuccessfully: (formId: string) => void;
+    getUserSignature: () => Observable<IUserSignature>;
+    saveUserSignature: (signature: PointGroup[]) => Observable<void>;
+}
+export declare const initialUIState: IFormsInitStateInterface;
+export declare class FormsStoreService extends ComponentStore<IFormsInitStateInterface> {
+    httpClient: HttpClient;
+    snackBar: MatSnackBar;
+    sectionPlaceholder: Record<string, AbstractControl>;
+    readonly NGX_T_FORMS_CONFIG: NgxTFormsConfig;
+    constructor();
+    utils: InClassFormUtilsInterface;
+    showMessage(message: string, type: HintType): void;
+    private setupDevTools;
+    get resourceFunctions(): IStoreFunctions | null;
+    readonly selectors: {
+        state$: Observable<IFormsInitStateInterface>;
+        selectForms$: Observable<import("ngx-t-forms-types").LocalFormStateSelectorInterface[]>;
+        selectFormInEdit$: Observable<DatabaseFormInterface | null>;
+        selectFormBuilderIsBusy$: Observable<boolean>;
+        selectLoadingForm$: Observable<boolean>;
+        selectLoadingForms$: Observable<boolean>;
+        selectFormId$: Observable<string | null>;
+        selectErrors$: Observable<{
+            ArchiveForm: string | undefined;
+            CreateForm: string | undefined;
+            UpdateForm: string | undefined;
+            GetForm: string | undefined;
+            LoadForms: string | undefined;
+        } | null>;
+        selectFormListSection$: Observable<FormListSection>;
+        selectFormUpdated$: Observable<string | Date | null>;
+        selectRouterState$: Observable<import("@angular/router").ActivatedRouteSnapshot | null>;
+        selectSubmittingForm$: Observable<boolean>;
+        selectFormInitialValues$: Observable<Record<string, any> | null>;
+        selectInputInEditId$: Observable<string | null>;
+    };
+    readonly formBuilderSelectors: {
+        selectFormSlides$: Observable<import("ngx-t-forms-types").FormSlideInterface[]>;
+        missingConfig$: Observable<string[]>;
+        canSaveForm$: Observable<boolean>;
+        isNewForm$: Observable<boolean>;
+        hasMissingConfigs$: Observable<boolean>;
+        formErrors$: Observable<{
+            key: string;
+            message: string;
+        }[]>;
+        formValidationErrorsMessages$: Observable<string[]>;
+        inputInEdit$: Observable<import("ngx-t-forms-types").FormColumnInputs | undefined>;
+        defaultInputInEdit$: Observable<any>;
+        inputInEditValidationErrors$: Observable<import("ngx-t-forms-types").ValidationError[]>;
+        selectFormTitle$: Observable<string | undefined>;
+        getAllFormInputs$: Observable<import("ngx-t-forms-types").FormColumnInputs[]>;
+        inputElementEditorConfigs$: Observable<{
+            editorSections: {
+                elements: import("ngx-t-forms-types").ElementEditorInnerSectionElementInterface[];
+                hasErrors: boolean;
+                label: string;
+                showItemValue?: keyof import("ngx-t-forms-types").FormColumnInputs;
+                id: string;
+                additionalTest?: import("ngx-t-forms-types").ConfigurationValidTestInterface[];
+            }[];
+            title?: string;
+            description?: string;
+        }>;
+        selectFormSlideSections$: Observable<{
+            inputConfigErrors: {
+                key: string;
+                message: string;
+            }[];
+            sectionId: string;
+            label: string;
+            columns: Array<import("ngx-t-forms-types").FormColumnInputs>;
+            inEdit?: boolean;
+            sectionIsSeen?: boolean;
+            isActive?: boolean;
+        }[]>;
+    };
+    readonly actions: {
+        loadFormListSuccess: (observableOrValue: {
+            forms: DatabaseFormInterface[];
+        } | Observable<{
+            forms: DatabaseFormInterface[];
+        }>) => import("rxjs").Subscription;
+        toggleFormBuilderBusy: () => void;
+        toggleLoadingForm: () => void;
+        toggleLoadingForms: (observableOrValue: {
+            loadingForms: boolean;
+        } | Observable<{
+            loadingForms: boolean;
+        }>) => import("rxjs").Subscription;
+        loadFormSuccess: (observableOrValue: {
+            form: DatabaseFormInterface;
+        } | Observable<{
+            form: DatabaseFormInterface;
+        }>) => import("rxjs").Subscription;
+        toggleFormBusy: (observableOrValue: {
+            formId: string;
+        } | Observable<{
+            formId: string;
+        }>) => import("rxjs").Subscription;
+        archivedSuccess: (observableOrValue: {
+            formId: string;
+        } | Observable<{
+            formId: string;
+        }>) => import("rxjs").Subscription;
+        setFormId: (observableOrValue: {
+            formId: string;
+        } | Observable<{
+            formId: string;
+        }>) => import("rxjs").Subscription;
+        setError: (observableOrValue: {
+            error: string | undefined;
+            type: import("ngx-t-forms-types").FormStateErrors;
+        } | Observable<{
+            error: string | undefined;
+            type: import("ngx-t-forms-types").FormStateErrors;
+        }>) => import("rxjs").Subscription;
+        handleListSectionChange: (observableOrValue: {
+            listSection: FormListSection;
+        } | Observable<{
+            listSection: FormListSection;
+        }>) => import("rxjs").Subscription;
+        handleRouterStateChange: (observableOrValue: {
+            routerState: import("@angular/router").ActivatedRouteSnapshot | null;
+        } | Observable<{
+            routerState: import("@angular/router").ActivatedRouteSnapshot | null;
+        }>) => import("rxjs").Subscription;
+        handleSetSubmittingForm: (observableOrValue: {
+            submittingForm: boolean;
+        } | Observable<{
+            submittingForm: boolean;
+        }>) => import("rxjs").Subscription;
+        setFormInitialValues: (observableOrValue: {
+            initialFormValues: Record<string, any>;
+        } | Observable<{
+            initialFormValues: Record<string, any>;
+        }>) => import("rxjs").Subscription;
+        handleEditorUpdateFormInEdit: (observableOrValue: {
+            form: FormInterface;
+        } | Observable<{
+            form: FormInterface;
+        }>) => import("rxjs").Subscription;
+        setInputInEditId: (observableOrValue: {
+            inputInEdit: string | null;
+        } | Observable<{
+            inputInEdit: string | null;
+        }>) => import("rxjs").Subscription;
+    };
+    readonly actionsFormBuilder: {
+        handelSaveForm: () => void;
+        setFormTitle: (title: string) => void;
+        handleSectionDragDrop: (event: import("@angular/cdk/drag-drop").CdkDragDrop<any, any, any>) => void;
+        handleInputDragDrop: (event: import("@angular/cdk/drag-drop").CdkDragDrop<any, any, any>, sectionId: string) => void;
+        handleAddSection: () => void;
+        stepTitleChangeStep: (sectionId: string, title: string) => void;
+        formDeleteInput: (item: import("ngx-t-forms-types").FormColumnInputs) => void;
+        multipleInputToggleLabel: (item: import("ngx-t-forms-types").FormColumnInputs) => void;
+        editInput: (item: import("ngx-t-forms-types").FormColumnInputs) => void;
+        addMultipleInputValueCalculationFunction: (item: import("ngx-t-forms-types").IMultipleInputCal, multipleInputId: string | undefined) => void;
+        formDeleteSection: (sectionId: string) => void;
+        moveInputToSection: (inputId: string, targetSectionId: string) => void;
+        reorderMultipleInputItems: (event: import("@angular/cdk/drag-drop").CdkDragDrop<import("ngx-t-forms-types").FormColumnInputs[], any, any>, multipleInputId: string) => void;
+        cloneCopyFormInput: (inputId: string) => void;
+        saveInput: (sectionId: string) => void;
+        applyFormTemplate: (form: FormInterface) => void;
+        selectInputTemplate: (inputId: string, element: import("ngx-t-forms-types").ElementTypes) => void;
+        formInputChange: (ele: import("ngx-t-forms-types").ElementEditorInnerSectionElementInterface, value: any) => void;
+        saveSubmitApi: (dataPlaceholder: undefined | {
+            data: import("ngx-t-forms-types").APIDataFetchingConfigurationInterface;
+        }, keyInEdit: "submissionAPI" | "canSubmitAPI" | undefined) => void;
+        removeSubmissionApi: (api: import("ngx-t-forms-types").APIDataFetchingConfigurationInterface, keyInEdit: "submissionAPI" | "canSubmitAPI" | undefined) => void;
+        elementConfigurationChanged: (inputId: string, value: any, ele: import("ngx-t-forms-types").ElementEditorInnerSectionElementInterface) => void;
+        elementBlur: (inputId: string, event: any, element: import("ngx-t-forms-types").ElementEditorInnerSectionElementInterface) => void;
+        addMultipleFormInput: (sectionId: string, multipleInputInEditId: string) => void;
+        clearInputInEdit: (inputId: string) => void;
+    };
+    readonly effects: {
+        createForm$: (observableOrValue: FormInterface | Observable<FormInterface>) => import("rxjs").Subscription;
+        loadForms$: (observableOrValue?: void | Observable<void> | undefined) => import("rxjs").Subscription;
+        loadForm$: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+        updateForm$: (observableOrValue: FormInterface | Observable<FormInterface>) => import("rxjs").Subscription;
+        archiveForm$: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+        setListSection$: (observableOrValue: FormListSection | Observable<FormListSection>) => import("rxjs").Subscription;
+        unArchiveForm$: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+        deleteForm$: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    };
+    refreshExternalFormStates?: (form: FormInterface) => void;
+    registerFormChangeFn(fn: (form: FormInterface) => void): void;
+    createFormPlaceHolderFormGroups(form: FormInterface): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormsStoreService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormsStoreService>;
+}

package/lib/components/index.d.ts

@@ -0,0 +1,11 @@
+import { DialogTemplateComponent } from "./dialog-template/dialog-template.component";
+import { FormBuilderComponent } from "./form-builder/form-builder.component";
+import { FormsComponent } from "./forms/forms.component";
+import { TDynamicDataEditComponent } from "./t-dynamic-data-edit/t-dynamic-data-edit.component";
+import { TDynamicDataViewComponent } from "./t-dynamic-data-view/t-dynamic-data-view.component";
+import { SyncEditorComponent } from "./t-form-input/elements/editor-input-element/core/form-input-rich-text-editor/sync-editor/sync-editor.component";
+import { MscoaFormInputComponent } from "./t-form-input/elements/mscoa-form-input/mscoa-form-input.component";
+import { SignatureInputElementComponent } from "./t-form-input/elements/signature-input-element/signature-input-element.component";
+import { TFormInputComponent } from "./t-form-input/t-form-input.component";
+import { UserFormStepperComponent } from "./user-form-stepper/user-form-stepper.component";
+export { FormsComponent, FormBuilderComponent, MscoaFormInputComponent, UserFormStepperComponent, TFormInputComponent, SyncEditorComponent, TDynamicDataEditComponent, TDynamicDataViewComponent, DialogTemplateComponent, SignatureInputElementComponent };

package/lib/components/t-dynamic-data-edit/elements/api-value-access-rules/api-value-access-rules.component.d.ts

@@ -0,0 +1,59 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { TreeNode } from "ngx-t-forms-types";
+import { FormColumnInputs } from 'ngx-t-forms-types';
+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 { IFolderItem, IPostmanCollectionConfig } from "ngx-t-forms-types";
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class ApiValueAccessRulesComponent implements MatFormFieldControl<TreeNode[] | string | {
+    [key: string]: TreeNode[] | string;
+}> {
+    ngControl: NgControl;
+    private _elementRef;
+    private readonly httpClient;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    id: string;
+    placeholder: string;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLElement>, httpClient: HttpClient);
+    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;
+    multipleBind: string[] | undefined;
+    errors: IConfigElementError[] | undefined;
+    value: TreeNode[] | string | {
+        [key: string]: TreeNode[] | string;
+    };
+    mapToData: any;
+    formInputs: FormColumnInputs[];
+    valueChanged: EventEmitter<any>;
+    reload: EventEmitter<any>;
+    _postManCollectionConfig: IPostmanCollectionConfig | undefined;
+    set postmanCollectionConfig(postmanCollectionConfig: IPostmanCollectionConfig | undefined);
+    get postmanCollectionConfig(): IPostmanCollectionConfig | undefined;
+    get computedValue(): any;
+    pathChanged(path: TreeNode[] | string, control?: string): void;
+    private isValidConfig;
+    error: HttpErrorResponse | undefined;
+    loading: boolean;
+    postManFolderItems: IFolderItem[];
+    private initializePostmanService;
+    get postmanResponseBody(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiValueAccessRulesComponent, [{ optional: true; self: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ApiValueAccessRulesComponent, "app-api-value-access-rules", never, { "multipleBind": { "alias": "multipleBind"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "value": { "alias": "value"; "required": false; }; "mapToData": { "alias": "mapToData"; "required": false; }; "formInputs": { "alias": "formInputs"; "required": false; }; "postmanCollectionConfig": { "alias": "postmanCollectionConfig"; "required": false; }; }, { "valueChanged": "valueChanged"; "reload": "reload"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/api-value-access-rules/elements/data-tree/data-tree.component.d.ts

@@ -0,0 +1,60 @@
+import { ElementRef, EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { TreeComponent } from '../../functions/convertDataToTree';
+import { FlatNode, TreeNode } from 'ngx-t-forms-types';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { MatSelectChange } from '@angular/material/select';
+import * as i0 from "@angular/core";
+export declare class DataTreeComponent implements OnInit, OnChanges {
+    treeClass: TreeComponent;
+    data: any;
+    value: TreeNode[] | string;
+    formInputs: FormColumnInputs[];
+    pathChanged: EventEmitter<string | TreeNode[]>;
+    constructor();
+    _data: any;
+    _value: TreeNode[] | string;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    textareaElementRef: ElementRef;
+    showSuggestions: boolean;
+    suggestions: string[];
+    filteredSuggestions: string[];
+    cursorPosition: number;
+    valueChangedSetPath(newPath: TreeNode[] | string): void;
+    onTextChange(event: Event): Promise<void>;
+    functionChanged(event: MatSelectChange): void;
+    addNewFunction(): void;
+    editFunction(id: string): void;
+    selectSuggestionInput(suggestion: string): void;
+    onFocus(event: FocusEvent): void;
+    nodeIsChecked(node: FlatNode): boolean;
+    hasANodeInEdit(): boolean;
+    showNode(node: FlatNode): boolean;
+    onSearchChange(event: Event): void;
+    methods: {
+        label: string;
+        value: string;
+    }[];
+    getMethods(): any[];
+    getNodeValueColor(v: any): "#c56100" | "mediumblue" | "forestgreen" | "#005959" | "currentcolor";
+    setupPath(node: TreeNode): void;
+    trackByFn(index: number, node: TreeNode): string;
+    showValue: boolean;
+    optionsSearch: string;
+    getAllInputs(): any[];
+    getValueVariables(): string[];
+    saveNodeInEdit(): void;
+    closeEdit(): void;
+    reset(): void;
+    getFunctionInEdit(): {
+        function: "filter" | "find";
+        id: string;
+        expression: string;
+        inEdit?: boolean;
+    } | undefined;
+    get getValue(): any;
+    removeFunction(id: string): void;
+    update(node: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataTreeComponent, "app-data-tree", never, { "data": { "alias": "data"; "required": false; }; "value": { "alias": "value"; "required": false; }; "formInputs": { "alias": "formInputs"; "required": false; }; }, { "pathChanged": "pathChanged"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/elements/api-value-access-rules/functions/convertDataToTree.d.ts

@@ -0,0 +1,57 @@
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { MatTreeFlatDataSource, MatTreeFlattener } from '@angular/material/tree';
+import { TreeNode, FlatNode } from 'ngx-t-forms-types';
+export interface ObjectTreeNode {
+    name: string;
+    children?: ObjectTreeNode[];
+    path: string[];
+}
+export interface ObjectTreeFlatNode {
+    expandable: boolean;
+    name: string;
+    level: number;
+    path: string[];
+}
+export declare function convertToTree(obj: any, parentPath?: string[]): TreeNode[];
+export declare class TreeComponent {
+    activePath: TreeNode[];
+    pathInEdit: TreeNode | null;
+    get activeLevel(): number;
+    private _transformer;
+    setupPath(node: TreeNode): void;
+    updateStateFromPath(path: TreeNode[]): void;
+    selectNode(node: FlatNode): TreeNode[] | undefined;
+    saveNodeInEdit(): {
+        children: undefined;
+        value: undefined;
+        key: string;
+        name: string;
+        inEdit?: boolean;
+        path: string[];
+        keyIsArrayIndex?: boolean;
+        functions: {
+            function: "filter" | "find";
+            id: string;
+            expression: string;
+            inEdit?: boolean;
+        }[];
+    }[] | undefined;
+    resetNode(): void;
+    removeFunction(id: string): void;
+    closeEdit(): void;
+    nodeIsExpandable(node: TreeNode): boolean;
+    showNode(node: FlatNode): boolean;
+    hasANodeInEdit(): boolean;
+    nodeIsChecked(node: FlatNode): boolean;
+    treeControl: FlatTreeControl<FlatNode, FlatNode>;
+    treeFlattener: MatTreeFlattener<TreeNode, FlatNode, FlatNode>;
+    dataSource: MatTreeFlatDataSource<TreeNode, FlatNode, FlatNode>;
+    private dynamicObject;
+    constructor();
+    computeTreeData(dynamicObject: any): void;
+    assignDataSourceData(tree: TreeNode[]): void;
+    hasChild: (_: number, node: FlatNode) => boolean;
+    getValue(): any;
+    addNewFunction(): void;
+    functionChanged(value: string): void;
+}

package/lib/components/t-dynamic-data-edit/elements/api-value-access-rules/functions/extractNodeFromTree.d.ts

@@ -0,0 +1,3 @@
+import { TreeNode } from 'ngx-t-forms-types';
+declare const extractNode: (tree: readonly TreeNode[], path: readonly string[]) => TreeNode | null;
+export { extractNode };

package/lib/components/t-dynamic-data-edit/elements/calculated-field-rules/calculated-field-rules.component.d.ts

@@ -0,0 +1,92 @@
+import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { CalculatedFieldRules, TableConfigurationsInterface } from 'ngx-t-forms-types';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { NgControl } from '@angular/forms';
+import { MatSelectChange } from '@angular/material/select';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import { CalculationFunctions, calculationVariableInterface } from "ngx-t-forms-types";
+import * as i0 from "@angular/core";
+export declare class CalculatedFieldRulesComponent implements OnInit, MatFormFieldControl<CalculatedFieldRules | 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;
+    mapToData: FormColumnInputs | undefined;
+    _value: CalculatedFieldRules;
+    set value(value: CalculatedFieldRules);
+    get value(): CalculatedFieldRules;
+    formInputs: Array<FormColumnInputs>;
+    errors: IConfigElementError[] | undefined;
+    valueChange2dWithPath: EventEmitter<any>;
+    valueChanged: EventEmitter<any>;
+    get allCalculationFunction(): CalculationFunctions[];
+    ngOnInit(): void;
+    applyColTo(): any;
+    get numberInputs(): FormColumnInputs[];
+    get tableMode(): Boolean;
+    get tableConfig(): TableConfigurationsInterface | undefined;
+    inputIsInItemList(v: FormColumnInputs): any;
+    selectedVariableIsTable(): boolean;
+    selectedInputVariable(): any;
+    checkIfInputCanBeLinkedToCalVariable(currentInput: FormColumnInputs | undefined, inputToDisable: {
+        [x: string]: any;
+        formControlName: any;
+    }): boolean | undefined;
+    valueChangedPost(event: any): void;
+    activeVariable: any;
+    addVariable(): void;
+    linkFormulaSource(event: MatSelectChange): void;
+    showVariableConfig: boolean;
+    bindInput(inputId: string): void;
+    formulaChanged(event: any): void;
+    bindTableCol(event: {
+        stopPropagation: () => void;
+    }, col: string): void;
+    tableFunctionToCol(event: {
+        stopPropagation: () => void;
+    }, col: string | number | any): void;
+    filterValuesByThisCol(event: {
+        stopPropagation: () => void;
+    }, col: string): void;
+    unlick(event: {
+        stopPropagation: () => void;
+    }): void;
+    unlinkTableFunctionToCol(event: {
+        stopPropagation: () => void;
+    }): void;
+    unlinkTableFilter(event: {
+        stopPropagation: () => void;
+    }): void;
+    functions: {
+        value: string;
+        label: string;
+    }[];
+    attachFunction(event: {
+        stopPropagation: () => void;
+    }, value: any): void;
+    saveNewVariable(event: any): void;
+    remove(variable: calculationVariableInterface): void;
+    cancelVariableConfig(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculatedFieldRulesComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalculatedFieldRulesComponent, "app-calculated-field-rules", never, { "mapToData": { "alias": "mapToData"; "required": false; }; "value": { "alias": "value"; "required": false; }; "formInputs": { "alias": "formInputs"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; }, { "valueChange2dWithPath": "valueChange2dWithPath"; "valueChanged": "valueChanged"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,73 @@
+import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { MatDialog } from '@angular/material/dialog';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { IGetTreeResponse } from 'ngx-t-forms-types';
+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 ConfiguredMscoaInput extends FormColumnInputs {
+    segment: string;
+}
+export declare class ConfigMscoaAdditionalInputsComponent implements OnInit, MatFormFieldControl<ConfiguredMscoaInput[]> {
+    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;
+    mscoaInitiated: boolean;
+    errors: IConfigElementError[] | undefined;
+    set getMscoaTree(options$: Observable<IGetTreeResponse> | undefined);
+    mapToData: FormColumnInputs | undefined;
+    set value(val: ConfiguredMscoaInput[]);
+    get value(): ConfiguredMscoaInput[];
+    _inputInEdit: BehaviorSubject<ConfiguredMscoaInput | null>;
+    inputInEdit: ConfiguredMscoaInput | undefined;
+    valueChanged: EventEmitter<ConfiguredMscoaInput[]>;
+    private _value;
+    editingIndex: number | null;
+    isAddingNew: boolean;
+    accountTreeKeys: string[];
+    ngOnInit(): void;
+    hovered: null | number;
+    startAddNew(): void;
+    startEdit(index: number): void;
+    removeInput(index: number): void;
+    cancelEdit(): void;
+    saveSegment(): void;
+    hoveredIndex: number | null;
+    removeSegment(index: number): void;
+    parentId: string | undefined;
+    openElementEditor(): Promise<void>;
+    inputSegmentChanged($event: any, i: number): void;
+    readonly dialog: MatDialog;
+    openFormDialog(): void;
+    get limitInputTo(): ({
+        value: string;
+        label: string;
+    } | {
+        value: undefined;
+        label: string;
+    })[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigMscoaAdditionalInputsComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigMscoaAdditionalInputsComponent, "app-config-mscoa-additional-inputs", never, { "errors": { "alias": "errors"; "required": false; }; "getMscoaTree": { "alias": "getMscoaTree"; "required": false; }; "mapToData": { "alias": "mapToData"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+export {};