@olafvv/ngx-dynamic-form 19.0.1 → 20.1.0

package/index.d.ts

@@ -1,5 +1,563 @@
+import * as i0 from '@angular/core';
+import { WritableSignal, InputSignal, InjectionToken, Type } from '@angular/core';
+import { ValidatorFn, FormGroup, AbstractControl, FormControl, FormBuilder } from '@angular/forms';
+import { Observable } from 'rxjs';
+
+declare enum RelationActionType {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED",
+    HIDDEN = "HIDDEN",
+    VISIBLE = "VISIBLE",
+    REQUIRED = "REQUIRED",
+    OPTIONAL = "OPTIONAL"
+}
+declare enum RelationOperator {
+    AND = "AND",
+    OR = "OR"
+}
+type RelationCondition = {
+    /** Name of a field in the same form this field is depended on */
+    fieldName?: string;
+    /**
+     * Path to the related field.
+     * This must be used when working with nested FormGroups and you want to relate a field in a different group.
+     */
+    path?: string;
+    /** Method that returns true when the condition is met. The passed parameter is the value of the depended field */
+    value: (val: any) => boolean;
+};
+type DynamicFormFieldRelation = {
+    actionType: RelationActionType;
+    conditions: RelationCondition[];
+    operator?: RelationOperator;
+};
+
+type DynamicFormValidator = {
+    name: string;
+    validator: ValidatorFn;
+    message?: string;
+};
+
 /**
- * Generated bundle index. Do not edit.
+ * Base configuration object for each Dynamic Form Field.
+ * Expects a generic type describing the type of the value the control holds.
  */
-/// <amd-module name="@olafvv/ngx-dynamic-form" />
-export * from './public-api';
+type DynamicFormFieldConfig = {
+    /**
+     * Name used as FormControlName
+     * @required
+     */
+    name: string;
+    /**
+     * Whether the control has to be disabled.
+     * Default value is false.
+     * @optional
+     */
+    disabled?: boolean;
+    /**
+     * Whether the control should be hidden.
+     * Default value is false
+     * @optional
+     */
+    hidden?: boolean;
+    /**
+     * Adds an id attribute to the FormControl.
+     * When not provided, the required 'name' property is used as id
+     * @optional
+     */
+    id?: string;
+    /**
+     * Used as mat-label when provided
+     * @optional
+     */
+    label?: string | null;
+    /**
+     * Hint text underneath the FormControl
+     * @optional
+     */
+    hint?: string;
+    /**
+     * Array of Dynamic Form Validators
+     * @optional
+     */
+    validators?: DynamicFormValidator[];
+    /**
+     * Array of Dynamic Form Relations
+     * @optional
+     */
+    relations?: DynamicFormFieldRelation[];
+    /**
+     * Event name for the control to update on.
+     * This will determine when Angular is checking the validators
+     * Possible values:
+     * - `change`: on every change event on the FormControl
+     * - `blur`: on the blur event of the FormControl
+     * - `submit`: when the parent form of the FormControl is submitted
+     *
+     * Default value is 'blur'.
+     * @optional
+     */
+    updateOn?: 'submit' | 'blur' | 'change';
+    /**
+     * Sets the width of the field, based on percentages. Default value is 100.
+     * @optional
+     */
+    width?: number;
+};
+
+/**
+ * Base class for all DynamicFormFields
+ */
+declare abstract class DynamicFormFieldModel {
+    id: string;
+    width: number;
+    label: string | null;
+    name: string;
+    hint: string | null;
+    validators: DynamicFormValidator[];
+    updateOn: 'submit' | 'blur' | 'change';
+    relations: DynamicFormFieldRelation[] | null;
+    disabledChange: Observable<boolean>;
+    abstract readonly type: string;
+    private readonly disabled$;
+    private readonly $hidden;
+    constructor(config: DynamicFormFieldConfig);
+    get disabled(): boolean;
+    set disabled(disable: boolean);
+    get hidden(): boolean;
+    set hidden(hidden: boolean);
+}
+
+type DynamicFormConfig = DynamicFormFieldModel[][];
+
+declare class DynamicFormComponent {
+    group: i0.InputSignal<FormGroup<any>>;
+    formConfig: i0.InputSignal<DynamicFormConfig>;
+    /**
+     * Get the formConfig as flat array.
+     */
+    get flatFormConfig(): DynamicFormFieldModel[];
+    /**
+     * Get the current value of the form.
+     * @param includeDisabledFields Include the disabled fields of the form, is enabled by default
+     */
+    getFormValue<T = unknown>(includeDisabledFields?: boolean): T;
+    /**
+     * Provides an Observable to listen to changes of a specific field in the form.
+     *
+     * @param name Name of the field
+     * @returns Observable<unknown>
+     */
+    onControlChange(name: string): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "dynamic-form", never, { "group": { "alias": "group"; "required": true; "isSignal": true; }; "formConfig": { "alias": "formConfig"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DynamicFormFieldValueConfig<T> extends DynamicFormFieldConfig {
+    /**
+     * The value of the control.
+     * This value will change when the control is used.
+     * @optional
+     */
+    value?: T;
+    /**
+     * The default value of the control when initializing or resetting the control.
+     * @optional
+     */
+    defaultValue?: T;
+    /**
+     * A function that gets called everytime the value of the control changes.
+     * Passes the value of the control as parameter.
+     * If you don't want to get an event on every keystroke without delay, use the ReactiveFormsModule `valueChanges` Observable
+     * @optional
+     */
+    valueChanged?: (val: T | null) => any;
+}
+/**
+ * Base class for a DynamicFormField with a value
+ */
+declare abstract class DynamicFormFieldValueModel<T = unknown> extends DynamicFormFieldModel {
+    defaultValue: T | null;
+    private _value$;
+    private _valueChanged;
+    constructor(config: DynamicFormFieldValueConfig<T>);
+    get value(): T | null;
+    set value(val: T | null);
+}
+
+type DynamicOptionList<T> = DynamicFormFieldOption<T>[] | Observable<DynamicFormFieldOption<T>[]>;
+type DynamicGroupedOptionList<T> = DynamicFormFieldOptionGroup<T>[] | Observable<DynamicFormFieldOptionGroup<T>[]>;
+/**
+ * Interface for the objects inside a list of options of Dynamic FormField
+ */
+interface DynamicFormFieldOption<T> {
+    /** The text shown as label */
+    label: string;
+    /** Extra line of text shown as subtitle */
+    subTitle?: string;
+    /** The value the option holds */
+    value: T;
+}
+/**
+ * Interface for a group op options inside a Dynamic FormField (optgroup)
+ */
+interface DynamicFormFieldOptionGroup<T> {
+    name: string;
+    options: DynamicFormFieldOption<T>[];
+}
+/**
+ * Base interface for any DynamicFormFieldConfig with options (e.g. DynamicSelectConfig or DynamicAutocompleteConfig).
+ */
+interface DynamicFormFieldOptionConfig<T> extends DynamicFormFieldValueConfig<T> {
+    options?: DynamicOptionList<T>;
+    groupedOptions?: DynamicGroupedOptionList<T>;
+}
+/**
+ * Base class for any DynamicFormField with options (e.g. DynamicSelect or DynamicAutocomplete)
+ */
+declare abstract class DynamicFormFieldOptionModel<T> extends DynamicFormFieldValueModel<T> {
+    options$: Observable<DynamicFormFieldOption<T>[]>;
+    groupedOptions$: Observable<DynamicFormFieldOptionGroup<T>[]>;
+    private _options;
+    private _groupedOptions;
+    constructor(config: DynamicFormFieldOptionConfig<T>);
+    private setOptions;
+    private setGroupedOptions;
+}
+
+declare const DYNAMIC_FORM_FIELD_BUTTON_TOGGLES = "button-toggles";
+type DynamicButtonTogglesConfig = Omit<DynamicFormFieldOptionConfig<string | number | null>, 'label'> & {
+    /** Whether to allow multiple options to be selected. Default is false */
+    multiple?: boolean;
+    /** Whether the toggle group is vertical. Default is false */
+    vertical?: boolean;
+};
+declare class DynamicButtonToggles extends DynamicFormFieldOptionModel<string | number | null> {
+    multiple: boolean;
+    vertical: boolean;
+    readonly type: string;
+    constructor(config: DynamicButtonTogglesConfig);
+}
+
+declare const DYNAMIC_FORM_FIELD_BUTTON = "button";
+type OmittedProperties = 'hint' | 'validators' | 'updateOn';
+/**
+ * @TODO icon support
+ */
+type DynamicButtonConfig = Omit<DynamicFormFieldConfig, OmittedProperties> & {
+    /**
+     * Label shown inside the button
+     */
+    label: string;
+    /**
+     * Function called when the button is clicked.
+     * Provides no parameters.
+     * @returns
+     */
+    clicked: () => any;
+};
+declare class DynamicButton extends DynamicFormFieldModel {
+    label: string | null;
+    clicked: () => any;
+    readonly type = "button";
+    constructor(config: DynamicButtonConfig);
+}
+
+declare const DYNAMIC_FORM_FIELD_CHECKBOX = "checkbox";
+type DynamicCheckboxConfig = DynamicFormFieldValueConfig<boolean> & {
+    labelPosition?: 'before' | 'after';
+    indeterminate?: boolean;
+};
+declare class DynamicCheckbox extends DynamicFormFieldValueModel<boolean> {
+    labelPosition: 'before' | 'after';
+    indeterminate: boolean;
+    readonly type: string;
+    constructor(config: DynamicCheckboxConfig);
+    get checked(): boolean;
+    set checked(checked: boolean);
+    toggle(): void;
+}
+
+declare const DYNAMIC_FORM_FIELD_DATEPICKER = "datepicker";
+type DynamicDatepickerControlValue = Date | object | string | null;
+type DynamicDatepickerConfig = DynamicFormFieldValueConfig<DynamicDatepickerControlValue> & {
+    /** Maximum date selectable in the datepicker */
+    max?: DynamicDatepickerControlValue;
+    /** Minimum date selectable in the datepicker */
+    min?: DynamicDatepickerControlValue;
+    /** The initial date visible inside the datepicker when opening the picker */
+    startAt?: DynamicDatepickerControlValue;
+    /** The view the picker is initializing when opening */
+    startView?: 'month' | 'year' | 'multi-year';
+};
+declare class DynamicDatepicker extends DynamicFormFieldValueModel<DynamicDatepickerControlValue> {
+    max: DynamicDatepickerControlValue | null;
+    min: DynamicDatepickerControlValue | null;
+    startAt: DynamicDatepickerControlValue | null;
+    startView: 'month' | 'year' | 'multi-year';
+    readonly type = "datepicker";
+    constructor(config: DynamicDatepickerConfig);
+}
+
+declare const DYNAMIC_FORM_FIELD_INPUT = "input";
+type HtmlInputType = 'text' | 'number' | 'tel' | 'email' | 'password' | 'date' | 'time' | 'color';
+type DynamicInputValue = string | number | Date | null;
+type DynamicInputConfig = DynamicFormFieldValueConfig<DynamicInputValue> & {
+    inputType?: HtmlInputType;
+    placeholder?: string;
+    max?: number;
+    min?: number;
+    maxLength?: number;
+    minLength?: number;
+    step?: number;
+    pattern?: string | RegExp;
+    autocomplete?: 'on' | 'off';
+    prefix?: string;
+    hideClearIcon?: boolean;
+    showLoader?: WritableSignal<boolean>;
+};
+declare class DynamicInput extends DynamicFormFieldValueModel<DynamicInputValue> {
+    inputType: HtmlInputType;
+    placeholder: string;
+    max: number | null;
+    min: number | null;
+    maxLength: number | null;
+    minLength: number | null;
+    step: number | null;
+    pattern: string | RegExp;
+    autocomplete: 'on' | 'off';
+    prefix: string | null;
+    hideClearIcon: boolean;
+    showLoader: WritableSignal<boolean>;
+    readonly type = "input";
+    constructor(config: DynamicInputConfig);
+}
+
+declare const DYNAMIC_FORM_FIELD_RADIO_GROUP = "radio-group";
+type DynamicRadioGroupConfig = DynamicFormFieldOptionConfig<string | number | null> & {
+    /** Placement of the option label. Default is 'before' */
+    labelPosition?: 'before' | 'after';
+    /** Whether the options are shown inline (horizontally). Default is false */
+    inline?: boolean;
+};
+declare class DynamicRadioGroup extends DynamicFormFieldOptionModel<string | number | null> {
+    labelPosition: 'before' | 'after';
+    inline: boolean;
+    readonly type: string;
+    constructor(config: DynamicRadioGroupConfig);
+}
+
+declare const DYNAMIC_FORM_FIELD_READONLY = "readonly";
+type DynamicReadonlyValue = string | number | null;
+type DynamicReadonlyConfig = Omit<DynamicFormFieldValueConfig<DynamicReadonlyValue>, 'validators' | 'relations' | 'updateOn'>;
+declare class DynamicReadonly extends DynamicFormFieldValueModel<DynamicReadonlyValue> {
+    readonly type = "readonly";
+    constructor(config: DynamicReadonlyConfig);
+}
+
+declare const DYNAMIC_FORM_FIELD_SELECT = "select";
+type DynamicSelectConfig<T = string> = DynamicFormFieldOptionConfig<T> & {
+    /**
+     * Show the native dropdown instead of the Angular Material styled dropdown
+     */
+    native?: boolean;
+    /**
+     * Whether it is possible to select multiple options.
+     * Default value is false
+     */
+    multiple?: boolean;
+};
+declare class DynamicSelect<T = string> extends DynamicFormFieldOptionModel<T> {
+    native: boolean;
+    multiple: boolean;
+    readonly type = "select";
+    constructor(config: DynamicSelectConfig<T>);
+}
+
+declare const DYNAMIC_FORM_FIELD_TEXTAREA = "textarea";
+type DynamicTextareaValue = string | null;
+type DynamicTextareaConfig = DynamicFormFieldValueConfig<DynamicTextareaValue> & {
+    /**
+     * Placeholder text inside the textarea.
+     * Only visible when the field is empty and in focus.
+     */
+    placeholder?: string;
+    /**
+     * Minimum amount of characters needed in the textarea
+     */
+    minLength?: number;
+    /**
+     * Maximum amount of characters it is possible to fill in the textarea
+     */
+    maxLength?: number;
+    /**
+     * Enables or disabled the browser natie autocomplete bubble when the control is in focus.
+     * Default value is 'off'
+     */
+    autocomplete?: 'on' | 'off';
+    /**
+     * Amount of rows the textarea initializes on
+     */
+    rows?: number;
+    /**
+     * Whether the textare automatically resizes to fit its content
+     */
+    resize?: boolean;
+    /**
+     * Maximum amount of rows the textarea show resize to
+     */
+    resizeMaxRows?: number;
+};
+declare class DynamicTextarea extends DynamicFormFieldValueModel<DynamicTextareaValue> {
+    placeholder: string;
+    minLength: number | null;
+    maxLength: number | null;
+    autocomplete: 'on' | 'off';
+    rows: number;
+    resize: boolean;
+    resizeMaxRows: number | null;
+    readonly type = "textarea";
+    constructor(config: DynamicTextareaConfig);
+}
+
+interface DynamicFormField<M extends DynamicFormFieldModel = DynamicFormFieldModel> {
+    group: InputSignal<FormGroup>;
+    model: InputSignal<M>;
+}
+/**
+ * Base class for the DynamicFormField component classes
+ */
+declare abstract class DynamicFormFieldBase<M extends DynamicFormFieldModel = DynamicFormFieldModel> implements DynamicFormField<M> {
+    abstract group: InputSignal<FormGroup>;
+    abstract model: InputSignal<M>;
+    get id(): string;
+    get control(): AbstractControl;
+    get isValid(): boolean;
+    get isInvalid(): boolean;
+    resetControl(): void;
+    hasError(name: string): boolean;
+}
+
+declare class DynamicFormValidators {
+    /**
+     * Default email validator, the value of the control has to be a valid email address
+     * @param msg
+     */
+    static email(msg?: string): DynamicFormValidator;
+    /**
+     * Default min validator, the value has to be greater or equal than the the provided number
+     * @param min number
+     * @param msg
+     */
+    static min(min: number, msg?: string): DynamicFormValidator;
+    /**
+     * Default max validator, the value has to be less or equal than the the provided number
+     * @param max number
+     * @param msg
+     */
+    static max(max: number, msg?: string): DynamicFormValidator;
+    /**
+     * Default minLength validator, the value has to contain a minimum amount of characters
+     * @param min number
+     * @param msg
+     */
+    static minLength(min: number, msg?: string): DynamicFormValidator;
+    /**
+     * Default maxLength validator, the value has to contain a maximum amount of characters
+     * @param max number
+     * @param msg
+     */
+    static maxLength(max: number, msg?: string): DynamicFormValidator;
+    /**
+     * Default pattern validator, the value of the control has to match the provided pattern
+     * @param pattern: string | RegExp
+     * @param msg
+     */
+    static pattern(pattern: string | RegExp, msg?: string): DynamicFormValidator;
+    /**
+     * Default required validator, the control must contain a value
+     * @param msg
+     */
+    static required(msg?: string): DynamicFormValidator;
+    /**
+     * Default requiredTrue validator, the value of the control has to be true
+     * @param msg
+     */
+    static requiredTrue(msg?: string): DynamicFormValidator;
+}
+
+declare const DYNAMIC_FORM_FIELD_MAP: InjectionToken<Record<string, Type<DynamicFormField<any>>>>;
+
+declare class DynamicFormValidationsService {
+    /**
+     * Get all Validator Functions from the validator configuration
+     * @param validatorConfig
+     * @returns
+     */
+    getValidatorFns(validatorConfig: DynamicFormValidator[]): ValidatorFn[];
+    /**
+     * Update the validators on a FormControl based on the provided validator configuration.
+     * This will replace any existing validators on the control or removes all validators when none provided
+     * @param validatorConfig
+     * @param control
+     */
+    updateValidators(validatorConfig: DynamicFormValidator[], control: FormControl): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormValidationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicFormValidationsService>;
+}
+
+declare class DynamicFormService {
+    private customMap;
+    private fb;
+    private validatorsService;
+    constructor(customMap: Record<string, Type<DynamicFormField>>, fb: FormBuilder, validatorsService: DynamicFormValidationsService);
+    /**
+     * Check if there is a mapping provided to use custom form controls
+     * @param model
+     * @returns
+     */
+    getCustomControlComponentType(model: DynamicFormFieldModel): Type<DynamicFormField<any>> | null;
+    /**
+     * Create a FormGroup from the provided form configuration.
+     * Returns a FormGroup.
+     * @param {DynamicFormConfig} config Configuration object of a form
+     * @returns {FormGroup}
+     */
+    createFormGroup(config: DynamicFormConfig): FormGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormService, [{ optional: true; }, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicFormService>;
+}
+
+/**
+ * Transform any list to a list of DynamicFormFieldOption which is used in any Dynamic Form Field with options (e.g. DynamicSelect).
+ * Possible to provide the method with type definitions to define the provided list type `<T>` and desired option value type `<K>`:
+ *
+ * `dynamicFormService.toDynamicOptionList<T, K>(...)`
+ *
+ * Generic types:
+ *  - T = The type of the items in the provided list
+ *  - K = The type of the value inside an DynamicFormFieldOption. Default is 'string'
+ * @param arr An array of items of type T
+ * @param labelFn Callback to define the label of the options in the template
+ * @param valueFn Callback to define the value of the options. Must return a value of type K (default string)
+ * @returns
+ */
+declare function arrToDynamicFormOptions<T, K = string>(arr: T[], labelFn: (item: T) => string, valueFn: (item: T) => K): DynamicFormFieldOption<K>[];
+/**
+ * Transform any Observable of a list to a list of DynamicFormFieldOption which is used in any Dynamic Form Field with options (e.g. DynamicSelect).
+ * Possible to provide the method with type definitions to define the provided list type `<T>` and desired option value type `<K>`:
+ *
+ * `dynamicFormService.toDynamicOptionList<T, K>(...)`
+ *
+ * Generic types:
+ *  - T = The type of the items in the provided list
+ *  - K = The type of the value inside an DynamicFormFieldOption. Default is 'string'
+ * @param obs An Observable of a list of items of type T
+ * @param labelFn Callback to define the label of the options in the template
+ * @param valueFn Callback to define the value of the options. Must return a value of type K (default string)
+ * @returns
+ */
+declare function obsToDynamicFormOptions<T, K = string>(obs: Observable<T[]>, labelFn: (item: T) => string, valueFn: (item: T) => K): Observable<DynamicFormFieldOption<K>[]>;
+
+export { DYNAMIC_FORM_FIELD_BUTTON, DYNAMIC_FORM_FIELD_BUTTON_TOGGLES, DYNAMIC_FORM_FIELD_CHECKBOX, DYNAMIC_FORM_FIELD_DATEPICKER, DYNAMIC_FORM_FIELD_INPUT, DYNAMIC_FORM_FIELD_MAP, DYNAMIC_FORM_FIELD_RADIO_GROUP, DYNAMIC_FORM_FIELD_READONLY, DYNAMIC_FORM_FIELD_SELECT, DYNAMIC_FORM_FIELD_TEXTAREA, DynamicButton, DynamicButtonToggles, DynamicCheckbox, DynamicDatepicker, DynamicFormComponent, DynamicFormFieldBase, DynamicFormFieldModel, DynamicFormFieldOptionModel, DynamicFormFieldValueModel, DynamicFormService, DynamicFormValidators, DynamicInput, DynamicRadioGroup, DynamicReadonly, DynamicSelect, DynamicTextarea, RelationActionType, RelationOperator, arrToDynamicFormOptions, obsToDynamicFormOptions };
+export type { DynamicButtonConfig, DynamicButtonTogglesConfig, DynamicCheckboxConfig, DynamicDatepickerConfig, DynamicDatepickerControlValue, DynamicFormConfig, DynamicFormField, DynamicFormFieldConfig, DynamicFormFieldOption, DynamicFormFieldOptionConfig, DynamicFormFieldOptionGroup, DynamicFormFieldRelation, DynamicFormFieldValueConfig, DynamicFormValidator, DynamicGroupedOptionList, DynamicInputConfig, DynamicInputValue, DynamicOptionList, DynamicRadioGroupConfig, DynamicReadonlyConfig, DynamicReadonlyValue, DynamicSelectConfig, DynamicTextareaConfig, DynamicTextareaValue, HtmlInputType, RelationCondition };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@olafvv/ngx-dynamic-form",
-  "version": "19.0.1",
+  "version": "20.1.0",
   "peerDependencies": {
-    "@angular/common": "^19.2.10",
-    "@angular/core": "^19.2.10",
-    "@angular/forms": "^19.2.10",
-    "@angular/material": "^19.2.15",
+    "@angular/common": "^20.3.16",
+    "@angular/core": "^20.3.16",
+    "@angular/forms": "^20.3.16",
+    "@angular/material": "^20.2.14",
     "rxjs": "^7.5.0"
   },
   "dependencies": {

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

@@ -1,31 +0,0 @@
-import { EventEmitter } from '@angular/core';
-import { UntypedFormGroup } from '@angular/forms';
-import { Observable } from 'rxjs';
-import { DynamicFormFieldModel } from '../../models/classes/dynamic-form-field-model';
-import { DynamicFormFieldEvent } from '../../models/interfaces/dynamic-form-field-event.interface';
-import { DynamicFormConfig } from '../../models/types/dynamic-form-config.type';
-import * as i0 from "@angular/core";
-export declare class DynamicFormComponent {
-    group: UntypedFormGroup;
-    formConfig: DynamicFormConfig;
-    change: EventEmitter<DynamicFormFieldEvent>;
-    /**
-     * Get the formConfig as flat array.
-     */
-    get flatFormConfig(): DynamicFormFieldModel[];
-    /**
-     * Get the current value of the form.
-     * @param includeDisabledFields Include the disabled fields of the form, is enabled by default
-     */
-    getFormValue<T = unknown>(includeDisabledFields?: boolean): T;
-    /**
-     * Provides an Observable to listen to changes of a specific field in the form.
-     *
-     * @param name Name of the field
-     * @returns Observable<unknown>
-     */
-    onControlChange(name: string): Observable<unknown>;
-    onChange(event: DynamicFormFieldEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "dynamic-form", never, { "group": { "alias": "group"; "required": true; }; "formConfig": { "alias": "formConfig"; "required": true; }; }, { "change": "change"; }, never, never, true, never>;
-}

package/lib/components/dynamic-form-field/dynamic-form-field.component.d.ts

@@ -1,49 +0,0 @@
-import { EventEmitter, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';
-import { UntypedFormGroup } from '@angular/forms';
-import { DynamicFormFieldModel } from '../../models/classes/dynamic-form-field-model';
-import { DynamicFormFieldEvent } from '../../models/interfaces/dynamic-form-field-event.interface';
-import * as i0 from "@angular/core";
-export declare class DynamicFormFieldComponent implements OnInit, OnDestroy {
-    componentViewContainer: ViewContainerRef;
-    model: DynamicFormFieldModel;
-    group: UntypedFormGroup;
-    change: EventEmitter<DynamicFormFieldEvent>;
-    private readonly dynamicFormService;
-    private readonly relationService;
-    private readonly cdRef;
-    private _control;
-    private _subs;
-    /** Get the instance of a control component using the injected custom method or local method */
-    private get componentType();
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    /**
-     * Finds the instance of a control component by type
-     * @returns
-     */
-    private getControlComponentType;
-    private createFormControlComponent;
-    /**
-     * Setup all necessary subscriptions of the FormControl
-     */
-    private setSubscriptions;
-    /**
-     * Set up all relations of the current model
-     */
-    private setUpRelations;
-    /**
-     * Fired when the value changes of the control and updates the value inside the model
-     * @param value
-     */
-    private onValueChange;
-    /**
-     * Enables/disabled the control based on the provided parameter.
-     * Is fired when disabled state is changed inside the model and should not be directly used outside this component.
-     * @param disabled
-     */
-    private onDisabledChange;
-    private onChange;
-    private createDynamicFormEvent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormFieldComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormFieldComponent, "dynamic-form-field", never, { "model": { "alias": "model"; "required": false; }; "group": { "alias": "group"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
-}

package/lib/controls/button/dynamic-button.component.d.ts

@@ -1,11 +0,0 @@
-import { UntypedFormGroup } from '@angular/forms';
-import { DynamicFormFieldBase } from '../../models/classes/dynamic-form-field-base';
-import { DynamicButton } from './dynamic-button.model';
-import * as i0 from "@angular/core";
-export declare class DynamicButtonComponent extends DynamicFormFieldBase {
-    model: DynamicButton;
-    group: UntypedFormGroup;
-    onClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicButtonComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicButtonComponent, "dynamic-button", never, { "model": { "alias": "model"; "required": false; }; "group": { "alias": "group"; "required": false; }; }, {}, never, never, true, never>;
-}