ngx-t-forms 0.0.1

package/lib/components/t-form-input/t-form-input.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { ElementTypes } from "ngx-t-forms-types";
+import { FormBuilderFunctions } from 'ngx-t-forms-types';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class TFormInputComponent {
+    inputConfig: FormColumnInputs | undefined;
+    formGroup: FormGroup<{
+        [sectionId: string]: FormGroup<{
+            [inputId: string]: FormControl<string | null>;
+        }>;
+    }> | undefined | null;
+    editorMode: boolean;
+    formBuilderFunctions: FormBuilderFunctions | undefined;
+    valueChange: EventEmitter<any>;
+    optionsSearchWordKeyWord: string;
+    elementTypes: typeof ElementTypes;
+    constructor();
+    get hasFormControlInstance(): boolean;
+    changed(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TFormInputComponent, never>;
+    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; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-form-input-status/t-form-input-status.component.d.ts

@@ -0,0 +1,10 @@
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class TFormInputStatusComponent {
+    inputConfig: FormColumnInputs | undefined;
+    recentlyUpdated(): boolean;
+    get busy(): boolean;
+    get busyMessage(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TFormInputStatusComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TFormInputStatusComponent, "lib-t-form-input-status", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/user-form-stepper/user-form-stepper.component.d.ts

@@ -0,0 +1,23 @@
+import { StepState } from '@angular/cdk/stepper';
+import { FormTowerControllerService } from '../../services/core/t-form-tower-controller/form-tower-controller.service';
+import { MatStepper } from '@angular/material/stepper';
+import { FormBuilderFunctions } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class UserFormStepperComponent extends FormTowerControllerService {
+    set formId(value: string | undefined);
+    loading: boolean;
+    loadForm(formId: string | undefined): void;
+    set initialValues(initialFormValues: any);
+    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;
+    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; }; "passParamsOnSubmit": { "alias": "passParamsOnSubmit"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/injection-tokens/index.d.ts

@@ -0,0 +1,14 @@
+import { InjectionToken } from "@angular/core";
+import { FormInterface, InClassFormUtilsInterface, NgxTFormsConfig } from "ngx-t-forms-types";
+import { ITableSelectionInput, IFileUploadInput, IDateRangePickerInput, ITextareaProperties, IToggleInput, IMatrixInput, IMultiple, IBasicFormInput, IGetTreeResponse } from "ngx-t-forms-types";
+import { FormSlideInterface } from "ngx-t-forms-types";
+import { IFormActions } from "ngx-t-forms-types";
+import { Observable } from "rxjs";
+export declare const FORM_ACTIONS_TOKEN: InjectionToken<IFormActions>;
+export declare const FORM_CONFIG_TOKEN: InjectionToken<FormInterface>;
+export declare const FORM_SLIDES_TOKEN: InjectionToken<FormSlideInterface>;
+export declare const UTILS_OBJECT_TOKEN: InjectionToken<InClassFormUtilsInterface>;
+export declare const FORM_INPUTS_TOKEN: InjectionToken<ITableSelectionInput & IBasicFormInput & IFileUploadInput & IDateRangePickerInput & ITextareaProperties & IToggleInput & IMatrixInput & IMultiple>;
+export declare const MULTIPLE_FORM_INPUT_TOKEN: InjectionToken<IMultiple>;
+export declare const MSCOA_TREE_PROVIDER: InjectionToken<() => Observable<IGetTreeResponse>>;
+export declare const NGX_T_FORMS_CONFIG_TOKEN: InjectionToken<NgxTFormsConfig>;

package/lib/ngx-t-forms.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class NgxTFormsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTFormsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxTFormsComponent, "lib-ngx-t-forms", never, {}, {}, never, never, true, never>;
+}

package/lib/ngx-t-forms.service.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class NgxTFormsService {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTFormsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxTFormsService>;
+}

package/lib/services/core/t-form-builder/functions/addFormInputToForm.d.ts

@@ -0,0 +1,8 @@
+import { FormInterface } from 'ngx-t-forms-types';
+/**
+ * Adds a form input to the form.
+ *
+ * @param FormBuilder - The `TFormBuilderService` instance.
+ */
+export declare function addFormInputToForm(form: FormInterface, sectionId: string): FormInterface;
+export declare function addMultipleFormInputFn(form: FormInterface, sectionId: string, multipleInputInEditId: string): FormInterface;

package/lib/services/core/t-form-builder/functions/addMultipleInputFunction.d.ts

@@ -0,0 +1,2 @@
+import { FormInterface, IMultipleInputCal } from "ngx-t-forms-types";
+export declare function addMultipleInputFunction(calculationFunction: IMultipleInputCal, multipleInputId: string | undefined, form: FormInterface): FormInterface | undefined;

package/lib/services/core/t-form-builder/functions/addNewSection.d.ts

@@ -0,0 +1,2 @@
+import { FormInterface } from 'ngx-t-forms-types';
+export declare function addNewSection(form: FormInterface): FormInterface;

package/lib/services/core/t-form-builder/functions/deleteSection.d.ts

@@ -0,0 +1,2 @@
+import { FormInterface } from "ngx-t-forms-types";
+export declare function deleteActiveSection(form: FormInterface, sectionId: string): FormInterface;

package/lib/services/core/t-form-builder/functions/formCanSave.d.ts

@@ -0,0 +1,3 @@
+import { FormInterface } from "ngx-t-forms-types";
+export declare function canSaveNewForm(form: FormInterface): boolean;
+export declare function missingConfig(form: FormInterface | undefined): string[];

package/lib/services/core/t-form-builder/functions/inputElementEditorConfigs.d.ts

@@ -0,0 +1,91 @@
+import { FormInterface } from "ngx-t-forms-types";
+import { AllFormInputPrimaryKeys, ElementEditorInnerSectionElementInterface, ElementEditorTypes, FormInputKeys, SpecialElementKeys } from "ngx-t-forms-types";
+import { FormColumnInputs } from "ngx-t-forms-types";
+import { InClassFormUtilsInterface, NgxTFormsConfig } from "ngx-t-forms-types";
+import { ValidationError } from "ngx-t-forms-types";
+export declare function inputElementEditorConfigs(form: FormInterface | undefined, inputInEdit: (FormColumnInputs) | undefined, NGX_T_FORMS_CONFIG: NgxTFormsConfig, utils: InClassFormUtilsInterface): {
+    editorSections: {
+        elements: ElementEditorInnerSectionElementInterface[];
+        hasErrors: boolean;
+        label: string;
+        showItemValue?: keyof FormColumnInputs;
+        id: string;
+        additionalTest?: import("ngx-t-forms-types").ConfigurationValidTestInterface[];
+    }[];
+    title?: string;
+    description?: string;
+};
+export 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) => import("rxjs").Observable<any>;
+    getWorkflowOptions: import("rxjs").Observable<import("ngx-t-forms-types").IWorkflowOption[]> | undefined;
+    getMscoaTree: import("rxjs").Observable<import("ngx-t-forms-types").IGetTreeResponse> | undefined;
+    id: string;
+    name: FormInputKeys | SpecialElementKeys | AllFormInputPrimaryKeys;
+    hint?: string;
+    editType: ElementEditorTypes;
+    deepBind: Array<string>;
+    limitTo?: number;
+    additionalTest?: import("ngx-t-forms-types").ConfigurationValidTestInterface[];
+    disabled?: import("ngx-t-forms-types").ConfigurationValidTestInterface[];
+    fetchOptions?: string[];
+    clearOnChange?: string[][];
+    blurHandle?: import("ngx-t-forms-types").BlurHandleTypes;
+    label: string;
+    readonly?: boolean;
+    templateOptions?: Array<any>;
+    placeholder?: string;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    min?: number;
+    max?: number;
+    step?: number;
+    format?: (value: any) => number;
+})[];
+export declare function processElement(element: 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) => import("rxjs").Observable<any>;
+    getWorkflowOptions: import("rxjs").Observable<import("ngx-t-forms-types").IWorkflowOption[]> | undefined;
+    getMscoaTree: import("rxjs").Observable<import("ngx-t-forms-types").IGetTreeResponse> | undefined;
+    id: string;
+    name: FormInputKeys | SpecialElementKeys | AllFormInputPrimaryKeys;
+    hint?: string;
+    editType: ElementEditorTypes;
+    deepBind: Array<string>;
+    limitTo?: number;
+    additionalTest?: import("ngx-t-forms-types").ConfigurationValidTestInterface[];
+    disabled?: import("ngx-t-forms-types").ConfigurationValidTestInterface[];
+    fetchOptions?: string[];
+    clearOnChange?: string[][];
+    blurHandle?: import("ngx-t-forms-types").BlurHandleTypes;
+    label: string;
+    readonly?: boolean;
+    templateOptions?: Array<any>;
+    placeholder?: string;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    min?: number;
+    max?: number;
+    step?: number;
+    format?: (value: any) => number;
+};
+export declare function getPostmanConfig(element: ElementEditorInnerSectionElementInterface, NGX_T_FORMS_CONFIG: NgxTFormsConfig): {
+    collectionUrl: string;
+    collectionKey: string;
+} | undefined;
+export declare function isElementApplicable(input: any, inputProperties: (FormInputKeys | SpecialElementKeys | AllFormInputPrimaryKeys)[] | undefined, element: ElementEditorInnerSectionElementInterface): boolean;
+export declare function inputInEditValidationErrors(form: FormInterface | undefined, inputInEdit: (FormColumnInputs) | undefined): ValidationError[];

package/lib/services/core/t-form-builder/functions/moveFormInput.d.ts

@@ -0,0 +1,4 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { FormInterface } from 'ngx-t-forms-types';
+export declare function moveFormInput(event: CdkDragDrop<any>, sectionId: string, form: FormInterface): FormInterface | undefined;
+export declare function moveMultipleInputInput(parentId: string, event: CdkDragDrop<any>, form: FormInterface): FormInterface | undefined;

package/lib/services/core/t-form-builder/functions/moveInputToDiffSection.d.ts

@@ -0,0 +1,2 @@
+import { FormInterface } from "ngx-t-forms-types";
+export declare function moveInputToSectionFn(form: FormInterface, inputId: string, targetSection: string): FormInterface;

package/lib/services/core/t-form-builder/functions/multipleInputToggleLabel.d.ts

@@ -0,0 +1,2 @@
+import { FormColumnInputs, FormInterface } from "ngx-t-forms-types";
+export declare function multipleInputToggleLabelFn(item: FormColumnInputs, form: FormInterface): FormInterface | undefined;

package/lib/services/core/t-form-builder/functions/removeItem.d.ts

@@ -0,0 +1,7 @@
+import { FormColumnInputs, FormInterface } from "ngx-t-forms-types";
+export declare function removeItem(item: FormColumnInputs, form: FormInterface): {
+    slides: import("ngx-t-forms-types").FormSlideInterface[];
+    submissionHandle: import("ngx-t-forms-types").FormSubmissionHandleInterface;
+    formId: string | any;
+    formTitle: string;
+};

package/lib/services/core/t-form-builder/functions/sectionDrop.d.ts

@@ -0,0 +1,3 @@
+import { CdkDragDrop } from "@angular/cdk/drag-drop";
+import { FormInterface } from "ngx-t-forms-types";
+export declare function sectionDrop(event: CdkDragDrop<any>, form: FormInterface): FormInterface | undefined;

package/lib/services/core/t-form-builder/functions/stepTitleChangeStep.d.ts

@@ -0,0 +1,14 @@
+import { FormInterface } from "ngx-t-forms-types";
+export declare function stepTitleChangeStepFn(sectionId: string, value: string, form: FormInterface): {
+    slides: {
+        label: string;
+        sectionId: string;
+        columns: Array<import("ngx-t-forms-types").FormColumnInputs>;
+        inEdit?: boolean;
+        sectionIsSeen?: boolean;
+        isActive?: boolean;
+    }[];
+    submissionHandle: import("ngx-t-forms-types").FormSubmissionHandleInterface;
+    formId: string | any;
+    formTitle: string;
+};

package/lib/services/core/t-form-controller/function/calculateInputValue.d.ts

@@ -0,0 +1,11 @@
+import { CalculationFunctions } from "ngx-t-forms-types";
+import { CalculatedFieldRules } from "ngx-t-forms-types";
+import { FormColumnInputs } from "ngx-t-forms-types";
+import { Observable } from "rxjs";
+import { IFunctionUtils } from "../../t-form-tower-controller/form-tower-controller.service";
+export declare function calculateInput(inputConfig: FormColumnInputs, formValue: () => Record<string, any>, utils: IFunctionUtils): Observable<void>;
+export declare function configureCalculationScope(input: FormColumnInputs, formValue: Record<string, any>): Record<string, number>;
+export declare function evaluateFormulaAgainstScope(rules: CalculatedFieldRules | undefined, scope: {
+    [key: string]: number;
+}): number | undefined;
+export declare function calculateListOveralFunctions(rule: CalculationFunctions, arrayValues: any): number;

package/lib/services/core/t-form-controller/function/getApiDataFetching.d.ts

@@ -0,0 +1,4 @@
+import { FormColumnInputs } from "ngx-t-forms-types";
+import { IFunctionUtils } from "../../t-form-tower-controller/form-tower-controller.service";
+import { Observable } from "rxjs";
+export declare function getApiDataFetching(inputConfig: FormColumnInputs, dataFor: "options" | "value", utils: IFunctionUtils): Observable<void>;

package/lib/services/core/t-form-controller/function/postApiDataFetching.d.ts

@@ -0,0 +1,16 @@
+import { FormColumnInputs } from "ngx-t-forms-types";
+import { Observable } from "rxjs";
+import { MinimumInputRequiredInterface } from "ngx-t-forms-types";
+import { IFunctionUtils } from "../../t-form-tower-controller/form-tower-controller.service";
+/**
+ * Retrieves the input data for a POST request.
+ * @param minRequiredInputs - An array of TInputControllerService objects representing the minimum required inputs.
+ * @param inputClass - The TInputControllerService object representing the input class requesting the data.
+ * @param formValues - An object containing the entire form's values.
+ * @param section - The TFormSectionControllerService object representing the form section.
+ * @param minInputs - An array of MinimumInputRequiredInterface objects representing the minimum required inputs.
+ * @param dataFor - A string indicating whether the data is for "options" or "value".
+ * @param httpPostDataFunction - A function that performs the HTTP POST request.
+ */
+export declare function inputGetApiPostData(inputConfig: FormColumnInputs, formValues: any, dataFor: "options" | "value", utils: IFunctionUtils): Observable<void>;
+export declare function returnMappedData(formValues: any, minInputs: MinimumInputRequiredInterface[], endpoint: string): any;

package/lib/services/core/t-form-controller/function/validateMinInputForPostRequest.d.ts

@@ -0,0 +1,8 @@
+import { MinimumInputRequiredInterface } from "ngx-t-forms-types";
+/**
+ * Validates the minimum input required for a post request.
+ * @param input - The minimum input required.
+ * @param formValues - The form values.
+ * @returns A boolean indicating whether the minimum input is valid or not.
+ */
+export declare function validateMinInput(input: MinimumInputRequiredInterface, formValues: any): boolean;

package/lib/services/core/t-form-environment-injection/functions/provideNgxTforms.d.ts

@@ -0,0 +1,3 @@
+import { EnvironmentProviders } from '@angular/core';
+import { NgxTFormsConfig } from 'ngx-t-forms-types';
+export declare function provideNgxTForms(config: NgxTFormsConfig): EnvironmentProviders;

package/lib/services/core/t-form-section-controller/Functions/commonFormOperations.d.ts

@@ -0,0 +1,21 @@
+import { AbstractControlOptions, ValidatorFn } from "@angular/forms";
+import { FormControlCustomValidatorsInterface } from 'ngx-t-forms-types';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+/**
+ * Generates a form group based on the provided inputs and optional validator.
+ *
+ * @param inputs - An array of form inputs. Each input can be of type IBasicFormInput, IMultiple, ITableSelectionInput, IFileUploadInput, or IMatrixInput.
+ * @param validator - An optional object containing validation rules for the form group.
+ *
+ * @returns A FormGroup instance. If a validator is provided, it is applied to the form group.
+ *
+ * @throws Will throw an error if an error occurs while crwhile postingeating the form group.
+ */
+export interface FormObject {
+    [key: string]: [{
+        value: any;
+        disabled: boolean;
+    }, AbstractControlOptions];
+}
+export declare function compileInputValidators(input: FormColumnInputs, getFormValue: () => Record<string, any>): AbstractControlOptions;
+export declare function returnValidator(validators: Array<string | FormControlCustomValidatorsInterface>, formValue: () => Record<string, any>): ValidatorFn[];

package/lib/services/core/t-form-section-controller/Functions/errorResolver.d.ts

@@ -0,0 +1,7 @@
+interface HttpError extends Error {
+    status?: number;
+    error?: any;
+}
+export declare function errorResolver(err: HttpError | undefined): string | undefined;
+export declare function resolveErrorString(error: Error | any): any;
+export {};

package/lib/services/core/t-form-section-controller/Functions/formGenerator.d.ts

@@ -0,0 +1,29 @@
+import { FormGroup, AbstractControl, FormControl } from "@angular/forms";
+import { FormColumnInputs } from "ngx-t-forms-types";
+/**
+ * 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
+ */
+export declare function formGenerator(inputs: Array<FormColumnInputs>, getFormValue: () => Record<string, any>): FormGroup;
+/**
+ * Retrieves a section FormGroup from the parent form
+ *
+ * @param form The parent FormGroup
+ * @param sectionId The ID of the section to retrieve
+ * @returns The section FormGroup or null if not found
+ */
+export declare function getSectionForm(form: FormGroup | undefined, sectionId: string): FormGroup | null;
+/**
+ * Retrieves a specific control from a section
+ *
+ * @param form The parent FormGroup
+ * @param sectionId The ID of the section containing the control
+ * @param controlId The ID of the control to retrieve
+ * @returns The form control or null if not found
+ */
+export declare function getSectionControl(form: FormGroup, sectionId: string, controlId: string): AbstractControl | null;
+export declare function generateControlsForTheseInputs(inputs: FormColumnInputs[], getFormValue: any): Record<string, FormControl>;

package/lib/services/core/t-form-section-controller/Functions/getValueFromPathMap.d.ts

@@ -0,0 +1,6 @@
+import { FormInputBasicOptionInterface, TreeNode } from 'ngx-t-forms-types';
+declare const returnMappedPathValue: (pathMap: TreeNode[], obj: any) => any;
+declare const getValueFromValueAccessor: (valueAccessRules: FormInputBasicOptionInterface | TreeNode[] | {
+    [key: string]: TreeNode[];
+}, data: any) => any;
+export { returnMappedPathValue, getValueFromValueAccessor };

package/lib/services/core/t-form-tower-controller/form-tower-controller.service.d.ts

@@ -0,0 +1,99 @@
+import { OnDestroy } from '@angular/core';
+import { FormColumnInputs, FormInterface, FormSubmissionStatus, IFormChangeHistory } from 'ngx-t-forms-types';
+import { FormGroup } from '@angular/forms';
+import { Observable, Subject } from 'rxjs';
+import { FunctionTypes } from './functions/getAllFunctionTypes';
+import { HintType } from '../../../shared/functions/textIconsForUserHints';
+import { HttpClient } from '@angular/common/http';
+import { StepperSelectionEvent } from '@angular/cdk/stepper';
+import * as i0 from "@angular/core";
+interface DependentInput {
+    inputId: string;
+    functionType: FunctionTypes;
+}
+export interface IFunctionUtils {
+    setInputTemporaryError: (inputId: string, message: string) => void;
+    setTemporaryHint: (inputId: string, message: string, type: HintType) => void;
+    setInputStatus: (inputId: string, statusId: string, status: string) => void;
+    removeInputStatus: (inputId: string, statusId: string) => void;
+    updateValue: (inputId: string, value: any) => void;
+    httpPostDataFunction: (url: string, data: any, options?: any) => Observable<any>;
+    httpGetDataFunction: (url: string, options?: any) => Observable<any>;
+    updateFormInputConfig: (inputId: string, config: FormColumnInputs) => void;
+    fileUpload: (file: string, fileName: string, fileType: string) => Observable<{
+        url: string;
+    }>;
+}
+export declare abstract class FormTowerControllerService implements OnDestroy {
+    private _http;
+    readonly NGX_T_FORMS_CONFIG: import("ngx-t-forms-types").NgxTFormsConfig;
+    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 _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);
+    get mainForm(): FormGroup | undefined;
+    get changeHistory(): IFormChangeHistory[];
+    set changeHistory(value: IFormChangeHistory[]);
+    ngOnDestroy(): void;
+    initialize: (form: FormInterface) => Promise<void>;
+    setFirstStepAsActive: () => void;
+    getFormValueNames: () => Record<string, any>;
+    readonly allFormInputs: () => FormColumnInputs[] | undefined;
+    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;
+    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: () => import("ngx-t-forms-types").ITowerFormSteps[];
+    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;
+    /**
+     * 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) => boolean;
+    saveMultipleInputForm: (inputId: string) => boolean;
+    multipleInputEditRow: (inputId: string, rowId: string) => boolean;
+    multipleInputDuplicateRow: (inputId: string, rowId: string) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormTowerControllerService, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormTowerControllerService, never, never, {}, {}, never, never, true, never>;
+}
+export {};

package/lib/services/core/t-form-tower-controller/functions/allFormInputs.d.ts

@@ -0,0 +1,3 @@
+import { FormColumnInputs } from "ngx-t-forms-types";
+import { FormTowerControllerService } from "../form-tower-controller.service";
+export declare const allFormInputs: (self: FormTowerControllerService) => FormColumnInputs[] | undefined;

package/lib/services/core/t-form-tower-controller/functions/createEmptyForm.d.ts

@@ -0,0 +1,2 @@
+import { FormInterface } from "ngx-t-forms-types";
+export declare const createEmptyForm: () => FormInterface;

package/lib/services/core/t-form-tower-controller/functions/extractInitFunctions.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { FunctionTypes } from "./getAllFunctionTypes";
+/**
+ * Extracts ValueGetMethodAPI and OptionsGetMethodAPI observables from the input collection
+ * @param inputCollection The collection of functions to extract from
+ * @returns Array of extracted observables
+ */
+export declare function extractSpecificFunctionTypes(inputCollection: Record<string, Partial<Record<FunctionTypes, Observable<void>>>>): Observable<void>[];

package/lib/services/core/t-form-tower-controller/functions/getAllFunctionTypes.d.ts

@@ -0,0 +1,12 @@
+import { FormColumnInputs } from "ngx-t-forms-types";
+export declare enum FunctionTypes {
+    ValueCalculation = "ValueCalculation",
+    ValuePostMethodAPI = "ValuePostMethodAPI",
+    OptionsPostMethodAPI = "OptionsPostMethodAPI",
+    ValueGetMethodAPI = "ValueGetMethodAPI",
+    OptionsGetMethodAPI = "OptionsGetMethodAPI",
+    InputSourcedValue = "InputSourcedValue",
+    ManualValueValidation = "ManualValueValidation"
+}
+export declare function getAllFunctionTypes(inputConfig: FormColumnInputs): Partial<Record<FunctionTypes, boolean>>;
+export declare function createInputChangeDependency(inputConfig: FormColumnInputs): Partial<Record<FunctionTypes, Record<string, boolean>>>;

package/lib/services/core/t-form-tower-controller/functions/getFormValue.d.ts

@@ -0,0 +1,3 @@
+import { FormTowerControllerService } from "../form-tower-controller.service";
+export declare const getFormValue: (self: FormTowerControllerService) => Record<string, any>;
+export declare const getFormValueAsFormControlBasedObject: (self: FormTowerControllerService) => Record<string, any>;

package/lib/services/core/t-form-tower-controller/functions/getSubmissionStatus.d.ts

@@ -0,0 +1,7 @@
+import { ITowerFormSteps } from 'ngx-t-forms-types';
+import { FormTowerControllerService } from '../form-tower-controller.service';
+import { MatStepper } from '@angular/material/stepper';
+import { FormGroup } from '@angular/forms';
+export declare function formProgress(self: FormTowerControllerService): number;
+export declare const formSubmissionMessage: (self: FormTowerControllerService) => string;
+export declare function getSubmissionStatusFn(stepper: MatStepper | undefined, mainForm: FormGroup | undefined, formProgress: number, steps: ITowerFormSteps[], loading: boolean): string;

package/lib/services/core/t-form-tower-controller/functions/handleStepChange.d.ts

@@ -0,0 +1,3 @@
+import { StepperSelectionEvent } from '@angular/cdk/stepper';
+import { FormTowerControllerService } from '../form-tower-controller.service';
+export declare const handleStepChange: (self: FormTowerControllerService, event: StepperSelectionEvent) => void;

package/lib/services/core/t-form-tower-controller/functions/multipleInputRowIDControllInput.d.ts

@@ -0,0 +1,2 @@
+import { FormColumnInputs } from "ngx-t-forms-types";
+export declare const multipleInputRowIDControlInput: (value: string | undefined, multipleInputInEditId: string) => FormColumnInputs;

package/lib/services/core/t-form-tower-controller/functions/prePoPulateForm.d.ts

@@ -0,0 +1,85 @@
+import { FormInterface } from "ngx-t-forms-types";
+export declare const prepPopulateForm: (form: FormInterface, initValue: Record<string, any>) => FormInterface | {
+    slides: {
+        columns: {
+            value: any;
+            label: string;
+            formControlName: string;
+            readonly?: boolean;
+            id: string;
+            sectionId: string;
+            pipe?: {
+                pipeType: import("ngx-t-forms-types").InputPipeTypes;
+                param: string;
+            };
+            hintLabel?: string;
+            temporaryHint?: string;
+            valueUpdatedAt?: Date;
+            status?: Record<string, string>;
+            min?: number | string | Date | import("ngx-t-forms-types/dist/interfaces/formInput/BasicFormInputInterface").MaxMinCustomScripts;
+            max?: number | string | Date | import("ngx-t-forms-types/dist/interfaces/formInput/BasicFormInputInterface").MaxMinCustomScripts;
+            tourContent?: string;
+            viewType?: import("ngx-t-forms-types/dist/interfaces/formInput/BasicFormInputInterface").InputViewTypes;
+            maxLength?: number;
+            minLength?: number;
+            placeholder?: string;
+            pattern?: string;
+            spellcheck?: boolean;
+            autocapitalize?: import("ngx-t-forms-types").AutocapitalizeOptions;
+            autocomplete?: import("ngx-t-forms-types").AutocompleteOptions;
+            multipleInputInEditId?: string;
+            suffixText?: string;
+            prefixText?: string;
+            prefixIcon?: string;
+            suffixIcon?: string;
+            disabled?: boolean;
+            script?: Record<string, unknown>;
+            conditionalInputConfig?: import("ngx-t-forms-types/dist/interfaces/formInput/ConditionalInputRule").ConditionalInputRule[];
+            calculatedFieldRules?: import("ngx-t-forms-types").CalculatedFieldRules;
+            element: import("ngx-t-forms-types").ElementTypes;
+            dataType: import("ngx-t-forms-types").InputDataTypes;
+            appearance: import("@angular/material/form-field").MatFormFieldAppearance;
+            type?: import("ngx-t-forms-types").InputTypes;
+            required: boolean;
+            colSize: number;
+            onlySetTempErrorOnTouch: boolean;
+            isCalculatedField: boolean;
+            matOptions?: import("ngx-t-forms-types").MatDataOptionsInterface;
+            validators: Array<import("ngx-t-forms-types").FormControlCustomValidatorsInterface | string>;
+            selectUpto?: number;
+            tableConfig?: import("ngx-t-forms-types").TableConfigurationsInterface;
+            fileType?: import("ngx-t-forms-types").InputFileType;
+            singleSelect?: boolean;
+            accept?: string;
+            endDateControl?: string;
+            startDateControl?: string;
+            startMinDate?: Date;
+            endMaxDate?: Date;
+            startMaxDate?: Date;
+            endMinDate?: Date;
+            rows?: number;
+            wrap?: "hard" | "soft";
+            labelPosition?: import("ngx-t-forms-types/dist/interfaces/formInput/ToggleInputInterface").LabelPosition;
+            matrixTableConfig?: {
+                dataSource: string;
+            };
+            handleLabel: string;
+            formIsOpen?: boolean;
+            originalId?: string;
+            showAsLabel?: boolean;
+            formInputs?: Array<import("ngx-t-forms-types").FormColumnInputs>;
+            calculateListFunctions: Array<import("ngx-t-forms-types").IMultipleInputCal>;
+            groupBy?: string[];
+            mscoaConfig: import("ngx-t-forms-types").IMscoaInputConfig;
+            richTextEditorLibrary: import("ngx-t-forms-types/dist/interfaces/formInput/RichTextEditorInput").RichTextEditorType;
+        }[];
+        sectionId: string;
+        label: string;
+        inEdit?: boolean;
+        sectionIsSeen?: boolean;
+        isActive?: boolean;
+    }[];
+    submissionHandle: import("ngx-t-forms-types").FormSubmissionHandleInterface;
+    formId: string | any;
+    formTitle: string;
+};