ngx-t-forms 0.0.1

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

@@ -0,0 +1,60 @@
+import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { MenuCloseReason } from '@angular/material/menu';
+import { ElementTypes, FormControlCustomValidatorsInterface, IMultiple } from 'ngx-t-forms-types';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { NgControl } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import { IConfigElementError } from '../../t-dynamic-data-edit.component';
+import * as i0 from "@angular/core";
+export declare class ValidatorsConfigComponent implements OnInit, MatFormFieldControl<FormControlCustomValidatorsInterface[]> {
+    ngControl: NgControl;
+    private _elementRef;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    id: string;
+    placeholder: string;
+    constructor(ngControl: NgControl, _elementRef: ElementRef<HTMLElement>);
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    required: boolean;
+    disabled: boolean;
+    get errorState(): boolean;
+    controlType?: string | undefined;
+    autofilled?: boolean | undefined;
+    userAriaDescribedBy?: string | undefined;
+    disableAutomaticLabeling?: boolean | undefined;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    errors: IConfigElementError[] | undefined;
+    touched: boolean;
+    onTouched: () => void;
+    markAsTouched(): void;
+    mapToData: FormColumnInputs | undefined;
+    value: (FormControlCustomValidatorsInterface)[];
+    formInputs: Array<FormColumnInputs>;
+    valueChanged: EventEmitter<any>;
+    ngOnInit(): void;
+    edit: FormControlCustomValidatorsInterface | undefined;
+    menuClosed(event: MenuCloseReason): void;
+    showVariables: boolean;
+    editV(validator: string | FormControlCustomValidatorsInterface): void;
+    remove(validator: FormControlCustomValidatorsInterface | string): void;
+    search: string;
+    getInputIcon(element: ElementTypes): string;
+    selectInput(inputId: string): void;
+    addVariable(event: any): void;
+    getMultipleFormInputs(input: IMultiple): FormColumnInputs[] | undefined;
+    returnExpression(): string | undefined;
+    addValidator(): void;
+    onTextChange(event: Event, key: string): void;
+    saveVariable(event: any): void;
+    removeObserved(event: any, item: {
+        inputId: string;
+        variable: string;
+    }): void;
+    isFormControlCustomValidator(validator: string | FormControlCustomValidatorsInterface): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorsConfigComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ValidatorsConfigComponent, "app-validators-config", never, { "errors": { "alias": "errors"; "required": false; }; "mapToData": { "alias": "mapToData"; "required": false; }; "value": { "alias": "value"; "required": false; }; "formInputs": { "alias": "formInputs"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}

package/lib/components/t-dynamic-data-edit/functions/testData.d.ts

@@ -0,0 +1,2 @@
+import { ConfigurationValidTestInterface } from 'ngx-t-forms-types';
+export declare function testAgainstItem(test: ConfigurationValidTestInterface, item: any): boolean;

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

@@ -0,0 +1,48 @@
+import { EventEmitter, NgZone, OnDestroy } from '@angular/core';
+import { BlurHandleTypes, ElementEditorInnerSectionElementInterface, ElementEditorTypes, IGetTreeResponse, IWorkflowOption } from "ngx-t-forms-types";
+import { Observable } from 'rxjs';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export interface IConfigElementError {
+    key: string;
+    message: string;
+}
+export 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: Array<FormColumnInputs> | undefined;
+    set data(data: any);
+    validationErrors: IConfigElementError[] | null;
+    valueChange: EventEmitter<unknown>;
+    blur: EventEmitter<any>;
+    editorConfigValue: import("@angular/core").Signal<ElementEditorInnerSectionElementInterface | undefined>;
+    dataValue: import("@angular/core").Signal<any>;
+    get getMscoaTree(): Observable<IGetTreeResponse> | undefined;
+    get getWorkflowOptions(): Observable<IWorkflowOption[]> | undefined;
+    value: import("@angular/core").Signal<any>;
+    dataOptions: import("@angular/core").Signal<any>;
+    disabled: import("@angular/core").Signal<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;
+    inputHasBlurFunction: import("@angular/core").Signal<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;
+    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>;
+}

package/lib/components/t-dynamic-data-view/t-dynamic-data-view.component.d.ts

@@ -0,0 +1,14 @@
+import { SimpleChanges } from '@angular/core';
+import { TreeComponent } from '../t-dynamic-data-edit/elements/api-value-access-rules/functions/convertDataToTree';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/lib/components/t-form-input/elements/Geo-location-form-input/elements/geo-location-form-input/geo-location-form-input.component.d.ts

@@ -0,0 +1,18 @@
+import { ElementRef } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { FormBuilderFunctions } from "ngx-t-forms-types";
+import { BaseCustomInput } from '../../../../../../services/core/t-input-controller/functions/baseCustomInput';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class GeoLocationFormInputComponent extends BaseCustomInput<GeolocationPosition | null> {
+    constructor(ngControl: NgControl, elementRef: ElementRef<HTMLElement>);
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    formBuilderFunctions: FormBuilderFunctions | undefined;
+    inputConfig: FormColumnInputs | undefined;
+    isLoading: boolean;
+    error: boolean;
+    getLocation(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeoLocationFormInputComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GeoLocationFormInputComponent, "lib-geo-location-form-input", never, { "formBuilderFunctions": { "alias": "formBuilderFunctions"; "required": false; }; "inputConfig": { "alias": "inputConfig"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/Geo-location-form-input/functions/getGeoLocation.d.ts

@@ -0,0 +1,2 @@
+declare const getGeoLocation: (options?: PositionOptions) => Promise<GeolocationPosition>;
+export default getGeoLocation;

package/lib/components/t-form-input/elements/Geo-location-form-input/geo-location.component.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FormBuilderFunctions } from "ngx-t-forms-types";
+import { FormColumnInputs } from "ngx-t-forms-types";
+import * as i0 from "@angular/core";
+export declare class GeoLocationComponent {
+    inputConfig: FormColumnInputs;
+    formGroup: FormGroup;
+    editorMode: boolean;
+    formBuilderFunctions: FormBuilderFunctions | undefined;
+    valueChange: EventEmitter<any>;
+    changed($event: any): void;
+    get errorMessage(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeoLocationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GeoLocationComponent, "lib-geo-location", 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/elements/auto-complete-input-element/auto-complete-input-element.component.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FormColumnInputs } from "ngx-t-forms-types";
+import * as i0 from "@angular/core";
+export declare class AutoCompleteInputElementComponent {
+    inputConfig: FormColumnInputs;
+    formGroup: FormGroup;
+    options: any;
+    valueChange: EventEmitter<any>;
+    changed($event: any): void;
+    get errorMessage(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoCompleteInputElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AutoCompleteInputElementComponent, "lib-auto-complete-input-element", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,17 @@
+import { EventEmitter } from '@angular/core';
+import { FormGroup, FormControl } from '@angular/forms';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class BasicInputInputElementComponent {
+    inputConfig: FormColumnInputs;
+    formGroup: FormGroup;
+    valueChange: EventEmitter<any>;
+    get formControl(): FormControl<any>;
+    changed($event: any): void;
+    passwordStrengthColor(formControlName: string): "var(--ion-color-success)" | "var(--ion-color-warning)" | "var(--ion-color-danger)";
+    checkPasswordStrength(formControlName: string): "strong" | "medium" | "weak";
+    get errorMessage(): string | undefined;
+    get hasError(): boolean | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BasicInputInputElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BasicInputInputElementComponent, "lib-basic-input-input-element", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/basic-input-input-element/core/input-custom/input-custom.component.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { BaseCustomInput } from '../../../../../../services/core/t-input-controller/functions/baseCustomInput';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class InputCustomComponent extends BaseCustomInput<string | number | Date> implements OnInit {
+    inputConfig: FormColumnInputs | undefined;
+    constructor(ngControl: NgControl, elementRef: ElementRef<HTMLElement>);
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    private readonly debounceTime;
+    private valueSubject;
+    ngOnInit(): void;
+    onInputChange($event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputCustomComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputCustomComponent, "lib-input-custom", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/date-picker-input-element/date-picker-input-element.component.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { MatDatepickerInputEvent } from '@angular/material/datepicker';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class DatePickerInputElementComponent {
+    inputConfig: FormColumnInputs;
+    formGroup: FormGroup;
+    valueChange: EventEmitter<any>;
+    changed(event: MatDatepickerInputEvent<any, any>): void;
+    get errorMessage(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerInputElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatePickerInputElementComponent, "lib-date-picker-input-element", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/date-range-picker-input-element/date-range-picker-input-element.component.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { DateRange, MatDatepickerInputEvent } from '@angular/material/datepicker';
+import { FormColumnInputs } from "ngx-t-forms-types";
+import * as i0 from "@angular/core";
+export declare class DateRangePickerInputElementComponent {
+    inputConfig: FormColumnInputs;
+    formGroup: FormGroup;
+    valueChange: EventEmitter<any>;
+    get errorMessage(): string | undefined;
+    dateChanged(event: MatDatepickerInputEvent<any, DateRange<any>>, formControlName: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangePickerInputElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangePickerInputElementComponent, "lib-date-range-picker-input-element", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/editor-input-element/core/editor-js-input/editor-js-input.component.d.ts

@@ -0,0 +1,18 @@
+import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import { BaseCustomInput } from '../../../../../../services/core/t-input-controller/functions/baseCustomInput';
+import { NgControl } from '@angular/forms';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import EditorJS, { OutputData } from '@editorjs/editorjs';
+import * as i0 from "@angular/core";
+export declare class EditorJsInputComponent extends BaseCustomInput<OutputData | undefined> implements AfterViewInit, OnDestroy {
+    editor: EditorJS | undefined;
+    inputConfig: FormColumnInputs;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    constructor(ngControl: NgControl, elementRef: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    contentChangedSaveValue(): Promise<void>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorJsInputComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorJsInputComponent, "lib-editor-js-input", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/editor-input-element/core/form-input-rich-text-editor/config.d.ts

@@ -0,0 +1,9 @@
+import { EditorConfig, OutputData } from "@editorjs/editorjs";
+export interface EditorJsPayload {
+    holderId: string;
+    imageFetchEndpoint: string;
+    imageUploadEndpoint: string;
+    onChangeFn: () => void;
+    data: OutputData | undefined;
+}
+export declare const editorConfig: (payload: EditorJsPayload) => EditorConfig;

package/lib/components/t-form-input/elements/editor-input-element/core/form-input-rich-text-editor/form-input-rich-text-editor.component.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef } from '@angular/core';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { BaseCustomInput } from '../../../../../../services/core/t-input-controller/functions/baseCustomInput';
+import { NgControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class FormInputRichTextEditorComponent extends BaseCustomInput<string | null> {
+    constructor(ngControl: NgControl, elementRef: ElementRef<HTMLElement>);
+    inputConfig: FormColumnInputs;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    editorChanged(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormInputRichTextEditorComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormInputRichTextEditorComponent, "app-form-input-rich-text-editor", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/editor-input-element/core/form-input-rich-text-editor/sync-editor/sync-editor.component.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SyncEditorComponent {
+    readonly: boolean;
+    initialData: any;
+    editorData: EventEmitter<any>;
+    editorValueChanged(e: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SyncEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SyncEditorComponent, "app-sync-editor", never, { "readonly": { "alias": "readonly"; "required": false; }; "initialData": { "alias": "initialData"; "required": false; }; }, { "editorData": "editorData"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,14 @@
+import { EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FormColumnInputs } from "ngx-t-forms-types";
+import * as i0 from "@angular/core";
+export declare class EditorInputElementComponent {
+    inputConfig: FormColumnInputs;
+    formGroup: FormGroup;
+    valueChange: EventEmitter<any>;
+    changed($event: any): void;
+    constructor();
+    get errorMessage(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorInputElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorInputElementComponent, "lib-editor-input-element", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/file-upload-input-element/core/file-uploader/camera-functions.d.ts

@@ -0,0 +1,3 @@
+import { AbstractControl, ValidationErrors } from "@angular/forms";
+export declare function setupDevices(cameraCallback: (stream: MediaStream) => any): Promise<any>;
+export declare function fileUploaderValidator(control: AbstractControl): ValidationErrors | null;

package/lib/components/t-form-input/elements/file-upload-input-element/core/file-uploader/file-uploader.component.d.ts

@@ -0,0 +1,30 @@
+import { ElementRef } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { FileUploadInputValueInterface } from "ngx-t-forms-types";
+import { BaseCustomInput } from '../../../../../../services/core/t-input-controller/functions/baseCustomInput';
+import * as i0 from "@angular/core";
+export declare class FileUploaderComponent extends BaseCustomInput<FileUploadInputValueInterface | object | null> {
+    constructor(ngControl: NgControl, elementRef: ElementRef<HTMLElement>);
+    uploader: ElementRef<HTMLInputElement>;
+    inputConfig: FormColumnInputs | undefined;
+    get value(): FileUploadInputValueInterface | object | null;
+    set value(file: FileUploadInputValueInterface | object | null);
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    onContainerClick(event: MouseEvent): void;
+    triggerUploader(): void;
+    fileName: string;
+    loading: Number;
+    onFileSelected(event: Event): void;
+    assignFile(file: File): void;
+    returnPreview(): string | ArrayBuffer | null;
+    uploadType(): any;
+    dragOver: boolean;
+    onDragOver(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    clearFile(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploaderComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploaderComponent, "app-file-uploader", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/file-upload-input-element/file-upload-input-element.component.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '@angular/core';
+import { FormGroup, ValidationErrors } from '@angular/forms';
+import { FormColumnInputs } from "ngx-t-forms-types";
+import * as i0 from "@angular/core";
+export declare class FileUploadInputElementComponent {
+    inputConfig: FormColumnInputs;
+    formGroup: FormGroup;
+    valueChange: EventEmitter<any>;
+    changed($event: any): void;
+    getErrors(): ValidationErrors | null | undefined;
+    get errorMessage(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadInputElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploadInputElementComponent, "lib-file-upload-input-element", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/image-capture-input-element/core/camera-capture/camera-capture.component.d.ts

@@ -0,0 +1,28 @@
+import { ElementRef } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { FileUploadInputValueInterface } from "ngx-t-forms-types";
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { BaseCustomInput } from '../../../../../../services/core/t-input-controller/functions/baseCustomInput';
+import * as i0 from "@angular/core";
+export declare class CameraCaptureComponent extends BaseCustomInput<FileUploadInputValueInterface | object | null> {
+    constructor(ngControl: NgControl, elementRef: ElementRef<HTMLElement>);
+    video: ElementRef;
+    canvas: ElementRef;
+    inputConfig: FormColumnInputs;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    WIDTH: number;
+    HEIGHT: number;
+    captures: string[];
+    isCaptured: boolean;
+    ngOnInit(): void;
+    recapture(): void;
+    setup: (stream: MediaStream) => any;
+    touch(event: any): void;
+    videoMode: boolean;
+    capture(): void;
+    stopVideo(): void;
+    drawImageToCanvas(image: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CameraCaptureComponent, [{ optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CameraCaptureComponent, "app-camera-capture", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/image-capture-input-element/image-capture-input-element.component.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FormColumnInputs } from "ngx-t-forms-types";
+import * as i0 from "@angular/core";
+export declare class ImageCaptureInputElementComponent {
+    inputConfig: FormColumnInputs;
+    formGroup: FormGroup;
+    valueChange: EventEmitter<any>;
+    changed($event: any): void;
+    get errorMessage(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageCaptureInputElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageCaptureInputElementComponent, "lib-image-capture-input-element", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/t-form-input/elements/mscoa-form-input/elements/account-value/account-value.component.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { IMSCOAAccount } from "ngx-t-forms-types";
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export declare class AccountValueComponent {
+    mscoaAccount: IMSCOAAccount | undefined;
+    accountInputs: FormColumnInputs[];
+    userCanClearAccount: boolean;
+    clearSelectedAccount: EventEmitter<void>;
+    updateAccount: EventEmitter<IMSCOAAccount>;
+    get accountDetails(): ({
+        label: string;
+        value: string | {
+            $oid: string;
+        } | {
+            $date: string;
+        };
+        input: boolean;
+    } | {
+        label: string;
+        value: string | {
+            $oid: string;
+        } | {
+            $date: string;
+        } | {
+            $date: string;
+        } | null | undefined;
+        formControlName: string;
+        input: boolean;
+    })[];
+    clearAccount(): void;
+    readonly dialog: MatDialog;
+    openValueEdit(inpu: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountValueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccountValueComponent, "app-account-value", never, { "mscoaAccount": { "alias": "mscoaAccount"; "required": false; }; "accountInputs": { "alias": "accountInputs"; "required": false; }; "userCanClearAccount": { "alias": "userCanClearAccount"; "required": false; }; }, { "clearSelectedAccount": "clearSelectedAccount"; "updateAccount": "updateAccount"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,93 @@
+import { OnInit, OnDestroy, EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+import { MatDialog } from '@angular/material/dialog';
+import { IMSCOAAccount, IMscoaInputConfig, ITableScoaSelectionRow, MscoaSegmentValue } from "ngx-t-forms-types";
+import { MscoaComponentStore } from '../../store/mscoa-component-store.service';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import { FormBuilderFunctions } from "ngx-t-forms-types";
+import * as i0 from "@angular/core";
+export declare class MscoaChartComponent implements OnInit, OnDestroy {
+    private store;
+    selectAccountTreeKeys$: Observable<{
+        segment: string | undefined;
+        singleSelect: boolean;
+        segmentTree: import("ngx-t-forms-types").MscoaAccountTree;
+        inputs: import("ngx-t-forms-types/dist/interfaces/formInput/IMscoaAccount").MscoaInnerInput[];
+        segmentValue: {
+            debit: IMSCOAAccount | undefined;
+            credit: IMSCOAAccount | undefined;
+        } | undefined;
+    }[]>;
+    selectMscoaLoadingTree$: Observable<boolean>;
+    table$: Observable<{
+        segment: string | undefined;
+        singleSelect: boolean;
+        segmentTree: import("ngx-t-forms-types").MscoaAccountTree;
+        inputs: import("ngx-t-forms-types/dist/interfaces/formInput/IMscoaAccount").MscoaInnerInput[];
+        segmentValue: {
+            debit: IMSCOAAccount | undefined;
+            credit: IMSCOAAccount | undefined;
+        } | undefined;
+        accountInputs: import("ngx-t-forms-types/dist/interfaces/formInput/IMscoaAccount").MscoaInnerInput[];
+        input: import("ngx-t-forms-types/dist/interfaces/formInput/IMscoaAccount").MscoaInnerInput | undefined;
+        debit: string | IMSCOAAccount | undefined;
+        credit: string | IMSCOAAccount | undefined;
+    }[]>;
+    segmentValues$: Observable<MscoaSegmentValue>;
+    initiated$: Observable<boolean>;
+    private destroy$;
+    _formBuilderFunctions: FormBuilderFunctions | undefined;
+    constructor(store: MscoaComponentStore);
+    set formBuilderFunctions(func: FormBuilderFunctions | undefined);
+    get formBuilderFunctions(): FormBuilderFunctions | undefined;
+    set segmentValues(segmentValues: MscoaSegmentValue | null);
+    readonly: boolean;
+    set config(config: IMscoaInputConfig | undefined | null);
+    segmentValuesChanged: EventEmitter<MscoaSegmentValue>;
+    interaction: EventEmitter<string>;
+    readonly dialog: MatDialog;
+    ngOnInit(): void;
+    segmentChange(activeSegment: string): void;
+    loadMscoa(functions: FormBuilderFunctions | undefined): void;
+    ngOnDestroy(): void;
+    accountNumberSelected(account: IMSCOAAccount | undefined, segment: string, accountType?: "debit" | "credit"): void;
+    get hasMultiSelect$(): Observable<boolean>;
+    get cols$(): Observable<string[]>;
+    editSelection: ITableScoaSelectionRow | any;
+    activeColumn: string | undefined;
+    selectAccount(row: ITableScoaSelectionRow | undefined, col: string | undefined): void;
+    openScoaSelection(): void;
+    openInput(input: FormColumnInputs): void;
+    onClick(): void;
+    viewData$: Observable<{
+        loading: boolean;
+        accountTreeKeys: {
+            segment: string | undefined;
+            singleSelect: boolean;
+            segmentTree: import("ngx-t-forms-types").MscoaAccountTree;
+            inputs: import("ngx-t-forms-types/dist/interfaces/formInput/IMscoaAccount").MscoaInnerInput[];
+            segmentValue: {
+                debit: IMSCOAAccount | undefined;
+                credit: IMSCOAAccount | undefined;
+            } | undefined;
+        }[];
+        tableData: {
+            segment: string | undefined;
+            singleSelect: boolean;
+            segmentTree: import("ngx-t-forms-types").MscoaAccountTree;
+            inputs: import("ngx-t-forms-types/dist/interfaces/formInput/IMscoaAccount").MscoaInnerInput[];
+            segmentValue: {
+                debit: IMSCOAAccount | undefined;
+                credit: IMSCOAAccount | undefined;
+            } | undefined;
+            accountInputs: import("ngx-t-forms-types/dist/interfaces/formInput/IMscoaAccount").MscoaInnerInput[];
+            input: import("ngx-t-forms-types/dist/interfaces/formInput/IMscoaAccount").MscoaInnerInput | undefined;
+            debit: string | IMSCOAAccount | undefined;
+            credit: string | IMSCOAAccount | undefined;
+        }[];
+        cols: string[];
+        hasMultiSelect: boolean;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MscoaChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MscoaChartComponent, "app-mscoa-chart", never, { "formBuilderFunctions": { "alias": "formBuilderFunctions"; "required": false; }; "segmentValues": { "alias": "segmentValues"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "segmentValuesChanged": "segmentValuesChanged"; "interaction": "interaction"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,62 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { MatTreeFlatDataSource } from '@angular/material/tree';
+import { MatDialogRef } from '@angular/material/dialog';
+import { IIncludedSegmentConfig, IMSCOAAccount, MscoaAccountTree } from "ngx-t-forms-types";
+import { ObjectTreeFlatNode, ObjectTreeNode } from '../../../../../t-dynamic-data-edit/elements/api-value-access-rules/functions/convertDataToTree';
+import { FormColumnInputs } from 'ngx-t-forms-types';
+import * as i0 from "@angular/core";
+export interface IMscoaComputationComponentData {
+    data: MscoaAccountTree;
+    segment: string;
+    value: IMSCOAAccount | undefined;
+    accountInputs: FormColumnInputs[];
+    activeColumn: string | undefined;
+    segmentConfig: IIncludedSegmentConfig | undefined;
+    readonly: boolean;
+    getSCOAAccount: (account: string) => Observable<{
+        accounts: IMSCOAAccount[];
+    }>;
+}
+export declare class MscoaComputationComponent implements OnInit, OnDestroy {
+    dialogRef: MatDialogRef<MscoaComputationComponent>;
+    dataInjected: IMscoaComputationComponentData;
+    data: MscoaAccountTree | undefined;
+    segment: string | undefined;
+    value: IMSCOAAccount | undefined;
+    accountInputs: FormColumnInputs[];
+    activeColumn: string | undefined;
+    readonly: boolean;
+    segmentConfig: IIncludedSegmentConfig | undefined;
+    private destroy$;
+    treeControl: FlatTreeControl<ObjectTreeFlatNode>;
+    private treeFlattener;
+    dataSource: MatTreeFlatDataSource<ObjectTreeNode, ObjectTreeFlatNode>;
+    constructor(dialogRef: MatDialogRef<MscoaComputationComponent>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    hasChild: (_: number, node: ObjectTreeFlatNode) => boolean;
+    private transformer;
+    isActivePathOrParent(path: string[]): boolean;
+    toggleNode(node: ObjectTreeFlatNode): void;
+    private collapseSiblings;
+    private getParentNode;
+    _selected: ObjectTreeFlatNode | undefined;
+    selectNode(node: ObjectTreeFlatNode): void;
+    searchAccount: any[];
+    searchingAccounts: boolean;
+    account: string | undefined;
+    getSelectedAccounts(): void;
+    cancel(): void;
+    saveAccount(): void;
+    closeAndPassData(account: IMSCOAAccount | undefined): void;
+    _selectedAccount: IMSCOAAccount | null;
+    selectAccount(account: IMSCOAAccount | null): void;
+    clearSelectedAccount(): void;
+    get saveSelection(): boolean;
+    updateAccount(account: IMSCOAAccount): void;
+    get userCanClearAccount(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MscoaComputationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MscoaComputationComponent, "app-mscoa-computation", never, {}, {}, never, never, true, never>;
+}