ngx-t-forms 2.0.27 → 2.0.29

package/types/ngx-t-forms.d.ts

@@ -0,0 +1,962 @@
+import * as i0 from '@angular/core';
+import { EnvironmentProviders, OnDestroy, InjectionToken, OnInit, EventEmitter, ElementRef, NgZone, SimpleChanges, PipeTransform } from '@angular/core';
+import * as ngx_t_forms_types from 'ngx-t-forms-types';
+import { OLD_FormInterface, FormInterface, NgxTFormsConfig, FormColumnInputs, IFormChangeHistory, FormSubmissionStatus, ElementEditorInnerSectionElementInterface, InClassFormUtilsInterface, ValidationError, FormInputKeys, SpecialElementKeys, AllFormInputPrimaryKeys, ElementEditorTypes, FormInputBasicOptionInterface, TreeNode, IFormActions, IWorkflowDocumentPicker, IBasicFormInput, IFileUploadInput, IDateRangePickerInput, ITextareaProperties, IToggleInput, IMatrixInput, IMultiple, FormSlideInterface, IGetTreeResponse, DialogConfig, IFormsInitStateInterface, IStoreFunctions, FormsStoreSelectorsInterface, FormListSection, LocalFormStateSelectorInterface, ConfigurationValidTestInterface, IWorkflowOption, BlurHandleTypes, FlatNode, ITowerStepColumn, FormBuilderFunctions, ElementTypes, DocumentLitsLabelConfigInterfaceValueType, InputDataTypes, InputPipeTypes, FileUploadInputValueInterface, IArrayFunction } from 'ngx-t-forms-types';
+import { FormGroup, AbstractControl, FormControl } from '@angular/forms';
+import { IStepOption } from 'ngx-ui-tour-md-menu';
+import * as rxjs from 'rxjs';
+import { Observable, Subject, Subscription, BehaviorSubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { StepperSelectionEvent, StepState } from '@angular/cdk/stepper';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as _angular_cdk_drag_drop from '@angular/cdk/drag-drop';
+import * as _angular_router from '@angular/router';
+import { ActivatedRoute, Router } from '@angular/router';
+import { ComponentStore } from '@ngrx/component-store';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { MatTreeFlattener, MatTreeFlatDataSource } from '@angular/material/tree';
+import { MatStepper } from '@angular/material/stepper';
+import * as ngx_ui_tour_core from 'ngx-ui-tour-core';
+
+declare class NgxTFormsService {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTFormsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxTFormsService>;
+}
+
+declare class NgxTFormsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTFormsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxTFormsComponent, "lib-ngx-t-forms", never, {}, {}, never, never, true, never>;
+}
+
+declare const initFormConfigToV2: (formConfig: OLD_FormInterface) => FormInterface;
+
+declare function provideNgxTForms(config: NgxTFormsConfig): EnvironmentProviders;
+
+/**
+ * Generates a hierarchical form with nested FormGroups based on section IDs.
+ * Parent form listens to all descendant changes, with validation cascading upward.
+ *
+ * @param inputs Array of form inputs with their configurations
+ * @param getFormValue Record of form values used for custom validation
+ * @returns A FormGroup with nested FormGroups for each section
+ */
+declare function formGenerator(inputs: Array<FormColumnInputs>, getFormValue: () => Record<string, any>): FormGroup;
+
+interface IFormTour extends IStepOption {
+    sectionId: string;
+}
+
+declare enum FunctionTypes {
+    ValueCalculation = "ValueCalculation",
+    ValuePostMethodAPI = "ValuePostMethodAPI",
+    ValuePostMethodAPIWithAllDefaultParams = "ValuePostMethodAPIWithAllDefaultParams",
+    OptionsPostMethodAPI = "OptionsPostMethodAPI",
+    OptionsPostMethodAPIWithAllDefaultParams = "OptionsPostMethodAPIWithAllDefaultParams",
+    ValueGetMethodAPI = "ValueGetMethodAPI",
+    OptionsGetMethodAPI = "OptionsGetMethodAPI",
+    InputSourcedValue = "InputSourcedValue",
+    ManualValueValidation = "ManualValueValidation"
+}
+
+declare enum HintType {
+    WARNING = "warning",
+    ERROR = "error",
+    SUCCESS = "success",
+    LOADING = "loading",
+    INFO = "info",
+    QUESTION = "question",
+    CRITICAL = "critical",
+    PENDING = "pending",
+    BLOCKED = "blocked",
+    COMPLETED = "completed",
+    CANCELLED = "cancelled",
+    DEFAULT = "default",
+    QUERY_SUCCESS = "query_success",
+    DB_LOAD = "db_load",
+    CALCULATED = "calculated",
+    TAG = "tag",
+    DOCUMENT = "document",
+    HISTORY = "history"
+}
+declare function textIconsForUserHints(hint: string, type: HintType): string;
+
+interface DependentInput {
+    inputId: string;
+    functionType: FunctionTypes;
+}
+declare abstract class FormTowerControllerService implements OnDestroy {
+    private _http;
+    readonly NGX_T_FORMS_CONFIG: ngx_t_forms_types.NgxTFormsConfig;
+    readonly getFinacialCycles: () => Observable<ngx_t_forms_types.IFinancialCycles>;
+    constructor(_http: HttpClient);
+    protected _destroyed$: Subject<void>;
+    protected _form: FormInterface | undefined;
+    protected _mainForm: FormGroup | undefined;
+    protected _formValue: Record<string, any>;
+    protected _initialFormValue: Record<string, any>;
+    protected _systemInputs: FormColumnInputs[];
+    protected _inputFunctionsCollection: Record<string, Partial<Record<FunctionTypes, Observable<void>>>>;
+    protected _inputChangeDependencyRecords: Partial<Record<string, Partial<Record<FunctionTypes, Record<string, boolean>>>>>;
+    protected _reverseDependencyMap: Record<string, DependentInput[]>;
+    protected _changeHistory: IFormChangeHistory[];
+    submittingStatus: FormSubmissionStatus | undefined;
+    submittingForm: boolean;
+    get form(): FormInterface | undefined;
+    set form(value: FormInterface | undefined);
+    set systemInputs(value: FormColumnInputs[]);
+    get systemInputs(): FormColumnInputs[];
+    get mainForm(): FormGroup | undefined;
+    get changeHistory(): IFormChangeHistory[];
+    set changeHistory(value: IFormChangeHistory[]);
+    get inputFunctionsCollection(): Record<string, Partial<Record<FunctionTypes, Observable<void>>>>;
+    ngOnDestroy(): void;
+    initialize: (form: FormInterface) => Promise<void>;
+    setFirstStepAsActive: () => void;
+    getFormValueNames: () => Record<string, any>;
+    readonly allFormInputs: () => FormColumnInputs[];
+    prevValue: any;
+    protected changeMonitor: (newFormValue: any) => Observable<any>;
+    createInputFunctionsCollection: () => void;
+    private buildReverseDependencyMap;
+    createAllInputDependencies: () => void;
+    setInputStatus: (inputId: string, statusId: string, status: string) => void;
+    removeInputStatus: (inputId: string, statusId: string) => void;
+    updateValue: (inputId: string, value: any) => void;
+    getFunctionByType(fn: FunctionTypes, input: FormColumnInputs): Observable<void>;
+    getFormValue: () => Record<string, any>;
+    clearFormState: () => void;
+    executeInputFunctionsWithoutDependencies: () => void;
+    _hintTimeoutIds: Record<string, any>;
+    setTemporaryHint: (inputId: string, hint: string, type: HintType) => void;
+    _onFormInputConfigChange?: (inputId: string, config: FormColumnInputs) => void;
+    registerFormInputConfigChangeFn: (fn: (inputId: string, config: FormColumnInputs) => void) => (inputId: string, config: FormColumnInputs) => void;
+    httpPostDataFunction: (url: string, data: any, options: any) => Observable<any>;
+    httpGetDataFunction: (url: string, options: any) => Observable<any>;
+    _errorTimeoutIds: Record<string, any>;
+    setInputTemporaryError: (inputId: string, message: string) => void;
+    setInputError: (err: Record<string, any>, inputId: string) => void;
+    updateFormInputConfig: (inputId: string, config: FormColumnInputs) => void;
+    handleStepChange: (event: StepperSelectionEvent) => void;
+    selectFormSteps: () => ngx_t_forms_types.ITowerFormSteps[];
+    selectAllFormTours: () => IFormTour[];
+    setSectionAsSeen: (sectionId: string) => void;
+    setSectionAsActive: (sectionId: string) => void;
+    setInputAsTouchedAndDirty: (inputId: string) => void;
+    formProgress: () => number;
+    formSubmissionMessage: () => string;
+    setSubmissionStatusValue: (status: FormSubmissionStatus) => FormSubmissionStatus;
+    initializeFormValues: (initialValues: Record<string, any>) => void;
+    reset(): void;
+    revertBackHistory: () => void;
+    /**
+     * Form Submissions
+     */
+    submitForm: (passData: Record<string, any>) => void;
+    /**
+     * Toggles a multiple input element and its associated form controls.
+     * When toggled on, adds controls to the form. When toggled off, removes them.
+     *
+     * @param inputId The ID of the multiple input to toggle
+     * @returns boolean indicating success or failure
+     */
+    toggleMultipleInput: (inputId: string, open: boolean, rowInEditId?: string) => boolean;
+    saveMultipleInputForm: (inputId: string) => boolean;
+    multipleInputEditRow: (inputId: string, rowId: string) => boolean;
+    multipleInputDuplicateRow: (inputId: string, rowId: string) => boolean;
+    refreshSection: (sectionId: string) => Observable<void>;
+    refreshActiveSection: () => void;
+    refreshInput: (inputId: string) => Observable<undefined>;
+    canRefreshFn: (inputId: string) => boolean;
+    canRefreshSection: (sectionId: string) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormTowerControllerService, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormTowerControllerService, never, never, {}, {}, never, never, true, never>;
+}
+
+declare function getSectionElements(elements: ElementEditorInnerSectionElementInterface[], inputInEdit: (FormColumnInputs) | undefined, NGX_T_FORMS_CONFIG: NgxTFormsConfig, utils: InClassFormUtilsInterface, errors?: ValidationError[]): (never[] | {
+    computedErrors: ValidationError[];
+    required: boolean;
+    postmanCollectionConfig: {
+        collectionUrl: string;
+        collectionKey: string;
+    } | undefined;
+    httpGetDataFunction: (url: string, options: any) => rxjs.Observable<any>;
+    getWorkflowOptions: rxjs.Observable<ngx_t_forms_types.IWorkflowOption[]>;
+    getMscoaTree: rxjs.Observable<ngx_t_forms_types.IGetTreeResponse> | undefined;
+    id: string;
+    name: FormInputKeys | SpecialElementKeys | AllFormInputPrimaryKeys;
+    hint?: string;
+    editType: ElementEditorTypes;
+    deepBind: Array<string>;
+    defaultValue?: any;
+    limitTo?: number;
+    additionalTest?: ngx_t_forms_types.ConfigurationValidTestInterface[];
+    disabled?: ngx_t_forms_types.ConfigurationValidTestInterface[];
+    fetchOptions?: string[];
+    secondaryElementEditorConfig?: Array<ngx_t_forms_types.ElementEditorConfigSectionInterface>;
+    clearOnChange?: string[][];
+    blurHandle?: ngx_t_forms_types.BlurHandleTypes;
+    label: string;
+    readonly?: boolean;
+    templateOptions?: Array<any>;
+    placeholder?: string;
+    options?: Array<{
+        label: string;
+        value: any;
+    }>;
+    min?: number;
+    max?: number;
+    step?: number;
+    format?: (value: any) => number;
+})[];
+
+declare const returnMappedPathValue: (pathMap: TreeNode[], obj: any) => any;
+declare const getValueFromValueAccessor: (valueAccessRules: FormInputBasicOptionInterface | TreeNode[] | Record<string, TreeNode[]>, data: any) => any;
+
+declare const FORM_ACTIONS_TOKEN: InjectionToken<IFormActions>;
+declare const FORM_CONFIG_TOKEN: InjectionToken<FormInterface>;
+declare const FORM_SLIDES_TOKEN: InjectionToken<FormSlideInterface>;
+declare const UTILS_OBJECT_TOKEN: InjectionToken<InClassFormUtilsInterface>;
+declare const FORM_INPUTS_TOKEN: InjectionToken<IWorkflowDocumentPicker & IBasicFormInput & IFileUploadInput & IDateRangePickerInput & ITextareaProperties & IToggleInput & IMatrixInput & IMultiple>;
+declare const MULTIPLE_FORM_INPUT_TOKEN: InjectionToken<IMultiple>;
+declare const MSCOA_TREE_PROVIDER: InjectionToken<() => Observable<IGetTreeResponse>>;
+declare const NGX_T_FORMS_CONFIG_TOKEN: InjectionToken<NgxTFormsConfig>;
+
+declare class DialogTemplateComponent {
+    readonly dialogRef: MatDialogRef<any, any>;
+    readonly data: DialogConfig;
+    proceed(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogTemplateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogTemplateComponent, "lib-dialog-template", never, {}, {}, never, never, true, never>;
+}
+
+declare class FormBuilderComponent implements OnDestroy, OnInit {
+    subscription$: Subscription;
+    private store;
+    private route;
+    selectLoadingForm: i0.Signal<boolean>;
+    selectFormBuilderIsBusy: i0.Signal<boolean>;
+    selectFormUpdated: i0.Signal<string | Date | null>;
+    canSaveForm: i0.Signal<boolean>;
+    isNewForm: i0.Signal<boolean>;
+    set formId(value: string);
+    selectHasFormId: i0.Signal<boolean>;
+    hasMissingConfigs: i0.Signal<boolean>;
+    elementEditorOpen: i0.Signal<boolean | null>;
+    constructor();
+    readonly NGX_T_FORMS_CONFIG: ngx_t_forms_types.NgxTFormsConfig;
+    readonly closeButton: ngx_t_forms_types.ActionButton;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    saveForm: () => void;
+    _title: string;
+    set titleValue(value: string);
+    initiatedTitle: boolean;
+    get titleValue(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormBuilderComponent, "app-form-builder", never, { "formId": { "alias": "formId"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+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: FormsStoreSelectorsInterface;
+    readonly formBuilderSelectors: {
+        selectFormSlides$: Observable<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<ngx_t_forms_types.FormColumnInputs | undefined>;
+        defaultInputInEdit$: Observable<any>;
+        inputInEditValidationErrors$: Observable<ngx_t_forms_types.ValidationError[]>;
+        selectFormTitle$: Observable<string | undefined>;
+        getAllFormInputs$: Observable<never[] | ngx_t_forms_types.FormColumnInputs[]>;
+        inputElementEditorConfigs$: Observable<{
+            editorSections: {
+                elements: {
+                    editType: ngx_t_forms_types.ElementEditorTypes;
+                    id: string;
+                    name: ngx_t_forms_types.FormInputKeys | ngx_t_forms_types.SpecialElementKeys | ngx_t_forms_types.AllFormInputPrimaryKeys;
+                    hint?: string;
+                    deepBind: Array<string>;
+                    defaultValue?: any;
+                    limitTo?: number;
+                    additionalTest?: ngx_t_forms_types.ConfigurationValidTestInterface[];
+                    disabled?: ngx_t_forms_types.ConfigurationValidTestInterface[];
+                    fetchOptions?: string[];
+                    secondaryElementEditorConfig?: Array<ngx_t_forms_types.ElementEditorConfigSectionInterface>;
+                    clearOnChange?: string[][];
+                    blurHandle?: ngx_t_forms_types.BlurHandleTypes;
+                    label: string;
+                    required?: boolean;
+                    readonly?: boolean;
+                    templateOptions?: Array<any>;
+                    placeholder?: string;
+                    options?: Array<{
+                        label: string;
+                        value: any;
+                    }>;
+                    computedErrors?: ngx_t_forms_types.ValidationError[];
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                    format?: (value: any) => number;
+                    postmanCollectionConfig?: ngx_t_forms_types.IPostmanCollectionConfig;
+                    httpGetDataFunction?: (url: string, options: any) => Observable<any>;
+                    getWorkflowOptions?: Observable<ngx_t_forms_types.IWorkflowOption[]> | undefined;
+                    getMscoaTree?: Observable<ngx_t_forms_types.IGetTreeResponse> | undefined;
+                }[];
+                hasErrors: boolean;
+                label: string;
+                showItemValue?: keyof ngx_t_forms_types.FormColumnInputs;
+                id: string;
+                additionalTest?: ngx_t_forms_types.ConfigurationValidTestInterface[];
+            }[];
+            title?: string;
+            description?: string;
+        }>;
+        selectFormSlideSections$: Observable<{
+            inputConfigErrors: {
+                key: string;
+                message: string;
+            }[];
+            sectionId: string;
+            label: string;
+            columns: Array<ngx_t_forms_types.FormColumnInputs>;
+            inEdit?: boolean;
+            sectionIsSeen?: boolean;
+            isActive?: boolean;
+        }[]>;
+    };
+    readonly actions: {
+        loadFormListSuccess: (observableOrValue: {
+            forms: ngx_t_forms_types.DatabaseFormInterface[];
+        } | Observable<{
+            forms: ngx_t_forms_types.DatabaseFormInterface[];
+        }>) => rxjs.Subscription;
+        toggleFormBuilderBusy: () => void;
+        toggleLoadingForm: () => void;
+        toggleLoadingForms: (observableOrValue: {
+            loadingForms: boolean;
+        } | Observable<{
+            loadingForms: boolean;
+        }>) => rxjs.Subscription;
+        loadFormSuccess: (observableOrValue: {
+            form: ngx_t_forms_types.DatabaseFormInterface;
+        } | Observable<{
+            form: ngx_t_forms_types.DatabaseFormInterface;
+        }>) => rxjs.Subscription;
+        toggleFormBusy: (observableOrValue: {
+            formId: string;
+        } | Observable<{
+            formId: string;
+        }>) => rxjs.Subscription;
+        archivedSuccess: (observableOrValue: {
+            formId: string;
+        } | Observable<{
+            formId: string;
+        }>) => rxjs.Subscription;
+        setFormId: (observableOrValue: {
+            formId: string;
+        } | Observable<{
+            formId: string;
+        }>) => rxjs.Subscription;
+        setError: (observableOrValue: {
+            error: string | undefined;
+            type: ngx_t_forms_types.FormStateErrors;
+        } | Observable<{
+            error: string | undefined;
+            type: ngx_t_forms_types.FormStateErrors;
+        }>) => rxjs.Subscription;
+        handleListSectionChange: (observableOrValue: {
+            listSection: FormListSection;
+        } | Observable<{
+            listSection: FormListSection;
+        }>) => rxjs.Subscription;
+        handleRouterStateChange: (observableOrValue: {
+            routerState: _angular_router.ActivatedRouteSnapshot | null;
+        } | Observable<{
+            routerState: _angular_router.ActivatedRouteSnapshot | null;
+        }>) => rxjs.Subscription;
+        handleSetSubmittingForm: (observableOrValue: {
+            submittingForm: boolean;
+        } | Observable<{
+            submittingForm: boolean;
+        }>) => rxjs.Subscription;
+        setFormInitialValues: (observableOrValue: {
+            initialFormValues: Record<string, any>;
+        } | Observable<{
+            initialFormValues: Record<string, any>;
+        }>) => rxjs.Subscription;
+        handleEditorUpdateFormInEdit: (observableOrValue: {
+            form: FormInterface;
+        } | Observable<{
+            form: FormInterface;
+        }>) => rxjs.Subscription;
+        updateFormInputConfigFromTower: (observableOrValue: {
+            inputId: string;
+            config: ngx_t_forms_types.FormColumnInputs;
+        } | Observable<{
+            inputId: string;
+            config: ngx_t_forms_types.FormColumnInputs;
+        }>) => rxjs.Subscription;
+        setInputInEditId: (observableOrValue: {
+            inputInEdit: string | null;
+        } | Observable<{
+            inputInEdit: string | null;
+        }>) => rxjs.Subscription;
+    };
+    readonly actionsFormBuilder: {
+        handelSaveForm: () => void;
+        setFormTitle: (title: string) => void;
+        handleSectionDragDrop: (event: _angular_cdk_drag_drop.CdkDragDrop<any, any, any>) => void;
+        handleInputDragDrop: (event: _angular_cdk_drag_drop.CdkDragDrop<any, any, any>, sectionId: string) => void;
+        handleAddSection: () => void;
+        stepTitleChangeStep: (sectionId: string, title: string) => void;
+        formDeleteInput: (item: ngx_t_forms_types.FormColumnInputs) => void;
+        multipleInputToggleLabel: (item: ngx_t_forms_types.FormColumnInputs) => void;
+        editInput: (item: ngx_t_forms_types.FormColumnInputs) => void;
+        addMultipleInputValueCalculationFunction: (item: ngx_t_forms_types.IMultipleInputCal, multipleInputId: string | undefined) => void;
+        formDeleteSection: (sectionId: string) => void;
+        formDeleteSectionInputs: (sectionId: string) => void;
+        moveInputToSection: (inputId: string, targetSectionId: string) => void;
+        reorderMultipleInputItems: (event: _angular_cdk_drag_drop.CdkDragDrop<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: ngx_t_forms_types.ElementTypes) => void;
+        formInputChange: (ele: ngx_t_forms_types.ElementEditorInnerSectionElementInterface, value: any) => void;
+        saveSubmitApi: (dataPlaceholder: undefined | {
+            data: ngx_t_forms_types.APIDataFetchingConfigurationInterface;
+        }, keyInEdit: "submissionAPI" | "canSubmitAPI" | undefined) => void;
+        removeSubmissionApi: (api: ngx_t_forms_types.APIDataFetchingConfigurationInterface, keyInEdit: "submissionAPI" | "canSubmitAPI" | undefined) => void;
+        elementConfigurationChanged: (inputId: string, value: any, ele: ngx_t_forms_types.ElementEditorInnerSectionElementInterface) => void;
+        elementBlur: (inputId: string, event: any, element: ngx_t_forms_types.ElementEditorInnerSectionElementInterface) => void;
+        addMultipleFormInput: (sectionId: string, multipleInputInEditId: string) => void;
+        clearInputInEdit: (inputId: string) => void;
+        addInputToScoaSelection: (sectionId: string, scoaInputId: string) => void;
+    };
+    readonly effects: {
+        createForm$: (observableOrValue: FormInterface | Observable<FormInterface>) => rxjs.Subscription;
+        loadForms$: (observableOrValue?: void | Observable<void> | undefined) => rxjs.Subscription;
+        loadForm$: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+        updateForm$: (observableOrValue: {
+            form: FormInterface;
+            versionNumber: number;
+        } | Observable<{
+            form: FormInterface;
+            versionNumber: number;
+        }>) => rxjs.Subscription;
+        archiveForm$: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+        setListSection$: (observableOrValue: FormListSection | Observable<FormListSection>) => rxjs.Subscription;
+        unArchiveForm$: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+        deleteForm$: (observableOrValue: string | Observable<string>) => 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>;
+}
+
+declare class FormsComponent implements OnInit, OnDestroy {
+    private route;
+    private store;
+    private document;
+    subscription$: Subscription;
+    selectFormsList$: Observable<LocalFormStateSelectorInterface[]>;
+    selectGroupedForms$: Observable<Record<string, any[]>>;
+    private searchQuerySubject;
+    searchQuery$: Observable<string>;
+    selectHasActiveSearch$: Observable<boolean>;
+    selectFilteredGroupedForms$: Observable<Record<string, any[]>>;
+    selectLoadingForms$: Observable<boolean>;
+    selectErrors$: Observable<any>;
+    selectFormListSection$: Observable<FormListSection>;
+    NGX_T_FORMS_CONFIG: ngx_t_forms_types.NgxTFormsConfig;
+    closeButton: ngx_t_forms_types.ActionButton;
+    constructor(route: ActivatedRoute, store: FormsStoreService, document: Document);
+    ngOnDestroy(): void;
+    get formListSections(): {
+        value: FormListSection;
+        label: string;
+    }[];
+    viewportWidth: number;
+    ngOnInit(): void;
+    labels: {
+        label: string;
+        formControlName: string;
+    }[];
+    activeForm: string | null;
+    getCols(): 1 | 4 | 2 | 3;
+    getFormAvatar(formTitle: string): string;
+    archive(form: LocalFormStateSelectorInterface, event: Event): Promise<void>;
+    unarchive(form: LocalFormStateSelectorInterface, event: Event): Promise<void>;
+    delete(form: LocalFormStateSelectorInterface, event: Event): Promise<void>;
+    loadForms(): void;
+    router: Router;
+    activatedRoute: ActivatedRoute;
+    setSection(value: FormListSection): void;
+    editForm(form: LocalFormStateSelectorInterface): void;
+    addNewForm(): void;
+    clearSearch(): void;
+    get searchQuery(): string;
+    set searchQuery(v: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormsComponent, "app-forms", never, {}, {}, never, never, true, never>;
+}
+
+declare class ValidationExpressioCreatorComponent implements OnDestroy, OnInit {
+    hint: string;
+    label: string;
+    formInputs: FormColumnInputs[];
+    _data: any;
+    set data(value: any);
+    get data(): any;
+    set expression(value: string);
+    _valueAccessRules: Record<string, TreeNode[]>;
+    set valueAccessRules(value: Record<string, TreeNode[]>);
+    get valueAccessRules(): Record<string, TreeNode[]>;
+    subscription$: Subscription;
+    ngOnDestroy(): void;
+    expressionChange: EventEmitter<{
+        expression: string | null;
+        valueAccessRules: Record<string, TreeNode[]>;
+    }>;
+    ngOnInit(): void;
+    textareaElementRef: ElementRef;
+    expressionControl: FormControl<string | null>;
+    cursorPosition: number;
+    showSuggestions: boolean;
+    optionsSearch: string;
+    onTextChange(expression: string): Promise<void>;
+    cleanValueAccessRules(): void;
+    selectSuggestionInput(suggestion: string): void;
+    get getAllInputs(): FormColumnInputs[];
+    onFocus(event: FocusEvent): void;
+    methods: {
+        label: string;
+        hint: string;
+        value: string;
+    }[];
+    getMethods(): {
+        label: string;
+        hint: string;
+        value: string;
+    }[];
+    variableInEdit: string | null;
+    get errorMessage(): string | null;
+    get valueAccessOptions(): string[];
+    activeVariableChanged(value: TreeNode[] | string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationExpressioCreatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ValidationExpressioCreatorComponent, "lib-validation-expressio-creator", never, { "hint": { "alias": "hint"; "required": false; }; "label": { "alias": "label"; "required": false; }; "formInputs": { "alias": "formInputs"; "required": false; }; "data": { "alias": "data"; "required": false; }; "expression": { "alias": "expression"; "required": false; }; "valueAccessRules": { "alias": "valueAccessRules"; "required": false; }; }, { "expressionChange": "expressionChange"; }, never, never, true, never>;
+}
+
+declare function testAgainstItem(test: ConfigurationValidTestInterface, item: any): boolean;
+
+interface IConfigElementError {
+    key: string;
+    message: string;
+}
+declare class TDynamicDataEditComponent implements OnDestroy {
+    private ngZone;
+    private editorInitiated;
+    constructor(ngZone: NgZone);
+    ngOnDestroy(): void;
+    private valueChanges;
+    private subscription;
+    elementEditorTypes: typeof ElementEditorTypes;
+    private _editorConfig;
+    private _data;
+    set editorConfig(config: ElementEditorInnerSectionElementInterface | undefined);
+    _formInputs$: BehaviorSubject<FormColumnInputs[]>;
+    _formInputs: FormColumnInputs[];
+    set formInputs(inputs: Array<FormColumnInputs>);
+    get formInputs(): Array<FormColumnInputs>;
+    set data(data: any);
+    get data(): any;
+    validationErrors: IConfigElementError[] | null;
+    valueChange: EventEmitter<unknown>;
+    blur: EventEmitter<any>;
+    editorConfigValue$: Observable<ElementEditorInnerSectionElementInterface | undefined>;
+    dataValue$: Observable<any>;
+    get getMscoaTree$(): Observable<IGetTreeResponse | undefined>;
+    get getWorkflowOptions$(): Observable<IWorkflowOption[] | undefined>;
+    get value$(): Observable<any>;
+    get dataOptions$(): Observable<any>;
+    get disabled$(): Observable<boolean | undefined>;
+    private initializeValueChanges;
+    private computeValueChange;
+    inputChange(event: any): void;
+    valueChanged(value: unknown): void;
+    manualValueChange(event: {
+        value: unknown;
+        deepBind: Array<string>;
+    }): void;
+    blurOff: boolean;
+    elementBlur(event: any): void;
+    get inputHasBlurFunction$(): Observable<BlurHandleTypes | undefined>;
+    blurFunctionTooltip(blurHandle: BlurHandleTypes | undefined): "Enable/disable pre-populating of the form control name from the label" | "Enable/disable auto conversion of control name to camel case" | "Toggle blur function";
+    formatLabel: (value: number) => any;
+    vm$: Observable<{
+        editorConfigValue: ElementEditorInnerSectionElementInterface | undefined;
+        value: any;
+        dataOptions: any;
+        disabled: boolean | undefined;
+        inputHasBlurFunction: BlurHandleTypes | undefined;
+        dataValue: any;
+        inputConfig: any;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TDynamicDataEditComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TDynamicDataEditComponent, "lib-t-dynamic-data-edit", never, { "editorConfig": { "alias": "editorConfig"; "required": false; }; "formInputs": { "alias": "formInputs"; "required": false; }; "data": { "alias": "data"; "required": false; }; "validationErrors": { "alias": "validationErrors"; "required": false; }; }, { "valueChange": "valueChange"; "blur": "blur"; }, never, never, true, never>;
+}
+
+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: ngx_t_forms_types.IArrayFunction[];
+    }[] | 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;
+}
+
+declare class TDynamicDataViewComponent {
+    treeClass: TreeComponent;
+    data: any;
+    constructor();
+    _data: any;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getNodeValueColor(value: any): "green" | "blue" | "purple" | "black";
+    static ɵfac: i0.ɵɵFactoryDeclaration<TDynamicDataViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TDynamicDataViewComponent, "lib-t-dynamic-data-view", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MscoaFormInputComponent {
+    inputConfig: ITowerStepColumn;
+    editorMode: boolean;
+    formGroup: FormGroup;
+    formBuilderFunctions: FormBuilderFunctions | undefined;
+    reload: EventEmitter<void>;
+    get errorMessage(): string | string[] | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MscoaFormInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MscoaFormInputComponent, "lib-mscoa-form-input", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "editorMode": { "alias": "editorMode"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "formBuilderFunctions": { "alias": "formBuilderFunctions"; "required": false; }; }, { "reload": "reload"; }, never, never, true, never>;
+}
+
+interface EncryptedData {
+    ciphertext: string;
+    salt: string;
+    iv: string;
+    hmac: string;
+}
+
+declare const getSignatureImage: (inputConfig: FormColumnInputs, value: EncryptedData | undefined) => Promise<string | undefined>;
+
+declare class SignatureInputElementComponent {
+    inputConfig: ITowerStepColumn;
+    formGroup: FormGroup;
+    reload: EventEmitter<void>;
+    get errorMessage(): string | string[] | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignatureInputElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SignatureInputElementComponent, "lib-signature-input-element", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, { "reload": "reload"; }, never, never, true, never>;
+}
+
+declare class TFormInputComponent {
+    private props;
+    inputConfig: ITowerStepColumn | undefined;
+    formGroup: FormGroup<{
+        [sectionId: string]: FormGroup<{
+            [inputId: string]: FormControl<string | null>;
+        }>;
+    }> | undefined | null;
+    editorMode: boolean;
+    formBuilderFunctions: FormBuilderFunctions | undefined;
+    optionsSearchWordKeyWord: string;
+    elementTypes: typeof ElementTypes;
+    constructor(props: any);
+    get hasFormControlInstance(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TFormInputComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TFormInputComponent, "lib-t-form-input", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "editorMode": { "alias": "editorMode"; "required": false; }; "formBuilderFunctions": { "alias": "formBuilderFunctions"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TourManagerService {
+    private readonly tourService;
+    userProfile: this;
+    constructor();
+    startTourByOption(steps: IStepOption[]): {
+        stepShow$: rxjs.Subject<ngx_ui_tour_core.StepChangeParams<IStepOption>>;
+        stepHide$: rxjs.Subject<ngx_ui_tour_core.StepChangeParams<IStepOption>>;
+        initialize$: rxjs.Subject<IStepOption[]>;
+        start$: rxjs.Subject<void>;
+        end$: rxjs.Subject<void>;
+        pause$: rxjs.Subject<void>;
+        resume$: rxjs.Subject<void>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<TourManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TourManagerService>;
+}
+
+declare class UserFormStepperComponent extends FormTowerControllerService {
+    /**
+     * Handles the key down event and opens the application log if the key combination is pressed.
+     * @param event The keyboard event object.
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    _formId: string | undefined;
+    set formId(value: string | undefined);
+    loading: boolean;
+    loadForm(formId: string | undefined): void;
+    _initialFormValuesLocal: any;
+    set initialValues(initialFormValues: any);
+    set globalSystemInputs(inputs: FormColumnInputs[]);
+    passParamsOnSubmit: any;
+    get formBuilderFunctions(): FormBuilderFunctions;
+    stepper: MatStepper | undefined;
+    isEditable: boolean;
+    getStepState(step: any, index: number): StepState;
+    getPreviousStepLabel(): string | undefined;
+    getNextStepLabel(): string | undefined;
+    canProceedToNextStep(step: any): boolean;
+    get getSubmissionStatus(): string;
+    handleSubmit(): void;
+    tourManagerService: TourManagerService;
+    get hasTour(): boolean;
+    /**
+     * Initiates and configures a dynamic, multi-step tutorial tour for the form.
+     * The tour guides the user through the form's title, sections, and individual fields.
+     */
+    startTour(): void;
+    refreshASection(sectionId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserFormStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserFormStepperComponent, "lib-user-form-stepper", never, { "formId": { "alias": "formId"; "required": false; }; "initialValues": { "alias": "initialValues"; "required": false; }; "globalSystemInputs": { "alias": "globalSystemInputs"; "required": false; }; "passParamsOnSubmit": { "alias": "passParamsOnSubmit"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FormatDataPipe implements PipeTransform {
+    transform(value: any, dataType: DocumentLitsLabelConfigInterfaceValueType | InputDataTypes | undefined | InputPipeTypes, pipeConfig?: FormColumnInputs['pipe'] | undefined): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatDataPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatDataPipe, "formatData", true>;
+}
+
+declare function assignDeepPropertyToObject(item: any, path: Array<string>, value: any): any;
+
+/**
+ * Creates a file upload data object from a Base64 string.
+ *
+ * @param fileName The desired name for the file (e.g., 'my-image.png').
+ * @param contentType The MIME type of the file (e.g., 'image/png').
+ * @param base64Content The raw Base64 encoded content of the file.
+ * @returns A populated FileUploadInputValueInterface object.
+ */
+declare const createFileFromBase64: (fileName: string, contentType: string, base64Content: string) => FileUploadInputValueInterface;
+
+type DeepPropertyValue = any;
+type PropertyPath = (string | number | IArrayFunction[])[];
+/**
+ * Custom error class for property access errors in deep object traversal.
+ *
+ * @class PropertyAccessError
+ * @extends Error
+ *
+ * @property {PropertyPath} path - The path segment where the error occurred.
+ * @property {string | number | symbol} segment - The specific path segment that caused the error.
+ *
+ * @description
+ * This error is thrown when there's an issue accessing a property during deep object traversal.
+ * It provides detailed information about where in the path the error occurred and what caused it.
+ *
+ * @example
+ * try {
+ *   const result = returnDeepProperty(obj, ['a', 'b', 'c']);
+ * } catch (error) {
+ *   if (error instanceof PropertyAccessError) {
+ *     console.log(`Error at path: ${error.path.join('.')}`);
+ *     console.log(`Problem segment: ${String(error.segment)}`);
+ *     console.log(`Error message: ${error.message}`);
+ *   }
+ * }
+ */
+declare class PropertyAccessError extends Error {
+    path: PropertyPath;
+    segment: string | number | IArrayFunction[];
+    constructor(message: string, path: PropertyPath, segment: string | number | IArrayFunction[]);
+}
+/**
+ * Retrieves a deeply nested property from an object using a path array.
+ *
+ * @function returnDeepProperty
+ *
+ * @param {any} item - The object to traverse.
+ * @param {(string|number|symbol)[]} path - An array representing the path to the desired property.
+ *        Each element in the array can be a string (for object properties),
+ *        a number (for array indices), or a symbol.
+ *
+ * @returns {any} The value of the deep property if it exists, otherwise undefined.
+ *
+ * @throws {Error} If the input item is null or undefined, or if the path is not a non-empty array.
+ *
+ * @example
+ * const obj = {
+ *   a: {
+ *     b: [
+ *       { c: 1 },
+ *       { c: 2 }
+ *     ]
+ *   }
+ * };
+ *
+ * returnDeepProperty(obj, ['a', 'b', 1, 'c']); // Returns 2
+ * returnDeepProperty(obj, ['a', 'x']); // Returns undefined
+ *
+ * @description
+ * This function allows for safe traversal of nested objects and arrays.
+ * It can handle various types of keys including strings, numbers, and symbols.
+ * The function is optimized for performance and can handle very deep object structures.
+ *
+ * Key features:
+ * - Iterative approach for better performance with deep structures
+ * - Handles array indices (both as numbers and strings)
+ * - Supports symbol keys
+ * - Safely returns undefined for non-existent paths without throwing errors
+ * - Type-safe with TypeScript
+ *
+ * Performance considerations:
+ * - Efficient for very deep object structures (tested up to 1000 levels deep)
+ * - Faster than naive recursive approaches for deep traversal
+ *
+ * Error handling:
+ * - Returns undefined for non-existent paths or when trying to access properties of non-objects
+ * - Throws an error if the input item is null/undefined or if the path is invalid
+ *
+ * @see safeReturnDeepProperty for a version that never throws and returns an object with value and error properties
+ */
+declare const returnDeepProperty: (item: any, path: PropertyPath) => DeepPropertyValue;
+/**
+ * Safely retrieves a deeply nested property from an object using a path array.
+ *
+ * @function safeReturnDeepProperty
+ *
+ * @param {any} item - The object to traverse.
+ * @param {(string|number|symbol)[]} path - An array representing the path to the desired property.
+ *        Each element in the array can be a string (for object properties),
+ *        a number (for array indices), or a symbol.
+ *
+ * @returns {{value: any, error: string|null}} An object containing:
+ *          - value: The value of the deep property if found, otherwise undefined.
+ *          - error: A string describing the error if one occurred, otherwise null.
+ *
+ * @example
+ * const obj = {
+ *   a: {
+ *     b: [
+ *       { c: 1 },
+ *       { c: 2 }
+ *     ]
+ *   }
+ * };
+ *
+ * safeReturnDeepProperty(obj, ['a', 'b', 1, 'c']);
+ * // Returns { value: 2, error: null }
+ *
+ * safeReturnDeepProperty(obj, ['a', 'x']);
+ * // Returns { value: undefined, error: "Property 'x' does not exist" }
+ *
+ * safeReturnDeepProperty(null, ['a']);
+ * // Returns { value: undefined, error: "Item cannot be null or undefined" }
+ *
+ * @description
+ * This function is a wrapper around returnDeepProperty that never throws exceptions.
+ * Instead, it returns an object with both the retrieved value and any error message.
+ * This makes it suitable for use in situations where you want to handle all possible
+ * errors without try/catch blocks.
+ *
+ * Key features:
+ * - Never throws exceptions
+ * - Provides both the retrieved value and error information
+ * - Handles the same range of inputs as returnDeepProperty
+ *
+ * Use this function when you need to:
+ * - Safely traverse objects without worrying about exceptions
+ * - Get detailed error information along with the result
+ * - Implement error handling in a functional programming style
+ *
+ * @see returnDeepProperty for the core implementation that this function wraps
+ */
+declare const safeReturnDeepProperty: (item: any, path: PropertyPath) => {
+    value: DeepPropertyValue;
+    error: string | null;
+};
+
+/**
+ * Creates a sample value for a given form input configuration.
+ * It determines the value based on the input's element type, specific input type (e.g., email, number),
+ * or data type, with a fallback to a default value.
+ *
+ * @param {FormColumnInputs} input - The configuration object for the form input.
+ * @returns {any} A sample value appropriate for the input type.
+ */
+declare function getSampleValueForInput(input: FormColumnInputs): any;
+
+declare function getPipedValueFromDataType(dataType: InputDataTypes | undefined | DocumentLitsLabelConfigInterfaceValueType, value: any, pipe: FormColumnInputs['pipe'] | undefined): any;
+
+declare function getUrl(url: string, variables: NgxTFormsConfig): string;
+
+/**
+ * Validates an object against a validation expression.
+ *
+ * @param {string} expression - The validation expression to evaluate.
+ * @param {object} object - The object to validate.
+ * @returns {boolean} - A boolean indicating whether the object is valid according to the expression.
+ *
+ * This function is designed to handle a variety of cases for validating objects based on a given expression. It can:
+ * 1. Evaluate an expression part with a single comparison operator, for example: 'a === 1' or '(a === 1)'.
+ * 2. Evaluate an expression with multiple comparison operators, including: '===', '==', '!==', '!=', '>', '<', '>=', and '<='.
+ * 3. Group expression parts considering bracket enclosures and logical operators.
+ * 4. Evaluate an expression with multiple logical operators, such as 'a === 1 && b === 2 || c === 3'.
+ */
+declare const validateObjectAgainstString: (expression: string, object: any) => boolean;
+declare function validateExpressionSyntax(expression: string): string | null;
+
+export { DialogTemplateComponent, FORM_ACTIONS_TOKEN, FORM_CONFIG_TOKEN, FORM_INPUTS_TOKEN, FORM_SLIDES_TOKEN, FormBuilderComponent, FormTowerControllerService, FormatDataPipe, FormsComponent, MSCOA_TREE_PROVIDER, MULTIPLE_FORM_INPUT_TOKEN, MscoaFormInputComponent, NGX_T_FORMS_CONFIG_TOKEN, NgxTFormsComponent, NgxTFormsService, PropertyAccessError, SignatureInputElementComponent, TDynamicDataEditComponent, TDynamicDataViewComponent, TFormInputComponent, UTILS_OBJECT_TOKEN, UserFormStepperComponent, ValidationExpressioCreatorComponent, assignDeepPropertyToObject, createFileFromBase64, formGenerator, getPipedValueFromDataType, getSampleValueForInput, getSectionElements, getSignatureImage, getUrl, getValueFromValueAccessor, initFormConfigToV2, provideNgxTForms, returnDeepProperty, returnMappedPathValue, safeReturnDeepProperty, testAgainstItem, textIconsForUserHints, validateExpressionSyntax, validateObjectAgainstString };