ngx-material-entity 0.1.0

package/classes/entity-service.class.d.ts

@@ -0,0 +1,56 @@
+import { Entity } from './entity-model.class';
+import { HttpClient } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+/**
+ * A generic EntityService class.
+ * Offers basic CRUD-functionality.
+ * You should create a service for every Entity you have.
+ * If you extend from this you need to make sure that the extended Service can be injected.
+ */
+export declare abstract class EntityService<EntityType extends Entity> {
+    private readonly http;
+    /**
+     * The base url used for api requests. If u want to have more control over this,
+     * you can override the create, read, update and delete methods.
+     * @create Sends a POST-Request to baseUrl
+     * @read Sends a GET-Request to baseUrl
+     * @update Sends a PATCH-Request to baseUrl/{id}
+     * @delete Sends a DEL-Request to baseUrl/{id}
+     */
+    abstract readonly baseUrl: string;
+    /**
+     * a subject of all the entity values.
+     * Can be subscribed to when you want to do a specific thing whenever the entities change.
+     */
+    readonly entitiesSubject: BehaviorSubject<EntityType[]>;
+    /**
+     * gets the entities in an array from the internal entitiesSubject
+     */
+    get entities(): EntityType[];
+    constructor(http: HttpClient);
+    /**
+     * Creates a new Entity and pushes it to the entities array
+     * @param entity The data of the entity to create.
+     * All values that should be omitted will be removed from it inside this method.
+     * @returns A Promise of the created entity
+     */
+    create(entity: EntityType): Promise<EntityType>;
+    /**
+     * Gets all existing entities and pushes them to the entites array
+     * @returns A Promise of all received Entities
+     */
+    read(): Promise<EntityType[]>;
+    /**
+     * Updates a specific Entity
+     * @param entity The updated Entity
+     * All values that should be omitted will be removed from it inside this method.
+     * @param entityPriorChanges The current Entity.
+     * It Is used to get changed values and only update them instead of sending the whole entity data
+     */
+    update(entity: EntityType, entityPriorChanges: EntityType): Promise<void>;
+    /**
+     * Method to delete a specific Entity
+     * @param id The id of the element to delete
+     */
+    delete(id: string): Promise<void>;
+}

package/classes/entity-utilities.class.d.ts

@@ -0,0 +1,95 @@
+import { DecoratorType, DecoratorTypes } from '../decorators/base/decorator-types.enum';
+import { Entity } from './entity-model.class';
+/**
+ * Contains HelperMethods around handling Entities and their property-metadata
+ */
+export declare abstract class EntityUtilities {
+    /**
+     * Gets the properties to omit when updating the entity
+     * @returns The properties which should be left out for updating a new Entity
+     */
+    static getOmitForUpdate<EntityType extends Entity>(entity: EntityType): (keyof EntityType)[];
+    /**
+     * Gets the properties to omit when creating new entities
+     * @returns The properties which should be left out for creating a new Entity
+     */
+    static getOmitForCreate<EntityType extends Entity>(entity: EntityType): (keyof EntityType)[];
+    /**
+     * Gets the metadata included in an property
+     * @param entity The entity with the property to get the metadata from
+     * @param propertyKey The property on the given Entity to get the metadata from
+     * @param type For secure Typing, defines the returned PropertyConfig
+     * @returns The metadata of the property
+     */
+    static getPropertyMetadata<EntityType extends Entity, T extends DecoratorTypes>(entity: EntityType, propertyKey: keyof EntityType, type: T): DecoratorType<T>;
+    /**
+     * Gets the type of the property-metadata.
+     * @param entity The entity with the property to get the type from
+     * @param propertyKey The property on the given Entity to get the type from
+     * @returns The type of the metadata
+     */
+    static getPropertyType<EntityType extends Entity>(entity: EntityType, propertyKey: keyof EntityType): DecoratorTypes;
+    /**
+     * Sets all property values based on a given entity data-object.
+     * @param entity The data object to get the property values from.
+     * @param target
+     * the target object that needs to be constructed
+     * (if called inside a Entity constructor its usually this)
+     * @alias new
+     * @alias build
+     * @alias construct
+     */
+    static new<EntityType extends Entity>(target: EntityType, entity?: EntityType): void;
+    static construct: typeof EntityUtilities.new;
+    static build: typeof EntityUtilities.new;
+    /**
+     * Checks if the values on an entity are valid.
+     * Also checks all the validators given by the metadata ("required", "maxLength" etc.)
+     * @param entity The entity to validate.
+     * @param omit Whether to check for creatiung or editing validity
+     * @returns Whether or not the entity is valid.
+     */
+    static isEntityValid<EntityType extends Entity>(entity: EntityType, omit: 'create' | 'edit'): boolean;
+    /**
+     * Checks if a single property value is valid
+     * @param entity The entity where the property is from
+     * @param key The name of the property
+     * @returns Whether or not the property value is valid
+     */
+    private static isPropertyValid;
+    /**
+     * Checks if an entity is "dirty" (if its values have changed)
+     * @param entity The entity after all changes
+     * @param entityPriorChanges The entity before the changes
+     * @returns Whether or not the entity is dirty
+     */
+    static dirty(entity: Entity, entityPriorChanges: Entity): boolean;
+    /**
+     * Compares two Entities and returns their difference in an object
+     * @param entity The first entity to compare
+     * @param entityPriorChanges The second entity to compare
+     * @returns The difference between the two Entities in form of a Partial
+     */
+    static difference<EntityType extends Entity>(entity: EntityType, entityPriorChanges: EntityType): Partial<EntityType>;
+    /**
+     * compare function for sorting entity keys by their order value
+     * @param a first key of entity
+     * @param b second key of entity
+     * @param entity current entity (used to get metadata of entity keys)
+     */
+    static compareOrder<EntityType extends Entity>(a: keyof EntityType, b: keyof EntityType, entity: EntityType): number;
+    /**
+     * gets the bootstrap column values for "lg", "md", "sm"
+     * @param entity entity to get the bootstrap column values of the key
+     * @param key key of the property to get bootstrap column values from
+     * @param type defines for which screensize the column values should be returned
+     * @returns bootstrap column value
+     */
+    static getWidth<EntityType extends Entity>(entity: EntityType, key: keyof EntityType, type: 'lg' | 'md' | 'sm'): number;
+    /**
+     * Resets all changes on an entity
+     * @param entity The entity to reset
+     * @param entityPriorChanges The entity before any changes
+     */
+    static resetChangesOnEntity<EntityType extends Entity>(entity: EntityType, entityPriorChanges: EntityType): void;
+}

package/components/confirm-dialog/confirm-dialog-data.d.ts

@@ -0,0 +1,41 @@
+export declare type ConfirmDialogTypes = 'default' | 'delete' | 'info-only';
+/**
+ * The Definition of the Confirm Dialog Data
+ */
+export interface ConfirmDialogData {
+    /**
+     * An array of paragraphs to display inside the dialog body
+     */
+    text?: string[];
+    /**
+     * The type of the Confirm Dialog. Changes the button layout. Can be either:
+     * @value 'default': A confirm- and a cancel-button
+     * @value 'delete': Like default but the confirm-button is red
+     * @value 'info-only': Only a cancel-button
+     */
+    type?: ConfirmDialogTypes;
+    /**
+     * The label of the button that confirms the dialog.
+     * In case of the 'delete' Dialog this is the string that is shown on the delete-button.
+     * Defaults to "Confirm" or "Delete", depending on the type
+     */
+    confirmButtonLabel?: string;
+    /**
+     * The label of the button that closes the dialog without doing anything.
+     * Defaults to "Cancel"
+     */
+    cancelButtonLabel?: string;
+    /**
+     * The title of the dialog.
+     */
+    title?: string;
+    /**
+     * Whether or not a checkbox needs to be selected before the user can confirm the dialog.
+     * Defaults to false.
+     */
+    requireConfirmation?: boolean;
+    /**
+     * The text to display on the checkbox if 'requireConfirmation' is set to true.
+     */
+    confirmationText?: string;
+}

package/components/confirm-dialog/confirm-dialog.component.d.ts

@@ -0,0 +1,18 @@
+import { OnInit } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import { ConfirmDialogData } from './confirm-dialog-data';
+import * as i0 from "@angular/core";
+export declare class NgxMatEntityConfirmDialogComponent implements OnInit {
+    private readonly dialogRef;
+    readonly data: ConfirmDialogData;
+    /**
+     * Used for the checkbox to confirm the action
+     */
+    confirm: boolean;
+    constructor(dialogRef: MatDialogRef<NgxMatEntityConfirmDialogComponent>, data: ConfirmDialogData);
+    ngOnInit(): void;
+    confirmAction(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityConfirmDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatEntityConfirmDialogComponent, "ngx-mat-entity-confirm-dialog", never, {}, {}, never, never>;
+}

package/components/confirm-dialog/confirm-dialog.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./confirm-dialog.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/dialog";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/material/checkbox";
+import * as i6 from "@angular/material/button";
+export declare class NgxMatEntityConfirmDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityConfirmDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMatEntityConfirmDialogModule, [typeof i1.NgxMatEntityConfirmDialogComponent], [typeof i2.CommonModule, typeof i3.MatDialogModule, typeof i4.FormsModule, typeof i5.MatCheckboxModule, typeof i6.MatButtonModule], [typeof i1.NgxMatEntityConfirmDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMatEntityConfirmDialogModule>;
+}

package/components/get-validation-error-message.function.d.ts

@@ -0,0 +1,7 @@
+import { NgModel } from '@angular/forms';
+/**
+ * Generates a default error message for most validation errors.
+ * @param model The ngModel to get the error from
+ * @returns The Validation Error Message to display
+ */
+export declare function getValidationErrorMessage(model: NgModel): string;

package/components/input/array-table/add-array-item-dialog/add-array-item-dialog.component.d.ts

@@ -0,0 +1,35 @@
+import { OnInit } from '@angular/core';
+import { NgModel } from '@angular/forms';
+import { MatDialogRef } from '@angular/material/dialog';
+import { Entity } from '../../../../classes/entity-model.class';
+import { EntityUtilities } from '../../../../classes/entity-utilities.class';
+import { CreateDialogData } from '../../../table/table-data';
+import * as i0 from "@angular/core";
+export interface AddArrayItemDialogData<EntityType extends Entity> {
+    /**
+     * An empty entity that is used as the data model.
+     */
+    entity: EntityType;
+    /**
+     * The info of the generic create-dialog.
+     */
+    createDialogData: CreateDialogData;
+    /**
+     * (optional) A custom function to generate the error-message for invalid inputs.
+     */
+    getValidationErrorMessage: (model: NgModel) => string;
+}
+export declare class NgxMatEntityAddArrayItemDialogComponent<EntityType extends Entity> implements OnInit {
+    data: AddArrayItemDialogData<EntityType>;
+    dialogRef: MatDialogRef<NgxMatEntityAddArrayItemDialogComponent<EntityType>>;
+    EntityUtilities: typeof EntityUtilities;
+    entityKeys: (keyof EntityType)[];
+    getWidth: typeof EntityUtilities.getWidth;
+    constructor(data: AddArrayItemDialogData<EntityType>, dialogRef: MatDialogRef<NgxMatEntityAddArrayItemDialogComponent<EntityType>>);
+    ngOnInit(): void;
+    private setEntityKeys;
+    create(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityAddArrayItemDialogComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatEntityAddArrayItemDialogComponent<any>, "ngx-mat-entity-add-array-item-dialog", never, {}, {}, never, never>;
+}

package/components/input/array-table/add-array-item-dialog/add-array-item-dialog.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./add-array-item-dialog.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../../internal-input/internal-input.module";
+import * as i4 from "@angular/material/dialog";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/material/button";
+export declare class NgxMatEntityAddArrayItemDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityAddArrayItemDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMatEntityAddArrayItemDialogModule, [typeof i1.NgxMatEntityAddArrayItemDialogComponent], [typeof i2.CommonModule, typeof i3.NgxMatEntityInternalInputModule, typeof i4.MatDialogModule, typeof i5.FormsModule, typeof i6.MatButtonModule], [typeof i1.NgxMatEntityAddArrayItemDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMatEntityAddArrayItemDialogModule>;
+}

package/components/input/array-table/array-table.component.d.ts

@@ -0,0 +1,34 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { OnInit } from '@angular/core';
+import { EntityArrayDecoratorConfig } from '../../../decorators/array.decorator';
+import { Entity } from '../../../classes/entity-model.class';
+import { EntityUtilities } from '../../../classes/entity-utilities.class';
+import { NgModel } from '@angular/forms';
+import { MatTableDataSource } from '@angular/material/table';
+import { MatDialog } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare class NgxMatEntityArrayTableComponent<EntityType extends Entity> implements OnInit {
+    private readonly dialog;
+    arrayItems: EntityType[];
+    metadata: EntityArrayDecoratorConfig<EntityType>;
+    getValidationErrorMessage: (model: NgModel) => string;
+    omit: 'create' | 'edit';
+    dataSource: MatTableDataSource<EntityType>;
+    selection: SelectionModel<EntityType>;
+    displayedColumns: string[];
+    arrayItem: EntityType;
+    private arrayItemPriorChanges;
+    getWidth: typeof EntityUtilities.getWidth;
+    EntityUtilities: typeof EntityUtilities;
+    constructor(dialog: MatDialog);
+    trackByFn(index: unknown): unknown;
+    ngOnInit(): void;
+    private validateInput;
+    add(): void;
+    remove(): void;
+    getObjectProperties(): (keyof EntityType)[];
+    masterToggle(): void;
+    isAllSelected(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityArrayTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatEntityArrayTableComponent<any>, "ngx-mat-entity-array-table", never, { "arrayItems": "arrayItems"; "metadata": "metadata"; "getValidationErrorMessage": "getValidationErrorMessage"; "omit": "omit"; }, {}, never, never>;
+}

package/components/input/array-table/array-table.module.d.ts

@@ -0,0 +1,19 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./array-table.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/material/form-field";
+import * as i6 from "@angular/material/select";
+import * as i7 from "@angular/material/autocomplete";
+import * as i8 from "@angular/material/checkbox";
+import * as i9 from "@angular/material/slide-toggle";
+import * as i10 from "@angular/material/table";
+import * as i11 from "../internal-input/internal-input.module";
+import * as i12 from "@angular/material/button";
+import * as i13 from "./add-array-item-dialog/add-array-item-dialog.module";
+export declare class NgxMatEntityArrayTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityArrayTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMatEntityArrayTableModule, [typeof i1.NgxMatEntityArrayTableComponent], [typeof i2.CommonModule, typeof i3.MatInputModule, typeof i4.FormsModule, typeof i5.MatFormFieldModule, typeof i6.MatSelectModule, typeof i7.MatAutocompleteModule, typeof i8.MatCheckboxModule, typeof i9.MatSlideToggleModule, typeof i10.MatTableModule, typeof i11.NgxMatEntityInternalInputModule, typeof i12.MatButtonModule, typeof i13.NgxMatEntityAddArrayItemDialogModule], [typeof i1.NgxMatEntityArrayTableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMatEntityArrayTableModule>;
+}

package/components/input/input.component.d.ts

@@ -0,0 +1,73 @@
+import { OnInit } from '@angular/core';
+import { NgModel } from '@angular/forms';
+import { EntityUtilities } from '../../classes/entity-utilities.class';
+import { Entity } from '../../classes/entity-model.class';
+import { DecoratorTypes } from '../../decorators/base/decorator-types.enum';
+import { PropertyDecoratorConfig } from '../../decorators/base/property-decorator-config.interface';
+import { AutocompleteStringDecoratorConfig, DefaultStringDecoratorConfig, DropdownStringDecoratorConfig, TextboxStringDecoratorConfig } from '../../decorators/string.decorator';
+import { DropdownBooleanDecoratorConfig } from '../../decorators/boolean.decorator';
+import { DefaultNumberDecoratorConfig, DropdownNumberDecoratorConfig } from '../../decorators/number.decorator';
+import { DefaultObjectDecoratorConfig } from '../../decorators/object.decorator';
+import { AutocompleteStringChipsArrayDecoratorConfig, EntityArrayDecoratorConfig, StringChipsArrayDecoratorConfig } from '../../decorators/array.decorator';
+import { MatChipInputEvent } from '@angular/material/chips';
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import * as i0 from "@angular/core";
+export declare class NgxMatEntityInputComponent<EntityType extends Entity> implements OnInit {
+    /**
+     * The entity on which the property exists. Used in conjuction with the "propertyKey"
+     * to determine the property for which the input should be generated.
+     */
+    entity: EntityType;
+    /**
+     * The name of the property to generate the input for. Used in conjuction with the "entity".
+     */
+    propertyKey: keyof EntityType;
+    /**
+     * (optional) A custom function to generate the error-message for invalid inputs.
+     */
+    getValidationErrorMessage: (model: NgModel) => string;
+    /**
+     * Whether to hide a value if it is omitted for creation.
+     * Is used internally for the object property.
+     */
+    hideOmitForCreate?: boolean;
+    /**
+     * Whether to hide a value if it is omitted for editing.
+     * Is used internally for the object property.
+     */
+    hideOmitForEdit?: boolean;
+    type: DecoratorTypes;
+    metadata: PropertyDecoratorConfig;
+    metadataDefaultString: DefaultStringDecoratorConfig;
+    metadataTextboxString: TextboxStringDecoratorConfig;
+    metadataAutocompleteString: AutocompleteStringDecoratorConfig;
+    autocompleteStrings: string[];
+    filteredAutocompleteStrings: string[];
+    metadataDropdownString: DropdownStringDecoratorConfig;
+    metadataDropdownBoolean: DropdownBooleanDecoratorConfig;
+    metadataDefaultNumber: DefaultNumberDecoratorConfig;
+    metadataDropdownNumber: DropdownNumberDecoratorConfig;
+    metadataDefaultObject: DefaultObjectDecoratorConfig;
+    objectProperty: Entity;
+    metadataEntityArray: EntityArrayDecoratorConfig<Entity>;
+    entityArrayValues: Entity[];
+    metadataStringChipsArray: StringChipsArrayDecoratorConfig;
+    stringChipsArrayValues: string[];
+    chipsInput: string;
+    metadataAutocompleteStringChipsArray: AutocompleteStringChipsArrayDecoratorConfig;
+    readonly DecoratorTypes: typeof DecoratorTypes;
+    getWidth: typeof EntityUtilities.getWidth;
+    constructor();
+    /**
+     * Helper method needed to recursively generate property input components (used eg. with the object)
+     */
+    trackByFn(index: unknown): unknown;
+    ngOnInit(): void;
+    getObjectProperties(): (keyof Entity)[];
+    addStringChipArrayValue(event: MatChipInputEvent): void;
+    removeStringChipArrayValue(value: string): void;
+    selected(event: MatAutocompleteSelectedEvent, chipsInput: HTMLInputElement): void;
+    filterAutocompleteStrings(input: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityInputComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatEntityInputComponent<any>, "ngx-mat-entity-input", never, { "entity": "entity"; "propertyKey": "propertyKey"; "getValidationErrorMessage": "getValidationErrorMessage"; "hideOmitForCreate": "hideOmitForCreate"; "hideOmitForEdit": "hideOmitForEdit"; }, {}, never, never>;
+}

package/components/input/input.module.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/material/form-field";
+import * as i6 from "@angular/material/select";
+import * as i7 from "@angular/material/autocomplete";
+import * as i8 from "@angular/material/checkbox";
+import * as i9 from "@angular/material/slide-toggle";
+import * as i10 from "./array-table/array-table.module";
+import * as i11 from "@angular/material/chips";
+import * as i12 from "@angular/material/icon";
+export declare class NgxMatEntityInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMatEntityInputModule, [typeof i1.NgxMatEntityInputComponent], [typeof i2.CommonModule, typeof i3.MatInputModule, typeof i4.FormsModule, typeof i5.MatFormFieldModule, typeof i6.MatSelectModule, typeof i7.MatAutocompleteModule, typeof i8.MatCheckboxModule, typeof i9.MatSlideToggleModule, typeof i10.NgxMatEntityArrayTableModule, typeof i11.MatChipsModule, typeof i12.MatIconModule], [typeof i1.NgxMatEntityInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMatEntityInputModule>;
+}

package/components/input/internal-input/internal-input.component.d.ts

@@ -0,0 +1,57 @@
+import { OnInit } from '@angular/core';
+import { DecoratorTypes } from '../../../decorators/base/decorator-types.enum';
+import { PropertyDecoratorConfig } from '../../../decorators/base/property-decorator-config.interface';
+import { DefaultNumberDecoratorConfig, DropdownNumberDecoratorConfig } from '../../../decorators/number.decorator';
+import { AutocompleteStringDecoratorConfig, DefaultStringDecoratorConfig, DropdownStringDecoratorConfig, TextboxStringDecoratorConfig } from '../../../decorators/string.decorator';
+import { DropdownBooleanDecoratorConfig } from '../../../decorators/boolean.decorator';
+import { Entity } from '../../../classes/entity-model.class';
+import { DefaultObjectDecoratorConfig } from '../../../decorators/object.decorator';
+import { EntityUtilities } from '../../../classes/entity-utilities.class';
+import { NgModel } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class NgxMatEntityInternalInputComponent<EntityType extends Entity> implements OnInit {
+    /**
+     * The entity on which the property exists. Used in conjuction with the "propertyKey"
+     * to determine the property for which the input should be generated.
+     */
+    entity: EntityType;
+    /**
+     * The name of the property to generate the input for. Used in conjuction with the "entity".
+     */
+    propertyKey: keyof EntityType;
+    /**
+     * Whether to hide a value if it is omitted for creation.
+     * Is used internally for the object property.
+     */
+    hideOmitForCreate?: boolean;
+    /**
+     * Whether to hide a value if it is omitted for editing.
+     * Is used internally for the object property.
+     */
+    hideOmitForEdit?: boolean;
+    /**
+     * (optional) A custom function to generate the error-message for invalid inputs.
+     */
+    getValidationErrorMessage: (model: NgModel) => string;
+    type: DecoratorTypes;
+    metadata: PropertyDecoratorConfig;
+    metadataDefaultString: DefaultStringDecoratorConfig;
+    metadataTextboxString: TextboxStringDecoratorConfig;
+    metadataAutocompleteString: AutocompleteStringDecoratorConfig;
+    metadataDropdownString: DropdownStringDecoratorConfig;
+    metadataDropdownBoolean: DropdownBooleanDecoratorConfig;
+    metadataDefaultNumber: DefaultNumberDecoratorConfig;
+    metadataDropdownNumber: DropdownNumberDecoratorConfig;
+    metadataDefaultObject: DefaultObjectDecoratorConfig;
+    objectProperty: Entity;
+    readonly DecoratorTypes: typeof DecoratorTypes;
+    getWidth: typeof EntityUtilities.getWidth;
+    /**
+     * Helper method needed to recursively generate property input components (used eg. with the object)
+     */
+    trackByFn(index: unknown): unknown;
+    ngOnInit(): void;
+    getObjectProperties(): (keyof Entity)[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityInternalInputComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatEntityInternalInputComponent<any>, "ngx-mat-entity-internal-input", never, { "entity": "entity"; "propertyKey": "propertyKey"; "hideOmitForCreate": "hideOmitForCreate"; "hideOmitForEdit": "hideOmitForEdit"; "getValidationErrorMessage": "getValidationErrorMessage"; }, {}, never, never>;
+}

package/components/input/internal-input/internal-input.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./internal-input.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/material/form-field";
+import * as i6 from "@angular/material/select";
+import * as i7 from "@angular/material/autocomplete";
+import * as i8 from "@angular/material/checkbox";
+import * as i9 from "@angular/material/slide-toggle";
+import * as i10 from "@angular/material/table";
+export declare class NgxMatEntityInternalInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityInternalInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMatEntityInternalInputModule, [typeof i1.NgxMatEntityInternalInputComponent], [typeof i2.CommonModule, typeof i3.MatInputModule, typeof i4.FormsModule, typeof i5.MatFormFieldModule, typeof i6.MatSelectModule, typeof i7.MatAutocompleteModule, typeof i8.MatCheckboxModule, typeof i9.MatSlideToggleModule, typeof i10.MatTableModule], [typeof i1.NgxMatEntityInternalInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMatEntityInternalInputModule>;
+}

package/components/table/create-dialog/create-entity-dialog-data.d.ts

@@ -0,0 +1,21 @@
+import { HttpClient } from '@angular/common/http';
+import { EntityService } from '../../../classes/entity-service.class';
+import { Entity } from '../../../classes/entity-model.class';
+import { CreateDialogData } from '../table-data';
+/**
+ * The Definition of the Create Entity Dialog Data
+ */
+export interface CreateEntityDialogData<EntityType extends Entity> {
+    /**
+     * An empty entity that is used as the data model.
+     */
+    entity: EntityType;
+    /**
+     * The Entity Service class used for the create request.
+     */
+    EntityServiceClass: new (httpClient: HttpClient) => EntityService<EntityType>;
+    /**
+     * The info of the generic create-dialog.
+     */
+    createDialogData: CreateDialogData;
+}

package/components/table/create-dialog/create-entity-dialog.component.d.ts

@@ -0,0 +1,25 @@
+import { Injector, OnInit } from '@angular/core';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { EntityService } from '../../../classes/entity-service.class';
+import { Entity } from '../../../classes/entity-model.class';
+import { EntityUtilities } from '../../../classes/entity-utilities.class';
+import { CreateEntityDialogData } from './create-entity-dialog-data';
+import * as i0 from "@angular/core";
+export declare class NgxMatEntityCreateDialogComponent<EntityType extends Entity> implements OnInit {
+    data: CreateEntityDialogData<EntityType>;
+    dialogRef: MatDialogRef<NgxMatEntityCreateDialogComponent<EntityType>>;
+    private readonly injector;
+    private readonly dialog;
+    EntityUtilities: typeof EntityUtilities;
+    entityKeys: (keyof EntityType)[];
+    entityService: EntityService<EntityType>;
+    getWidth: typeof EntityUtilities.getWidth;
+    constructor(data: CreateEntityDialogData<EntityType>, dialogRef: MatDialogRef<NgxMatEntityCreateDialogComponent<EntityType>>, injector: Injector, dialog: MatDialog);
+    ngOnInit(): void;
+    private setEntityKeys;
+    create(): void;
+    private confirmCreate;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityCreateDialogComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatEntityCreateDialogComponent<any>, "ngx-mat-entity-create-dialog", never, {}, {}, never, never>;
+}

package/components/table/create-dialog/create-entity-dialog.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./create-entity-dialog.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../../input/input.module";
+import * as i4 from "@angular/material/dialog";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/material/button";
+export declare class NgxMatEntityCreateDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityCreateDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMatEntityCreateDialogModule, [typeof i1.NgxMatEntityCreateDialogComponent], [typeof i2.CommonModule, typeof i3.NgxMatEntityInputModule, typeof i4.MatDialogModule, typeof i5.FormsModule, typeof i6.MatButtonModule], [typeof i1.NgxMatEntityCreateDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMatEntityCreateDialogModule>;
+}

package/components/table/edit-dialog/edit-entity-dialog-data.d.ts

@@ -0,0 +1,25 @@
+import { HttpClient } from '@angular/common/http';
+import { EntityService } from '../../../classes/entity-service.class';
+import { Entity } from '../../../classes/entity-model.class';
+import { EditDialogData } from '../table-data';
+/**
+ * The Definition of the Edit Entity Dialog Data
+ */
+export interface EditEntityDialogData<EntityType extends Entity> {
+    /**
+     * The entity to edit
+     */
+    entity: EntityType;
+    /**
+     * The Entity Service class used for updating/deleting the entity.
+     */
+    EntityServiceClass: new (httpClient: HttpClient) => EntityService<EntityType>;
+    /**
+     * The info of the generic edit-dialog.
+     */
+    editDialogData: EditDialogData<EntityType>;
+    /**
+     * Whether or not the user can delete this specific entity
+     */
+    allowDelete: (entity: EntityType) => boolean;
+}

package/components/table/edit-dialog/edit-entity-dialog.component.d.ts

@@ -0,0 +1,28 @@
+import { Injector, OnInit } from '@angular/core';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { EntityService } from '../../../classes/entity-service.class';
+import { Entity } from '../../../classes/entity-model.class';
+import { EntityUtilities } from '../../../classes/entity-utilities.class';
+import { EditEntityDialogData } from './edit-entity-dialog-data';
+import * as i0 from "@angular/core";
+export declare class NgxMatEntityEditDialogComponent<EntityType extends Entity> implements OnInit {
+    data: EditEntityDialogData<EntityType>;
+    dialogRef: MatDialogRef<NgxMatEntityEditDialogComponent<EntityType>>;
+    private readonly injector;
+    private readonly dialog;
+    EntityUtilities: typeof EntityUtilities;
+    entityKeys: (keyof EntityType)[];
+    entityService: EntityService<EntityType>;
+    entityPriorChanges: EntityType;
+    getWidth: typeof EntityUtilities.getWidth;
+    constructor(data: EditEntityDialogData<EntityType>, dialogRef: MatDialogRef<NgxMatEntityEditDialogComponent<EntityType>>, injector: Injector, dialog: MatDialog);
+    ngOnInit(): void;
+    private setEntityKeys;
+    edit(): void;
+    private confirmEdit;
+    delete(): void;
+    private confirmDelete;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityEditDialogComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatEntityEditDialogComponent<any>, "ngx-mat-entity-edit-dialog", never, {}, {}, never, never>;
+}

package/components/table/edit-dialog/edit-entity-dialog.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./edit-entity-dialog.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../../input/input.module";
+import * as i4 from "@angular/material/dialog";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/material/button";
+import * as i7 from "../../confirm-dialog/confirm-dialog.module";
+export declare class NgxMatEntityEditDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityEditDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMatEntityEditDialogModule, [typeof i1.NgxMatEntityEditDialogComponent], [typeof i2.CommonModule, typeof i3.NgxMatEntityInputModule, typeof i4.MatDialogModule, typeof i5.FormsModule, typeof i6.MatButtonModule, typeof i7.NgxMatEntityConfirmDialogModule], [typeof i1.NgxMatEntityEditDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMatEntityEditDialogModule>;
+}