ngx-t-forms 0.0.1

package/lib/components/form-builder/elements/form-section-stepper/form-section-stepper.component.d.ts

@@ -0,0 +1,146 @@
+import { OnInit } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { StepperSelectionEvent, StepState } from '@angular/cdk/stepper';
+import { MatStepper } from '@angular/material/stepper';
+import { FormTowerControllerService } from '../../../../services/core/t-form-tower-controller/form-tower-controller.service';
+import { FormBuilderFunctions, FormColumnInputs, IMultipleInputCal } from 'ngx-t-forms-types';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as i0 from "@angular/core";
+export declare class FormSectionStepperComponent extends FormTowerControllerService implements OnInit {
+    ngOnInit(): void;
+    private store;
+    loadingForm$: Observable<boolean>;
+    isEditable: boolean;
+    stepper: MatStepper | undefined;
+    get formBuilderFunctions(): FormBuilderFunctions;
+    getPreviousStepLabel(): string | undefined;
+    getNextStepLabel(): string | undefined;
+    getStepState(step: any, index: number): StepState;
+    activeInput: string | undefined;
+    get getSubmissionStatus$(): Observable<string>;
+    dragging: boolean;
+    drop: (event: any) => void;
+    dropItems: (event: any, sectionId: string) => void;
+    formDeleteSection: (sectionId: string) => void;
+    addMultipleFormInput: (sectionId: string, multipleInputId: string) => void;
+    moveInputToSection: (inputId: string, targetSectionId: string) => void;
+    reorderMultipleInputItems: (event: CdkDragDrop<FormColumnInputs[], any, any>, multipleInputId: string) => void;
+    cloneCopyFormInput: (inputId: string) => void;
+    multipleInputToggleLabel: (item: FormColumnInputs) => void;
+    editInput: (item: FormColumnInputs) => void;
+    addMultipleInputValueCalculationFunction: (item: IMultipleInputCal, multipleInputId: string | undefined) => void;
+    setActiveSection: ($event: StepperSelectionEvent) => number;
+    addNewInput: (sectionId: string) => void;
+    addSection: () => void;
+    setMatActiveStepper: (index: number) => number;
+    mouseOverSection: string | null;
+    handleInput: (event: Event, sectionId: string) => void;
+    get selectFormStepsComputed(): {
+        columns: {
+            inputConfigErrors: {
+                key: string;
+                message: string;
+            }[];
+            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;
+            value?: number | string | boolean | Date | File | {
+                [key: string]: any;
+            } | Array<{
+                [key: string]: any;
+            }>;
+            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<FormColumnInputs>;
+            calculateListFunctions: Array<IMultipleInputCal>;
+            groupBy?: string[];
+            mscoaConfig: import("ngx-t-forms-types").IMscoaInputConfig;
+            richTextEditorLibrary: import("ngx-t-forms-types/dist/interfaces/formInput/RichTextEditorInput").RichTextEditorType;
+        }[];
+        label: string;
+        sectionId: string;
+        sectionForm: import("@angular/forms").FormGroup<any> | null;
+        sectionIsInvalid: boolean | undefined;
+        sectionIsSeen: boolean | undefined;
+        sectionFormErrorMessage: string;
+        activeSectionHasTour: boolean;
+        tourOptions: (string | undefined)[];
+        isActive: boolean | undefined;
+    }[];
+    overId: string | null;
+    countdownSeconds: {
+        [key: string]: {
+            count: number | null;
+            stop$: Subject<void>;
+        };
+    };
+    stopDeletion(id: string): void;
+    inputWillBeRemovedIn: (id: string) => number | null | undefined;
+    removeInput(item: FormColumnInputs): void;
+    deleteSection(sectionId: string | null): void;
+    getPlaceHolerForSection: (sectionId: string) => any;
+    formDeleteInput: (item: FormColumnInputs) => void;
+    openSectionReports: Record<string, boolean>;
+    toggleSectionReports: (sectionId: string) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormSectionStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormSectionStepperComponent, "app-form-section-stepper", never, {}, {}, never, never, true, never>;
+}

package/lib/components/form-builder/elements/form-submissions-config/config.d.ts

@@ -0,0 +1,18 @@
+import { ElementEditorInnerSectionElementInterface, NgxTFormsConfig } from "ngx-t-forms-types";
+export declare function SubmissionAPIListItemConfig(environment: NgxTFormsConfig): ElementEditorInnerSectionElementInterface[];
+export declare const SubmissionAPIOtherConfig: ElementEditorInnerSectionElementInterface[];
+export declare const SubmissionDialogConfig: ({
+    titleIcon: string;
+    id: string;
+    title: string;
+    description: string;
+    primaryKey: string;
+    elements: ElementEditorInnerSectionElementInterface[];
+} | {
+    titleIcon: string;
+    title: string;
+    description: string;
+    primaryKey: string;
+    id: string;
+    elements?: undefined;
+})[];

package/lib/components/form-builder/elements/form-submissions-config/form-submissions-config.component.d.ts

@@ -0,0 +1,61 @@
+import { MatDialog } from '@angular/material/dialog';
+import { FormsStoreService } from '../../../forms/store/forms-store.service';
+import { APIDataFetchingConfigurationInterface, ElementEditorInnerSectionElementInterface } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class FormSubmissionsConfigComponent {
+    NGX_T_FORMS_CONFIG: import("ngx-t-forms-types").NgxTFormsConfig;
+    panels: import("@angular/core").Signal<({
+        error: string | undefined;
+        titleIcon: string;
+        id: string;
+        title: string;
+        description: string;
+        primaryKey: string;
+        elements: ElementEditorInnerSectionElementInterface[];
+    } | {
+        error: string | undefined;
+        titleIcon: string;
+        title: string;
+        description: string;
+        primaryKey: string;
+        id: string;
+        elements?: undefined;
+    })[]>;
+    private getPanelError;
+    _data: any;
+    store: FormsStoreService;
+    form: import("@angular/core").Signal<import("ngx-t-forms-types").FormInterface | undefined>;
+    formInputs: import("@angular/core").Signal<import("ngx-t-forms-types").FormColumnInputs[]>;
+    getFormApis(key: any): import("@angular/core").Signal<APIDataFetchingConfigurationInterface[]>;
+    constructor();
+    dataPlaceholder: undefined | {
+        data: APIDataFetchingConfigurationInterface;
+    };
+    keyInEdit: 'submissionAPI' | 'canSubmitAPI' | undefined;
+    get submissionApiListItemConfigElements(): ElementEditorInnerSectionElementInterface[];
+    formValidationError: import("@angular/core").Signal<{
+        key: string;
+        message: string;
+    }[]>;
+    readonly computedErrors: (element: ElementEditorInnerSectionElementInterface) => import("@angular/core").Signal<{
+        key: string;
+        message: string;
+    }[]>;
+    validationErrors(element: ElementEditorInnerSectionElementInterface): {
+        key: string;
+        message: string;
+    }[];
+    elementBlur(event: any, element: ElementEditorInnerSectionElementInterface): void;
+    inputChange(event: any, element: ElementEditorInnerSectionElementInterface): void;
+    passFormChanges(event: any, element: ElementEditorInnerSectionElementInterface): void;
+    formInputChange: (value: any, ele: ElementEditorInnerSectionElementInterface) => void;
+    elementConfigurationChanged(value: any, ele: ElementEditorInnerSectionElementInterface): void;
+    addNewSubmitApi(submision: string): void;
+    saveSubmitApi(): void;
+    removeSubmissionApi(api: APIDataFetchingConfigurationInterface): void;
+    cancelSubmitApi(): void;
+    matDialog: MatDialog;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormSubmissionsConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormSubmissionsConfigComponent, "app-form-submissions-config", never, {}, {}, never, never, true, never>;
+}

package/lib/components/form-builder/elements/forms-builder-menu/forms-builder-menu.component.d.ts

@@ -0,0 +1,35 @@
+import { MatDialog } from '@angular/material/dialog';
+import { FormsStoreService } from '../../../forms/store/forms-store.service';
+import { FormInterface } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class FormsBuilderMenuComponent {
+    private store;
+    form: import("@angular/core").Signal<FormInterface | undefined>;
+    showJson: boolean;
+    constructor(store: FormsStoreService);
+    items: import("@angular/core").Signal<({
+        label: string;
+        icon: string;
+        hint: string;
+        action: () => void;
+        errors?: undefined;
+    } | {
+        label: string;
+        hint: string;
+        icon: string;
+        errors: boolean;
+        action: () => void;
+    })[]>;
+    formCopy: import("@angular/core").Signal<string>;
+    readonly dialog: MatDialog;
+    openDialog(): void;
+    applyFormTemplate: (form: FormInterface) => void;
+    openFormSubmissionDialog(): void;
+    errors: import("@angular/core").Signal<{
+        key: string;
+        message: string;
+    }[]>;
+    configHasErrors: import("@angular/core").Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormsBuilderMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormsBuilderMenuComponent, "app-forms-builder-menu", never, {}, {}, never, never, true, never>;
+}

package/lib/components/form-builder/elements/input-editor/input-editor.component.d.ts

@@ -0,0 +1,18 @@
+import { FormsStoreService } from '../../../forms/store/forms-store.service';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class InputEditorComponent {
+    private store;
+    defaultInputs: import("ngx-t-forms-types").DefaultInputConfigInterface;
+    inputInEdit$: Observable<import("ngx-t-forms-types").FormColumnInputs | undefined>;
+    defaultInputInEdit$: Observable<any>;
+    constructor(store: FormsStoreService);
+    saveInput: () => void;
+    closeEditor: () => import("rxjs").Subscription;
+    get validationErrors$(): Observable<{
+        key: string;
+        message: string;
+    }[] | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputEditorComponent, "app-input-editor", never, {}, {}, never, never, true, never>;
+}

package/lib/components/form-builder/elements/input-element-editor/input-element-editor.component.d.ts

@@ -0,0 +1,42 @@
+import { ElementEditorInnerSectionElementInterface } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class InputElementEditorComponent {
+    private store;
+    inputElementEditorConfigs$: import("rxjs").Observable<{
+        editorSections: {
+            elements: 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;
+    }>;
+    inputElementEditorConfigs: import("@angular/core").Signal<{
+        editorSections: {
+            elements: 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;
+    } | undefined>;
+    inputInEdit$: import("rxjs").Observable<import("ngx-t-forms-types").FormColumnInputs | undefined>;
+    inputInEdit: import("@angular/core").Signal<import("ngx-t-forms-types").FormColumnInputs | undefined>;
+    defaultInputInEdit$: import("rxjs").Observable<any>;
+    defaultInputInEdit: import("@angular/core").Signal<any>;
+    formInputs$: import("rxjs").Observable<import("ngx-t-forms-types").FormColumnInputs[]>;
+    formInputs: import("@angular/core").Signal<import("ngx-t-forms-types").FormColumnInputs[] | undefined>;
+    elementConfigurationChanged: (value: any, ele: ElementEditorInnerSectionElementInterface) => void;
+    clearInputInEdit: () => void;
+    elementBlur: (event: any, element: ElementEditorInnerSectionElementInterface) => void;
+    inputInEditValidationErrors$: import("rxjs").Observable<import("ngx-t-forms-types").ValidationError[]>;
+    inputInEditValidationErrors: import("@angular/core").Signal<import("ngx-t-forms-types").ValidationError[] | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputElementEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputElementEditorComponent, "app-input-element-editor", never, {}, {}, never, never, true, never>;
+}

package/lib/components/form-builder/elements/missing-form-configs/missing-form-configs.component.d.ts

@@ -0,0 +1,12 @@
+import { FormsStoreService } from '../../../forms/store/forms-store.service';
+import * as i0 from "@angular/core";
+export declare class MissingFormConfigsComponent {
+    private store;
+    errors: import("@angular/core").Signal<string[]>;
+    missingConfigs: import("@angular/core").Signal<string[]>;
+    constructor(store: FormsStoreService);
+    hideDetails: boolean;
+    showAllErrors: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MissingFormConfigsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MissingFormConfigsComponent, "app-missing-form-configs", never, {}, {}, never, never, true, never>;
+}

package/lib/components/form-builder/elements/section-report/section-report.component.d.ts

@@ -0,0 +1,23 @@
+import { MatSort } from '@angular/material/sort';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatTableDataSource } from '@angular/material/table';
+import { FormSlideInterface } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class SectionReportComponent {
+    sectionId: string;
+    sort: MatSort;
+    paginator: MatPaginator;
+    displayedColumns: string[];
+    dataSource: MatTableDataSource<any, MatPaginator>;
+    private store;
+    selectFormInEdit$: import("rxjs").Observable<import("ngx-t-forms-types").DatabaseFormInterface | null>;
+    selectFormInEdit: import("@angular/core").Signal<import("ngx-t-forms-types").DatabaseFormInterface | null | undefined>;
+    constructor();
+    ngOnInit(): void;
+    section: import("@angular/core").Signal<FormSlideInterface | null>;
+    sectionData: import("@angular/core").Signal<any[]>;
+    updateTableData(data: FormSlideInterface | null): any[];
+    applyFilter(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionReportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionReportComponent, "app-section-report", never, { "sectionId": { "alias": "sectionId"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/form-builder/elements/select-form-template/select-form-template.component.d.ts

@@ -0,0 +1,17 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import { FormsStoreService } from '../../../forms/store/forms-store.service';
+import { FormInterface } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class SelectFormTemplateComponent {
+    private store;
+    selectForms$: import("rxjs").Observable<import("ngx-t-forms-types").LocalFormStateSelectorInterface[]>;
+    selectLoadingForms$: import("rxjs").Observable<boolean>;
+    readonly dialogRef: MatDialogRef<any, any>;
+    readonly data: any;
+    constructor(store: FormsStoreService);
+    close(): void;
+    selectForm(form: FormInterface): void;
+    getFormAvatar(formTitle: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectFormTemplateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectFormTemplateComponent, "lib-select-form-template", never, {}, {}, never, never, true, never>;
+}

package/lib/components/form-builder/form-builder.component.d.ts

@@ -0,0 +1,29 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FormBuilderComponent implements OnDestroy, OnInit {
+    subscription$: Subscription;
+    private store;
+    private route;
+    selectLoadingForm: import("@angular/core").Signal<boolean>;
+    selectFormBuilderIsBusy: import("@angular/core").Signal<boolean>;
+    selectFormUpdated: import("@angular/core").Signal<string | Date | null>;
+    canSaveForm: import("@angular/core").Signal<boolean>;
+    isNewForm: import("@angular/core").Signal<boolean>;
+    set formId(value: string);
+    selectHasFormId: import("@angular/core").Signal<boolean>;
+    hasMissingConfigs: import("@angular/core").Signal<boolean>;
+    elementEditorOpen: import("@angular/core").Signal<boolean | null>;
+    constructor();
+    readonly NGX_T_FORMS_CONFIG: import("ngx-t-forms-types").NgxTFormsConfig;
+    readonly closeButton: import("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>;
+}

package/lib/components/forms/forms.component.d.ts

@@ -0,0 +1,44 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { FormsStoreService } from './store/forms-store.service';
+import { ActivatedRoute, Router } from '@angular/router';
+import { FormListSection, LocalFormStateSelectorInterface } from "ngx-t-forms-types";
+import { Observable, Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FormsComponent implements OnInit, OnDestroy {
+    private route;
+    private store;
+    private document;
+    subscription$: Subscription;
+    selectFormsList$: Observable<LocalFormStateSelectorInterface[]>;
+    selectLoadingForms$: Observable<boolean>;
+    selectErrors$: Observable<any>;
+    selectFormListSection$: Observable<FormListSection>;
+    NGX_T_FORMS_CONFIG: import("ngx-t-forms-types").NgxTFormsConfig;
+    closeButton: import("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 | 2 | 4 | 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormsComponent, "app-forms", never, {}, {}, never, never, true, never>;
+}

package/lib/components/forms/functions/cloneCopyFormInput.d.ts

@@ -0,0 +1,3 @@
+import { FormInterface } from "ngx-t-forms-types";
+export declare const cloneCopyFormInputFn: (form: FormInterface, inputId: string) => FormInterface;
+export declare const clearInputInEditFn: (form: FormInterface, inputId: string) => FormInterface;

package/lib/components/forms/functions/elementBlur.d.ts

@@ -0,0 +1,2 @@
+import { ElementEditorInnerSectionElementInterface, FormInterface } from "ngx-t-forms-types";
+export declare const elementBlurFn: (form: FormInterface, inputId: string, event: any, element: ElementEditorInnerSectionElementInterface) => FormInterface;

package/lib/components/forms/functions/elementConfigurationChanged.d.ts

@@ -0,0 +1,2 @@
+import { ElementEditorInnerSectionElementInterface, FormInterface } from 'ngx-t-forms-types';
+export declare const elementConfigurationChangedFn: (form: FormInterface, inputId: string, configuration: ElementEditorInnerSectionElementInterface, value: any) => FormInterface;

package/lib/components/forms/functions/findFormInput.d.ts

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

package/lib/components/forms/functions/formHttpSubmissions.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from "rxjs";
+import { InClassFormUtilsInterface, FormInterface } from 'ngx-t-forms-types';
+export type FileUploadFn = (file: string, fileName: string, fileType: string) => Observable<{
+    url: string;
+}>;
+export declare const formHttpSubmissions: (form: FormInterface, formData: any, passData: any, Utils: InClassFormUtilsInterface) => Observable<any>;

package/lib/components/forms/functions/selectInputTemplate.d.ts

@@ -0,0 +1,3 @@
+import { ElementTypes, FormInterface } from "ngx-t-forms-types";
+export declare const getElementTemplate: (element: ElementTypes) => any;
+export declare const selectInputTemplateFn: (form: FormInterface, inputId: string, element: ElementTypes) => FormInterface;

package/lib/components/forms/store/Form-actions-formBuilder.d.ts

@@ -0,0 +1,34 @@
+import { FormsStoreService } from "./forms-store.service";
+import { CdkDragDrop } from "@angular/cdk/drag-drop";
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { APIDataFetchingConfigurationInterface, ElementTypes, IMultipleInputCal } from 'ngx-t-forms-types';
+import { FormInterface } from 'ngx-t-forms-types';
+import { ElementEditorInnerSectionElementInterface } from 'ngx-t-forms-types';
+export declare function formBuilderStoreActions(store: FormsStoreService): {
+    handelSaveForm: () => void;
+    setFormTitle: (title: string) => void;
+    handleSectionDragDrop: (event: CdkDragDrop<any, any, any>) => void;
+    handleInputDragDrop: (event: CdkDragDrop<any, any, any>, sectionId: string) => void;
+    handleAddSection: () => void;
+    stepTitleChangeStep: (sectionId: string, title: string) => void;
+    formDeleteInput: (item: FormColumnInputs) => void;
+    multipleInputToggleLabel: (item: FormColumnInputs) => void;
+    editInput: (item: FormColumnInputs) => void;
+    addMultipleInputValueCalculationFunction: (item: IMultipleInputCal, multipleInputId: string | undefined) => void;
+    formDeleteSection: (sectionId: string) => void;
+    moveInputToSection: (inputId: string, targetSectionId: string) => void;
+    reorderMultipleInputItems: (event: CdkDragDrop<FormColumnInputs[], any, any>, multipleInputId: string) => void;
+    cloneCopyFormInput: (inputId: string) => void;
+    saveInput: (sectionId: string) => void;
+    applyFormTemplate: (form: FormInterface) => void;
+    selectInputTemplate: (inputId: string, element: ElementTypes) => void;
+    formInputChange: (ele: ElementEditorInnerSectionElementInterface, value: any) => void;
+    saveSubmitApi: (dataPlaceholder: undefined | {
+        data: APIDataFetchingConfigurationInterface;
+    }, keyInEdit: "submissionAPI" | "canSubmitAPI" | undefined) => void;
+    removeSubmissionApi: (api: APIDataFetchingConfigurationInterface, keyInEdit: "submissionAPI" | "canSubmitAPI" | undefined) => void;
+    elementConfigurationChanged: (inputId: string, value: any, ele: ElementEditorInnerSectionElementInterface) => void;
+    elementBlur: (inputId: string, event: any, element: ElementEditorInnerSectionElementInterface) => void;
+    addMultipleFormInput: (sectionId: string, multipleInputInEditId: string) => void;
+    clearInputInEdit: (inputId: string) => void;
+};

package/lib/components/forms/store/Form-selectors-FormBuilder.d.ts

@@ -0,0 +1,42 @@
+import { FormsStoreService } from "./forms-store.service";
+export declare function formsFormBuilderStoreSelectors(store: FormsStoreService): {
+    selectFormSlides$: import("rxjs").Observable<import("ngx-t-forms-types").FormSlideInterface[]>;
+    missingConfig$: import("rxjs").Observable<string[]>;
+    canSaveForm$: import("rxjs").Observable<boolean>;
+    isNewForm$: import("rxjs").Observable<boolean>;
+    hasMissingConfigs$: import("rxjs").Observable<boolean>;
+    formErrors$: import("rxjs").Observable<{
+        key: string;
+        message: string;
+    }[]>;
+    formValidationErrorsMessages$: import("rxjs").Observable<string[]>;
+    inputInEdit$: import("rxjs").Observable<import("ngx-t-forms-types").FormColumnInputs | undefined>;
+    defaultInputInEdit$: import("rxjs").Observable<any>;
+    inputInEditValidationErrors$: import("rxjs").Observable<import("ngx-t-forms-types").ValidationError[]>;
+    selectFormTitle$: import("rxjs").Observable<string | undefined>;
+    getAllFormInputs$: import("rxjs").Observable<import("ngx-t-forms-types").FormColumnInputs[]>;
+    inputElementEditorConfigs$: import("rxjs").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$: import("rxjs").Observable<{
+        inputConfigErrors: {
+            key: string;
+            message: string;
+        }[];
+        sectionId: string;
+        label: string;
+        columns: Array<import("ngx-t-forms-types").FormColumnInputs>;
+        inEdit?: boolean;
+        sectionIsSeen?: boolean;
+        isActive?: boolean;
+    }[]>;
+};

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

@@ -0,0 +1,75 @@
+import { ActivatedRouteSnapshot } from "@angular/router";
+import { DatabaseFormInterface, FormInterface } from 'ngx-t-forms-types';
+import { FormListSection, FormStateErrors } from 'ngx-t-forms-types';
+import { FormsStoreService } from "./forms-store.service";
+export declare function formsStoreActions(store: FormsStoreService): {
+    loadFormListSuccess: (observableOrValue: {
+        forms: DatabaseFormInterface[];
+    } | import("rxjs").Observable<{
+        forms: DatabaseFormInterface[];
+    }>) => import("rxjs").Subscription;
+    toggleFormBuilderBusy: () => void;
+    toggleLoadingForm: () => void;
+    toggleLoadingForms: (observableOrValue: {
+        loadingForms: boolean;
+    } | import("rxjs").Observable<{
+        loadingForms: boolean;
+    }>) => import("rxjs").Subscription;
+    loadFormSuccess: (observableOrValue: {
+        form: DatabaseFormInterface;
+    } | import("rxjs").Observable<{
+        form: DatabaseFormInterface;
+    }>) => import("rxjs").Subscription;
+    toggleFormBusy: (observableOrValue: {
+        formId: string;
+    } | import("rxjs").Observable<{
+        formId: string;
+    }>) => import("rxjs").Subscription;
+    archivedSuccess: (observableOrValue: {
+        formId: string;
+    } | import("rxjs").Observable<{
+        formId: string;
+    }>) => import("rxjs").Subscription;
+    setFormId: (observableOrValue: {
+        formId: string;
+    } | import("rxjs").Observable<{
+        formId: string;
+    }>) => import("rxjs").Subscription;
+    setError: (observableOrValue: {
+        error: string | undefined;
+        type: FormStateErrors;
+    } | import("rxjs").Observable<{
+        error: string | undefined;
+        type: FormStateErrors;
+    }>) => import("rxjs").Subscription;
+    handleListSectionChange: (observableOrValue: {
+        listSection: FormListSection;
+    } | import("rxjs").Observable<{
+        listSection: FormListSection;
+    }>) => import("rxjs").Subscription;
+    handleRouterStateChange: (observableOrValue: {
+        routerState: ActivatedRouteSnapshot | null;
+    } | import("rxjs").Observable<{
+        routerState: ActivatedRouteSnapshot | null;
+    }>) => import("rxjs").Subscription;
+    handleSetSubmittingForm: (observableOrValue: {
+        submittingForm: boolean;
+    } | import("rxjs").Observable<{
+        submittingForm: boolean;
+    }>) => import("rxjs").Subscription;
+    setFormInitialValues: (observableOrValue: {
+        initialFormValues: Record<string, any>;
+    } | import("rxjs").Observable<{
+        initialFormValues: Record<string, any>;
+    }>) => import("rxjs").Subscription;
+    handleEditorUpdateFormInEdit: (observableOrValue: {
+        form: FormInterface;
+    } | import("rxjs").Observable<{
+        form: FormInterface;
+    }>) => import("rxjs").Subscription;
+    setInputInEditId: (observableOrValue: {
+        inputInEdit: string | null;
+    } | import("rxjs").Observable<{
+        inputInEdit: string | null;
+    }>) => import("rxjs").Subscription;
+};