@messaia/cdk 0.0.0-CDK

package/lib/form-validators/validators-function/regex-validation.function.d.ts

@@ -0,0 +1,4 @@
+import { AbstractControl } from "@angular/forms";
+import { BaseConfig } from "../models/config/base-config";
+export declare function regexValidation(configModel: BaseConfig, control: AbstractControl, regExp: RegExp, key: string): any;
+export declare function validate(config: any, control: AbstractControl, regExp: RegExp, key: string): any;

package/lib/forms/components/generic-form/generic-form.component.d.ts

@@ -0,0 +1,91 @@
+import { CdkPortal } from '@angular/cdk/portal';
+import { OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { FormFieldType } from '../../enums/form-field-type';
+import { FormFieldDefinition } from '../../models/form-field-definition';
+import { FormFieldGroup } from '../../models/form-field-group';
+import * as i0 from "@angular/core";
+/**
+ * VdEditorDirective class
+ */
+export declare class VdEditorDirective extends CdkPortal {
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdEditorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VdEditorDirective, "[vd-editor]ng-template", never, {}, {}, never>;
+}
+/**
+ * VdCodeDirective class
+ */
+export declare class VdCodeDirective extends CdkPortal {
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdCodeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VdCodeDirective, "[vd-code]ng-template", never, {}, {}, never>;
+}
+/**
+ * VdFileDirective class
+ */
+export declare class VdFileDirective extends CdkPortal {
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdFileDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VdFileDirective, "[vd-file]ng-template", never, {}, {}, never>;
+}
+/**
+ * VdCustomDirective class
+ */
+export declare class VdCustomDirective extends CdkPortal {
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdCustomDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VdCustomDirective, "[vd-custom]ng-template", never, {}, {}, never>;
+}
+export declare class VdGenericFormComponent implements OnInit {
+    /**
+     * form: FormGroup
+     */
+    formGroup: FormGroup;
+    /**
+     * fieldGroups: FormFieldGroup[]
+     */
+    fieldGroups: FormFieldGroup[];
+    /**
+     * Group name
+     */
+    groupName: string;
+    /**
+     * fieldRows: FormFieldDefinition[]
+     */
+    fieldRows: [FormFieldDefinition[]];
+    /**
+     * FormFieldType: typeof FormFieldType
+     */
+    FormFieldType: typeof FormFieldType;
+    /**
+     * Editor template
+     */
+    editorTemplate: VdEditorDirective;
+    /**
+     * Code template
+     */
+    codeTemplate: VdCodeDirective;
+    /**
+     * File template
+     */
+    fileTemplate: VdFileDirective;
+    /**
+     * Custom template
+     */
+    customTemplate: VdCustomDirective;
+    /**
+     * Filterd options for autocomplete
+     */
+    autocompleteFilteredOptions: {};
+    /**
+     * A callback method that is invoked immediately after the
+     * default change detector has checked the directive's
+     * data-bound properties for the first time,
+     * and before any of the view or content children have been checked.
+     * It is invoked only once when the directive is instantiated.
+     */
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdGenericFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VdGenericFormComponent, "vd-generic-form", never, { "formGroup": "formGroup"; "fieldGroups": "fieldGroups"; "groupName": "groupName"; }, {}, ["editorTemplate", "codeTemplate", "fileTemplate", "customTemplate"], never>;
+}

package/lib/forms/constants/constants.d.ts

@@ -0,0 +1 @@
+export declare const formFieldGroupMetadataKey: unique symbol;

package/lib/forms/directives/mat-form-field-editor.directive.d.ts

@@ -0,0 +1,82 @@
+import { Platform } from '@angular/cdk/platform';
+import { AutofillMonitor } from '@angular/cdk/text-field';
+import { DoCheck, ElementRef, EventEmitter, NgZone } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { CanUpdateErrorState, ErrorStateMatcher } from '@angular/material/core';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { EditorComponent } from '@tinymce/tinymce-angular';
+import { Subject } from 'rxjs';
+import { Editor } from 'tinymce';
+import * as i0 from "@angular/core";
+declare class EditorControlBase {
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    ngControl: NgControl;
+    /**
+     * Constructor
+     * @param _defaultErrorStateMatcher
+     * @param _parentForm
+     * @param _parentFormGroup
+     * @param ngControl
+     */
+    constructor(_defaultErrorStateMatcher: ErrorStateMatcher, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl);
+}
+export interface EditorChange {
+    textContent: string;
+    displayContent: string;
+}
+declare const _EditorInputMixinBase: import("@angular/material/core")._Constructor<CanUpdateErrorState> & import("@angular/material/core")._AbstractConstructor<CanUpdateErrorState> & typeof EditorControlBase;
+export declare class MatFormFieldEditorDirective extends _EditorInputMixinBase implements MatFormFieldControl<any>, CanUpdateErrorState, DoCheck {
+    private elementRef;
+    ngControl: NgControl;
+    private valueAccessor;
+    private platform;
+    private autofillMonitor;
+    private ngZone;
+    /**
+     * _disabled: boolean
+     */
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * _id: string
+     */
+    private _id;
+    get id(): string;
+    set id(value: string);
+    /**
+     * This input just provides the placeholder to the mat-form-field.
+     * Placeholder setup will still have to be done according to the
+     * TinyMCE placeholder plugin being used.
+     */
+    placeholder: string;
+    private _required;
+    get required(): boolean;
+    set required(value: boolean);
+    get value(): string;
+    set value(value: string);
+    editorChange: EventEmitter<EditorChange>;
+    empty: boolean;
+    focused: boolean;
+    controlType: string;
+    readonly stateChanges: Subject<void>;
+    ariaDescribedby: string | null;
+    shouldLabelFloat: boolean;
+    autofilled: boolean;
+    private uid;
+    private editor;
+    private editorElement;
+    errorStateMatcher: ErrorStateMatcher;
+    constructor(elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>, ngControl: NgControl, parentForm: NgForm, parentFormGroup: FormGroupDirective, errorStateMatcher: ErrorStateMatcher, valueAccessor: EditorComponent, platform: Platform, autofillMonitor: AutofillMonitor, ngZone: NgZone);
+    ngDoCheck(): void;
+    onEditorInit({ editor }: {
+        editor: Editor;
+    }): void;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatFormFieldEditorDirective, [null, { optional: true; self: true; }, { optional: true; }, { optional: true; }, null, { self: true; }, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatFormFieldEditorDirective, "[tinyMatFormControl]", never, { "disabled": "disabled"; "id": "id"; "placeholder": "placeholder"; "required": "required"; "value": "value"; "errorStateMatcher": "errorStateMatcher"; }, { "editorChange": "editorChange"; }, never>;
+}
+export {};

package/lib/forms/directives/mat-form-field-readonly.directive.d.ts

@@ -0,0 +1,16 @@
+import { MatFormField } from '@angular/material/form-field';
+import * as i0 from "@angular/core";
+export declare class MatFormFieldReadonlyDirective {
+    private matFormField;
+    /**
+     * Constructor
+     * @param matFormField
+     */
+    constructor(matFormField: MatFormField);
+    /**
+     * Checks if the control is readonly
+     */
+    isReadonlyInput(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatFormFieldReadonlyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatFormFieldReadonlyDirective, "mat-form-field", never, {}, {}, never>;
+}

package/lib/forms/enums/form-field-type.d.ts

@@ -0,0 +1,17 @@
+export declare enum FormFieldType {
+    Text = 0,
+    TextArea = 1,
+    Checkbox = 2,
+    Radio = 3,
+    Enum = 4,
+    Select = 5,
+    VdSelect = 6,
+    VdChips = 7,
+    Date = 8,
+    Toggle = 9,
+    Editor = 10,
+    Code = 11,
+    File = 12,
+    Autocomplete = 13,
+    Custom = 100
+}

package/lib/forms/forms.module.d.ts

@@ -0,0 +1,39 @@
+import { MatFormFieldEditorDirective } from './directives/mat-form-field-editor.directive';
+import { NativeElementInjectorDirective } from './validators/native-element-injector.directive';
+import { UniqueValidatorDirective } from './validators/unique-validator-directive';
+import * as i0 from "@angular/core";
+import * as i1 from "./validators/equal-validator.directive";
+import * as i2 from "./validators/unique-validator-directive";
+import * as i3 from "./validators/native-element-injector.directive";
+import * as i4 from "./directives/mat-form-field-readonly.directive";
+import * as i5 from "./directives/mat-form-field-editor.directive";
+import * as i6 from "./components/generic-form/generic-form.component";
+import * as i7 from "@angular/common";
+import * as i8 from "../common/common.module";
+import * as i9 from "../select/select.module";
+import * as i10 from "../chips/chips.module";
+import * as i11 from "@angular/forms";
+import * as i12 from "@angular/material/form-field";
+import * as i13 from "@angular/material/select";
+import * as i14 from "@angular/material/icon";
+import * as i15 from "@angular/material/input";
+import * as i16 from "@angular/material/datepicker";
+import * as i17 from "@angular/material/checkbox";
+import * as i18 from "@angular/material/slide-toggle";
+import * as i19 from "@angular/material/core";
+import * as i20 from "@angular/material/autocomplete";
+export { formFieldGroupMetadataKey } from './constants/constants';
+export { FormFieldType } from './enums/form-field-type';
+export { FormField, FormGroup } from './functions/decorators';
+export { getFormGroups } from './functions/functions';
+export { AbstractMatFormField } from './helpers/abstract-mat-form-field';
+export { ValueAccessorBase } from './helpers/value-accessor-base';
+export { FormFieldDefinition } from './models/form-field-definition';
+export { FormFieldGroup } from './models/form-field-group';
+export { EqualValidator } from './validators/equal-validator.directive';
+export { NativeElementInjectorDirective, UniqueValidatorDirective, MatFormFieldEditorDirective };
+export declare class VdFormsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VdFormsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VdFormsModule, [typeof i1.EqualValidator, typeof i2.UniqueValidatorDirective, typeof i3.NativeElementInjectorDirective, typeof i4.MatFormFieldReadonlyDirective, typeof i5.MatFormFieldEditorDirective, typeof i6.VdEditorDirective, typeof i6.VdCodeDirective, typeof i6.VdFileDirective, typeof i6.VdCustomDirective, typeof i6.VdGenericFormComponent], [typeof i7.CommonModule, typeof i8.VdCommonModule, typeof i9.VdSelectModule, typeof i10.VdChipsModule, typeof i11.FormsModule, typeof i11.ReactiveFormsModule, typeof i12.MatFormFieldModule, typeof i13.MatSelectModule, typeof i14.MatIconModule, typeof i15.MatInputModule, typeof i16.MatDatepickerModule, typeof i17.MatCheckboxModule, typeof i18.MatSlideToggleModule, typeof i16.MatDatepickerModule, typeof i19.MatNativeDateModule, typeof i20.MatAutocompleteModule], [typeof i1.EqualValidator, typeof i2.UniqueValidatorDirective, typeof i3.NativeElementInjectorDirective, typeof i4.MatFormFieldReadonlyDirective, typeof i5.MatFormFieldEditorDirective, typeof i6.VdEditorDirective, typeof i6.VdCodeDirective, typeof i6.VdFileDirective, typeof i6.VdCustomDirective, typeof i6.VdGenericFormComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VdFormsModule>;
+}

package/lib/forms/functions/decorators.d.ts

@@ -0,0 +1,14 @@
+import { Type } from "@angular/core";
+import { FormFieldDefinition } from "../models/form-field-definition";
+/**
+ * Property decorator to create form fields
+ * @param args
+ * @returns
+ */
+export declare function FormField(args: Partial<FormFieldDefinition>): Function;
+/**
+ * Property decorator to create form fields
+ * @param args
+ * @returns
+ */
+export declare function FormGroup<T>(type: Type<T>, header: string, name?: string): Function;

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

@@ -0,0 +1,7 @@
+import { FormFieldGroup } from "../models/form-field-group";
+/**
+ * Gets poperties decoarated with @FormField grouped by row
+ * @param origin
+ * @returns
+ */
+export declare function getFormGroups(origin: object): FormFieldGroup[];

package/lib/forms/helpers/abstract-mat-form-field.d.ts

@@ -0,0 +1,182 @@
+import { FocusMonitor } from "@angular/cdk/a11y";
+import { DoCheck, ElementRef, OnDestroy } from "@angular/core";
+import { ControlValueAccessor, FormGroupDirective, NgControl, NgForm } from "@angular/forms";
+import { ErrorStateMatcher } from "@angular/material/core";
+import { MatFormFieldControl } from "@angular/material/form-field";
+import * as i0 from "@angular/core";
+/**
+ * _AbstractMatFormField class
+ */
+declare class _AbstractMatFormField {
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    ngControl: NgControl;
+    constructor(_defaultErrorStateMatcher: ErrorStateMatcher, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl);
+}
+declare const AbstractMatFormField_base: import("@angular/material/core")._Constructor<import("@angular/material/core").CanUpdateErrorState> & import("@angular/material/core")._AbstractConstructor<import("@angular/material/core").CanUpdateErrorState> & typeof _AbstractMatFormField;
+/**
+ * AbstractMatFormField class
+ */
+export declare abstract class AbstractMatFormField<T> extends AbstractMatFormField_base implements DoCheck, OnDestroy, ControlValueAccessor, MatFormFieldControl<T> {
+    readonly controlType: string;
+    readonly ngControl: NgControl;
+    readonly _parentForm: NgForm;
+    readonly _parentFormGroup: FormGroupDirective;
+    readonly _defaultErrorStateMatcher: ErrorStateMatcher;
+    protected readonly _focusMonitor: FocusMonitor;
+    protected readonly _elementRef: ElementRef;
+    /**
+     * The value of the control.
+     */
+    protected _value: T;
+    /**
+     * Sets the value
+     */
+    set value(value: T);
+    /**
+     * Gets the value
+     */
+    get value(): T;
+    /**
+     * The placeholder for this control.
+     */
+    _placeholder: string;
+    /**
+     * Sets the placeholder
+     */
+    set placeholder(placeholder: string);
+    /**
+     * Gets the placeholder
+     */
+    get placeholder(): string;
+    /**
+     * Whether the control is required.
+     */
+    _required: boolean;
+    /**
+     * Sets the required
+     * @param required
+     */
+    set required(required: any);
+    /**
+     * Gets the required
+     */
+    get required(): any;
+    /**
+     * Readonly
+     */
+    _readonly: boolean;
+    /**
+     * Multiple select option
+     */
+    get readonly(): boolean;
+    set readonly(readonly: boolean);
+    /**
+     * Whether the control is disabled.
+     */
+    _disabled: boolean;
+    /**
+     * Gets the control is disabled.
+     * @param disabled
+     */
+    set disabled(disabled: any);
+    /**
+     * Sets the disabled.
+     * @param disabled
+     */
+    get disabled(): any;
+    /**
+     * Gets the empty value
+     */
+    get empty(): boolean;
+    /**
+     * Whether the `MatFormField` label should try to float.
+     */
+    get shouldLabelFloat(): boolean;
+    /**
+     * The element ID
+     */
+    private static nextId;
+    /**
+     * The element ID
+     */
+    id: string;
+    /**
+     * Used to indicate the IDs of the elements that describe the object.
+     */
+    describedBy: string;
+    /**
+     * Constructor
+     * @param controlType
+     * @param ngControl
+     * @param _parentForm
+     * @param _parentFormGroup
+     * @param _defaultErrorStateMatcher
+     * @param _focusMonitor
+     * @param _elementRef
+     */
+    constructor(controlType: string, ngControl: NgControl, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _defaultErrorStateMatcher: ErrorStateMatcher, _focusMonitor: FocusMonitor, _elementRef: ElementRef);
+    /**
+     * Registers a function called when the control value changes.
+     */
+    registerOnChange(fn: (_: T) => void): void;
+    /**
+     * Registers a callback function that is called by the forms API on initialization
+     * to update the form model on blur.
+     * @param fn
+     */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Writes a new value to the element.
+     * @param value
+     */
+    writeValue(value: T): void;
+    /**
+     * Sets the list of element IDs that currently describe this control.
+     * @param ids
+     */
+    setDescribedByIds(ids: string[]): void;
+    /**
+     * Whether the control is focused.
+     */
+    focused: boolean;
+    /**
+     * Whether the control is focused.
+     */
+    onBlur(): void;
+    /**
+     * Sets focus of the control
+     */
+    abstract focus(): void;
+    /**
+     * Handles a click on the control's container.
+     */
+    onContainerClick(): void;
+    /**
+     * The registered callback function called when an input
+     * event occurs on the input element.
+     */
+    protected onChange?: (value: T) => void;
+    /**
+     * The registered callback function called when a blur
+     * event occurs on the input element.
+     */
+    protected onTouched?: () => void;
+    /**
+     * A callback method that performs change-detection, invoked
+     * after the default change-detector runs.
+     * See `KeyValueDiffers` and `IterableDiffers` for implementing
+     * custom change checking for collections.
+     *
+     */
+    ngDoCheck(): void;
+    /**
+     * A lifecycle method called before the directive's instance
+     * is destroyed. For internal use only.
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractMatFormField<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractMatFormField<any>, never, never, { "placeholder": "placeholder"; "required": "required"; "readonly": "readonly"; "disabled": "disabled"; }, {}, never>;
+}
+export {};

package/lib/forms/helpers/value-accessor-base.d.ts

@@ -0,0 +1,92 @@
+import { OnDestroy } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ValueAccessorBase<T> extends MatFormFieldControl<any> implements ControlValueAccessor, OnDestroy {
+    /**
+     * Inner model value
+     */
+    protected innerValue: T;
+    private changed;
+    private touched;
+    /**
+     * Because the <mat-form-field> uses the OnPush change detection strategy, we need
+     * to let it know when something happens in the form field control that may require
+     * the form field to run change detection. We do this via the stateChanges property.
+     * So far the only thing the form field needs to know about is when the value changes.
+     * We'll need to emit on the stateChanges stream when that happens, and as we continue
+     * flushing out these properties we'll likely find more places we need to emit. We
+     * should also make sure to complete stateChanges when our component is destroyed.
+     */
+    stateChanges: Subject<void>;
+    /**
+     * This property allows us to tell the <mat-form-field> what to use as a placeholder.
+     */
+    private _placeholder;
+    /**
+     * This property is used to indicate whether the input is required.
+     */
+    private _required;
+    /**
+     * This property tells the form field when it should be in the disabled state.
+     */
+    private _disabled;
+    /**
+     * This property allows the form field control to specify the @angular/forms control
+     * that is bound to this component. Since we haven't set up our component to act as
+     * a ControlValueAccessor, we'll just set this to null in our component.
+     */
+    ngControl: any;
+    /**
+     * //TODO ???
+     */
+    touch(): void;
+    /**
+     * Writes a new value to the element.
+     *
+     * This method will be called by the forms API to write to the view when programmatic
+     * (model -> view) changes are requested.
+     *
+     * Example implementation of `writeValue`:
+     *
+     * ```ts
+     * writeValue(value: any): void {
+     *   this._renderer.setProperty(this._elementRef.nativeElement, 'value', value);
+     * }
+     * ```
+     */
+    writeValue(value: T): void;
+    /**
+     * From ControlValueAccessor interface
+     * @param fn
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * From ControlValueAccessor interface
+     * @param fn
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * This method is used by the <mat-form-field> to specify the IDs that
+     * should be used for the aria-describedby attribute of your component.
+     * The method has one parameter, the list of IDs, we just need to apply
+     *  the given IDs to our host element.
+     */
+    describedBy: string;
+    setDescribedByIds(ids: string[]): void;
+    /**
+     * This method will be called when the form field is clicked on.
+     * It allows the component to hook in and handle that click however it wants.
+     * The method has one parameter, the MouseEvent for the click. In our case we'll
+     * just focus the first <input> if the user isn't about to click an <input> anyways.
+     * @param event
+     */
+    onContainerClick(event: MouseEvent): void;
+    /**
+     * Lifecycle hook that is called when a directive, pipe or service is destroyed.
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValueAccessorBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ValueAccessorBase<any>, never, never, {}, {}, never>;
+}

package/lib/forms/models/form-field-definition.d.ts

@@ -0,0 +1,39 @@
+import { FormFieldType } from "../enums/form-field-type";
+export declare class FormFieldDefinition {
+    row: number;
+    groupName?: string;
+    groupHeader?: string;
+    name?: string;
+    header?: string;
+    hint?: string;
+    type?: FormFieldType;
+    inputType?: string;
+    enumType?: any;
+    endpoint?: string;
+    searchField?: string;
+    projection?: string;
+    multiple?: boolean;
+    optionValue?: string;
+    optionText?: string;
+    chipText?: string;
+    chipTemplate?: Function;
+    autocompleteText?: string;
+    autocompleteTemplate?: Function;
+    options?: {
+        id: any;
+        name: string;
+    }[];
+    filePath?: string;
+    isPublicFile?: boolean;
+    fileExtensions?: string[];
+    flex?: number;
+    rows?: number;
+    minLength?: number;
+    maxLength?: number;
+    hide?: Function;
+    /**
+     * constructor
+     * @param init
+     */
+    constructor(init?: Partial<FormFieldDefinition>);
+}

package/lib/forms/models/form-field-group.d.ts

@@ -0,0 +1,12 @@
+import { FormFieldDefinition } from "./form-field-definition";
+export declare class FormFieldGroup {
+    name: string;
+    header?: string;
+    fields: FormFieldDefinition[];
+    groups: [FormFieldDefinition[]];
+    /**
+     * constructor
+     * @param init
+     */
+    constructor(init?: Partial<FormFieldGroup>);
+}

package/lib/forms/public_api.d.ts

@@ -0,0 +1,3 @@
+export * from './components/generic-form/generic-form.component';
+export * from './directives/mat-form-field-readonly.directive';
+export * from './forms.module';

package/lib/forms/validators/equal-validator.directive.d.ts

@@ -0,0 +1,20 @@
+import { AbstractControl, Validator } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class EqualValidator implements Validator {
+    validateEqual: string;
+    reverse: string;
+    constructor(validateEqual: string, reverse: string);
+    /**
+     * Is reverse
+     */
+    private get isReverse();
+    /**
+     * Checks the equality of the values
+     * @param c
+     */
+    validate(c: AbstractControl): {
+        [key: string]: any;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<EqualValidator, [{ attribute: "validateEqual"; }, { attribute: "reverse"; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EqualValidator, "[validateEqual][formControlName],[validateEqual][formControl],[validateEqual][ngModel]", never, {}, {}, never>;
+}

package/lib/forms/validators/native-element-injector.directive.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef } from "@angular/core";
+import { NgControl, NgModel } from "@angular/forms";
+import * as i0 from "@angular/core";
+export declare class NativeElementInjectorDirective {
+    private el;
+    private control;
+    private model;
+    /**
+     * Constructor
+     * @param el
+     * @param control
+     * @param model
+     */
+    constructor(el: ElementRef, control: NgControl, model: NgModel);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NativeElementInjectorDirective, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NativeElementInjectorDirective, "[ngModel]", never, {}, {}, never>;
+}