ngx-material-entity 0.1.2 → 0.1.5

package/capsulation/lodash.utilities.d.ts

@@ -0,0 +1,62 @@
+import { Dictionary, Many, ValueKeyIteratee } from 'lodash';
+/**
+ * Encapsulates all functionality of lodash.
+ */
+export declare abstract class LodashUtilities {
+    /**
+     * Performs a deep comparison between two values to determine if they are
+     * equivalent.
+     *
+     * **Note:** This method supports comparing arrays, array buffers, booleans,
+     * date objects, error objects, maps, numbers, `Object` objects, regexps,
+     * sets, strings, symbols, and typed arrays. `Object` objects are compared
+     * by their own, not inherited, enumerable properties. Functions and DOM
+     * nodes are **not** supported.
+     *
+     * @param value - The value to compare.
+     * @param other - The other value to compare.
+     * @returns Returns `true` if the values are equivalent, else `false`.
+     */
+    static isEqual(value: unknown, other: unknown): boolean;
+    /**
+     * This method is like _.clone except that it recursively clones value.
+     *
+     * @param value - The value to recursively clone.
+     * @returns Returns the deep cloned value.
+     */
+    static cloneDeep<T>(value: T): T;
+    /**
+     * The opposite of `_.pick`; this method creates an object composed of the
+     * own and inherited enumerable properties of `object` that are not omitted.
+     *
+     * @param object - The source object.
+     * @param paths - The property names to omit, specified
+     * individually or in arrays.
+     * @returns Returns the new object.
+     */
+    static omit<T extends object, K extends keyof T>(object: T | null | undefined, ...paths: Many<K>[]): Omit<T, K>;
+    /**
+     * Checks if `value` is `null` or `undefined`.
+     *
+     * @param value - The value to check.
+     * @returns Returns `true` if `value` is nullish, else `false`.
+     */
+    static isNil(value: unknown): value is null | undefined;
+    /**
+     * The opposite of `_.pickBy`; this method creates an object composed of the
+     * own and inherited enumerable properties of `object` that `predicate`
+     * doesn't return truthy for.
+     *
+     * @param object - The source object.
+     * @param predicate - The function invoked per property.
+     * @returns Returns the new object.
+     */
+    static omitBy<T>(object: Dictionary<T> | null | undefined, predicate?: ValueKeyIteratee<T>): Dictionary<T>;
+    /**
+     * Checks if value is classified as an Array object.
+     *
+     * @param value - The value to check.
+     * @returns Returns true if value is correctly classified, else false.
+     */
+    static isArray(value?: unknown): value is unknown[];
+}

package/capsulation/reflect.utilities.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Encapsulates all functionality of Reflect.
+ */
+export declare abstract class ReflectUtilities {
+    /**
+     * Gets the metadata value for the provided metadata key on the target object or its prototype chain.
+     *
+     * @param metadataKey - A key used to store and retrieve metadata.
+     * @param target - The target object on which the metadata is defined.
+     * @param propertyKey - The property key for the target.
+     * @returns The metadata value for the metadata key if found; otherwise, undefined.
+     */
+    static getMetadata<T extends object>(metadataKey: string, target: T, propertyKey: keyof T): unknown;
+    /**
+     * Returns the string and symbol keys of the own properties of an object. The own properties of an object
+     * are those that are defined directly on that object, and are not inherited from the object's prototype.
+     *
+     * @param target - Object that contains the own properties.
+     * @returns The keys of the given object.
+     */
+    static ownKeys<T extends object>(target: T): (keyof T)[];
+    /**
+     * Gets the property of target, equivalent to `target[propertyKey]`.
+     *
+     * @param target - Object that contains the property on itself or in its prototype chain.
+     * @param propertyKey - The property name.
+     * @returns The property of the target of the given key.
+     */
+    static get<T extends object>(target: T, propertyKey: keyof T): unknown;
+    /**
+     * Sets the property of target, equivalent to `target[propertyKey] = value`.
+     *
+     * @param target - Object that contains the property on itself or in its prototype chain.
+     * @param propertyKey - The property name.
+     * @param value - The value to set the property to.
+     * @returns If setting the value was successful.
+     */
+    static set<T extends object>(target: T, propertyKey: keyof T, value: unknown): boolean;
+    /**
+     * Equivalent to `propertyKey in target`.
+     *
+     * @param target - Object that contains the property on itself or in its prototype chain.
+     * @param propertyKey - Name of the property.
+     * @returns Whether or not the given target has the key.
+     */
+    static has<T extends object>(target: T, propertyKey: keyof T): boolean;
+    /**
+     * Define a unique metadata entry on the target.
+     *
+     * @param metadataKey - A key used to store and retrieve metadata.
+     * @param metadataValue - A value that contains attached metadata.
+     * @param target - The target object on which to define metadata.
+     * @param propertyKey - The property key for the target.
+     */
+    static defineMetadata<T extends object>(metadataKey: unknown, metadataValue: unknown, target: T, propertyKey: string): void;
+}

package/classes/base.builder.d.ts

@@ -0,0 +1,36 @@
+import { BaseEntityType } from './entity.model';
+/**
+ * The abstract BaseBuilder class.
+ */
+export declare abstract class BaseBuilder<InternalType extends InputType, InputType extends BaseEntityType<InputType>> {
+    private readonly data;
+    private readonly inputData?;
+    protected constructor(data?: InputType);
+    /**
+     * Generates the internal data from the given user inputs.
+     *
+     * @param data - The input from the user.
+     * @returns The internal data.
+     */
+    protected abstract generateBaseData(data?: InputType): InternalType;
+    /**
+     * Used to validate the user input in the constructor.
+     *
+     * @param data - The user input.
+     */
+    protected validateInput(data?: InputType): void;
+    /**
+     * Sets the value for the given key if no user value was provided.
+     *
+     * @param key - The key to set the default value for.
+     * @param value - The value to set when nothing was provided.
+     * @returns The Builder.
+     */
+    withDefault(key: keyof InputType, value: Omit<InternalType[keyof InputType], 'undefined'>): BaseBuilder<InternalType, InputType>;
+    /**
+     * Method used to get the final build value after applying all chaining.
+     *
+     * @returns The build value.
+     */
+    getResult(): InternalType;
+}

package/classes/date.utilities.d.ts

@@ -0,0 +1,70 @@
+import { Time } from '@angular/common';
+import { DateFilterFn } from '@angular/material/datepicker';
+import { DropdownValue } from '../decorators/base/dropdown-value.interface';
+/**
+ * Valid steps from one time value to the next. Needs to be able to divide 60 minutes without remainder.
+ */
+declare type MinuteSteps = 1 | 2 | 3 | 4 | 5 | 6 | 10 | 12 | 15 | 20 | 30 | 60;
+/**
+ * Contains Helper Functions for handling date properties.
+ */
+export declare abstract class DateUtilities {
+    /**
+     * The default filter function to user when none was provided by the user.
+     */
+    static defaultDateFilter: DateFilterFn<Date | null | undefined>;
+    /**
+     * Gets the given value as a date value.
+     *
+     * @param value - The value to get as a date.
+     * @returns The given value as a date.
+     */
+    static asDate(value: unknown): Date;
+    /**
+     * Gets the default times used by the DateTime picker when nothing is specified by the user.
+     *
+     * @param format - The time format. Defaults to 24.
+     * @param minuteSteps - The steps from one time value to the next. Defaults to 30.
+     * @returns Times in the 24 hour format from 0:00 until 23:30 in 30 minute steps.
+     */
+    static getDefaultTimes(format?: 12 | 24, minuteSteps?: MinuteSteps): DropdownValue<Time>[];
+    private static getTimeDropdownValue;
+    private static getFormattedHour;
+    private static getFormattedMinute;
+    /**
+     * Gets the Time object from the given date.
+     *
+     * @param value - The date to get the time object from.
+     * @returns The Time object build from the date value.
+     */
+    static getTimeFromDate(value: Date): Time | undefined;
+    /**
+     * Gets the dates between the two given gates. Does additional filtering based on the provided DateRange metadata.
+     *
+     * @param startDate - The start date.
+     * @param endDate - The end date.
+     * @param filter - The custom filter from the metadata.
+     * @returns All dates between the two provided dates. Includes start and end date.
+     */
+    static getDatesBetween(startDate: Date, endDate: Date, filter?: DateFilterFn<Date>): Date[];
+    /**
+     * Get all valid times for the dropdown of a datetime property.
+     *
+     * @param date - The date of the datetime.
+     * @param times - All given times to filter.
+     * @param min - The function that defines the minimum time.
+     * @param max - The function that defines the maximum time.
+     * @param filter - A filter function to do more specific time filtering. This could be e.g. The removal of lunch breaks.
+     * @returns All valid dropdown values for the datetime property.
+     */
+    static getValidTimesForDropdown(date: Date, times: DropdownValue<Time>[], min?: (date?: Date) => Time, max?: (date?: Date) => Time, filter?: ((time: Time) => boolean) | (() => boolean)): DropdownValue<Time>[];
+    /**
+     * Checks if the time object has processable hours and minutes properties.
+     * Doesn't check custom validators like min/max from the metadata configuration.
+     *
+     * @param time - The time to check.
+     * @returns Whether or not the time object is unprocessable.
+     */
+    static timeIsUnprocessable(time?: Time): boolean;
+}
+export {};

package/classes/entity.model.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The newable type used whenever an entity class is passed to create an entity and initialize its metadata.
+ */
+export declare type EntityClassNewable<EntityType extends BaseEntityType<EntityType>> = new (data?: EntityType) => EntityType;
+/**
+ * The Generic Base EntityType.
+ */
+export declare type BaseEntityType<T> = {
+    [K in keyof T]: unknown;
+};
+/**
+ * A base Entity class with a builtin id.
+ */
+export declare abstract class Entity {
+    /**
+     * A unique identifier for the Entity.
+     */
+    id: string;
+}

package/classes/entity.service.d.ts

@@ -0,0 +1,108 @@
+import { HttpClient } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+import { BaseEntityType } from './entity.model';
+/**
+ * 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 BaseEntityType<EntityType>> {
+    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;
+    /**
+     * The key which holds the id value.
+     *
+     * @default 'id'
+     */
+    readonly idKey: keyof EntityType;
+    /**
+     * 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.
+     *
+     * @returns The current entities in form of an array.
+     */
+    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>;
+    /**
+     * Creates the entity with form data when the entity contains files in contrast to creating it with a normal json body.
+     * All file values are stored inside their respective property key and their name.
+     * Form data is able to handle setting multiple files to the same key.
+     *
+     * @param body - The body Of the request.
+     * @param filePropertyKeys - All property keys that are files and need to be added to the form data.
+     * @param entity - The entity to create. This is needed in addition to the body because the body doesn't contain any metadata.
+     * @returns The created entity from the server.
+     */
+    protected createWithFormData(body: Partial<EntityType>, filePropertyKeys: (keyof EntityType)[], entity: EntityType): Promise<EntityType>;
+    /**
+     * Creates the entity with a normal json body in contrast to creating it with form data when the entity contains files.
+     *
+     * @param body - The body Of the request.
+     * @returns The created entity from the server.
+     */
+    protected createWithJson(body: Partial<EntityType>): Promise<EntityType>;
+    /**
+     * Gets all existing entities and pushes them to the entities 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>;
+    /**
+     * Updates the entity with form data when the entity contains files in contrast to creating it with a normal json body.
+     * All file values are stored inside their respective property key and their name.
+     * Form data is able to handle setting multiple files to the same key.
+     *
+     * @param body - The request body. Already contains only properties that have changed.
+     * @param filePropertyKeys - The keys of all properties which are files and need to separately be appended to the form data.
+     * @param entity - The original entity. Is needed to get the metadata of all the files.
+     * @param id - The id of the entity to update.
+     */
+    protected updateWithFormData(body: Partial<EntityType>, filePropertyKeys: (keyof EntityType)[], entity: EntityType, id: EntityType[keyof EntityType]): Promise<void>;
+    /**
+     * Updates the entity with a normal json body in contrast to updating it with form data when the entity contains files.
+     *
+     * @param body - The body of the Request. Has already removed all unnecessary values.
+     * @param id - The id of the entity to update.
+     */
+    protected updateWithJson(body: Partial<EntityType>, id: EntityType[keyof EntityType]): Promise<void>;
+    /**
+     * Deletes a specific Entity.
+     *
+     * @param entity - The entity to delete.
+     */
+    delete(entity: EntityType): Promise<void>;
+}

package/classes/entity.utilities.d.ts

@@ -0,0 +1,180 @@
+import { DecoratorType, DecoratorTypes } from '../decorators/base/decorator-types.enum';
+import { PropertyDecoratorConfigInternal } from '../decorators/base/property-decorator-internal.data';
+import { BaseEntityType } from './entity.model';
+/**
+ * Contains HelperMethods around handling Entities and their property-metadata.
+ */
+export declare abstract class EntityUtilities {
+    /**
+     * Gets the properties to omit when updating the entity.
+     *
+     * @param entity - The entity to get the properties which should be left out for updating from.
+     * @returns The properties which should be left out for updating an Entity.
+     */
+    static getOmitForUpdate<EntityType extends BaseEntityType<EntityType>>(entity: EntityType): (keyof EntityType)[];
+    /**
+     * Gets the properties to omit when creating new entities.
+     *
+     * @param entity - The entity to get the properties which should be left out for creating from.
+     * @returns The properties which should be left out for creating a new Entity.
+     */
+    static getOmitForCreate<EntityType extends BaseEntityType<EntityType>>(entity: EntityType): (keyof EntityType)[];
+    /**
+     * Gets all properties on the given entity which are files.
+     *
+     * @param entity - The entity to check for file properties.
+     * @param omit - Whether to leave out values that are omitted for create or delete.
+     * @returns The keys of all file properties on the given entity.
+     */
+    static getFileProperties<EntityType extends BaseEntityType<EntityType>>(entity: EntityType, omit?: 'create' | 'update'): (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.
+     * @throws When no metadata can be found for the given property.
+     */
+    static getPropertyMetadata<EntityType extends BaseEntityType<EntityType>, 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.
+     * @throws Will throw an error if no metadata can be found for the given property.
+     */
+    static getPropertyType<EntityType extends BaseEntityType<EntityType>>(entity: EntityType, propertyKey: keyof EntityType): DecoratorTypes;
+    /**
+     * Sets all property values based on a given entity data-object.
+     *
+     * @param target - The target object that needs to be constructed (if called inside an Entity constructor its usually this).
+     * @param entity - The data object to get the property values from.
+     * @alias new
+     * @alias build
+     * @alias construct
+     */
+    static new<EntityType extends BaseEntityType<EntityType>>(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 creating or editing validity.
+     * @returns Whether or not the entity is valid.
+     */
+    static isEntityValid<EntityType extends BaseEntityType<EntityType>>(entity: EntityType, omit: 'create' | 'update'): 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.
+     * @param omit - Whether to check if the given entity is valid for creation or updating.
+     * @returns Whether or not the property value is valid.
+     * @throws Throws when it extracts an unknown metadata type.
+     */
+    private static isPropertyValid;
+    private static isBooleanValid;
+    private static isStringValid;
+    private static isTextboxValid;
+    private static isNumberValid;
+    private static isDateValid;
+    private static isDateRangeValid;
+    private static isDateTimeValid;
+    private static isFileDataValid;
+    /**
+     * 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<EntityType extends BaseEntityType<EntityType>>(entity: EntityType, entityPriorChanges: EntityType): Promise<boolean>;
+    private static differencesForDirty;
+    /**
+     * 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 BaseEntityType<EntityType>>(entity: EntityType, entityPriorChanges: EntityType): Promise<Partial<EntityType>>;
+    /**
+     * Checks if two given values are equal.
+     * It uses the isEqual method from LodashUtilities and extends it with functionality regarding Dates.
+     *
+     * @param value - The updated value.
+     * @param valuePriorChanges - The value before any changes.
+     * @param metadata - The metadata of the property.
+     * @param type - The type of the property.
+     * @returns Whether or not the given values are equal.
+     */
+    static isEqual(value: unknown, valuePriorChanges: unknown, metadata: PropertyDecoratorConfigInternal, type: DecoratorTypes): Promise<boolean>;
+    private static isEqualArrayDate;
+    private static isEqualArrayDateRange;
+    private static isEqualDateTime;
+    private static isEqualDate;
+    private static isEqualDateRange;
+    private static isEqualFile;
+    /**
+     * 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).
+     * @returns 0 if both values have the same order, a negative value if 'a' comes before 'b', a positive value if 'a' comes behind 'b'.
+     */
+    static compareOrder<EntityType extends BaseEntityType<EntityType>>(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 screen size the column values should be returned.
+     * @returns Bootstrap column value.
+     */
+    static getWidth<EntityType extends BaseEntityType<EntityType>>(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 BaseEntityType<EntityType>>(entity: EntityType, entityPriorChanges: EntityType): void;
+    /**
+     * Gets the rows that are used to display the given entity.
+     *
+     * @param entity - The entity to get the rows from.
+     * @param hideOmitForCreate - Whether or not keys with the metadata omitForCreate should be filtered out.
+     * @param hideOmitForEdit - Whether or not keys with the metadata omitForUpdate should be filtered out.
+     * @returns The sorted Rows containing the row number and the keys to display in that row.
+     */
+    static getEntityRows<EntityType extends BaseEntityType<EntityType>>(entity: EntityType, hideOmitForCreate?: boolean, hideOmitForEdit?: boolean): EntityRow<EntityType>[];
+    private static getKeysForRow;
+    private static getNumberOfRows;
+    /**
+     * Gets the keys of the provided entity correctly typed.
+     *
+     * @param entity - The entity to get the keys of.
+     * @param hideOmitForCreate - Whether or not keys with the metadata omitForCreate should be filtered out.
+     * @param hideOmitForEdit - Whether or not keys with the metadata omitForUpdate should be filtered out.
+     * @returns An array of keys of the entity.
+     */
+    static keysOf<EntityType extends BaseEntityType<EntityType>>(entity: EntityType, hideOmitForCreate?: boolean, hideOmitForEdit?: boolean): (keyof EntityType)[];
+}
+/**
+ * A row that contains all the information about how to display an entity.
+ */
+export interface EntityRow<EntityType extends BaseEntityType<EntityType>> {
+    /**
+     * The row in which this should be displayed.
+     */
+    row: number;
+    /**
+     * The keys of the values that should be displayed in that row.
+     */
+    keys: (keyof EntityType)[];
+}

package/classes/file.utilities.d.ts

@@ -0,0 +1,52 @@
+import { FileDataWithFile } from '../decorators/file/file-decorator-internal.data';
+import { FileData } from '../decorators/file/file-decorator.data';
+/**
+ * Provides functionality regarding files.
+ */
+export declare abstract class FileUtilities {
+    /**
+     * Gets the accept value for the html input.
+     *
+     * @param mimeTypes - The mimeTypes to get the accept string from.
+     * @returns A comma separated string of all the provided mime types.
+     */
+    static getAcceptString(mimeTypes?: string[]): string;
+    /**
+     * Reads a url to display the given file.
+     *
+     * @param file - The file to get the url from.
+     * @returns A promise of the url. Undefined if no file was provided.
+     */
+    static getDataURLFromFile(file?: Blob): Promise<string | undefined>;
+    /**
+     * Gets a file from the given url.
+     *
+     * @param url - The url to get the file from.
+     * @returns A promise of the File.
+     */
+    private static getFileFromUrl;
+    /**
+     * Gets the file data with the blob from the given File Data.
+     *
+     * @param data - The File Data to get the file data with blob from.
+     * @returns FileDataWithFile.
+     */
+    static getFileData(data: FileData): Promise<FileDataWithFile>;
+    /**
+     * Checks if the given file has a valid mime type.
+     *
+     * @param type - The type of the file to check.
+     * @param allowedMimeTypes - The allowed mime types.
+     * @returns Whether or not the given file has a valid mime type.
+     */
+    static isMimeTypeValid(type: string, allowedMimeTypes: string[]): boolean;
+    /**
+     * Transform the given value to Megabytes.
+     *
+     * @param value - The original value.
+     * @param unit - If the value is B, KB or GB.
+     * @returns The given value as bytes.
+     */
+    static transformToMegaBytes(value: number, unit: 'B' | 'KB' | 'GB'): number;
+    private static transformToBytes;
+}

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

@@ -1,4 +1,8 @@
+import { BaseBuilder } from '../../classes/base.builder';
 import { ConfirmDialogData, ConfirmDialogTypes } from './confirm-dialog-data';
+/**
+ * The internal ConfirmDialogData. Requires all default values the user can leave out.
+ */
 export declare class ConfirmDialogDataInternal implements ConfirmDialogData {
     text: string[];
     type: ConfirmDialogTypes;
@@ -9,16 +13,11 @@ export declare class ConfirmDialogDataInternal implements ConfirmDialogData {
     confirmationText?: string;
     constructor(text: string[], type: ConfirmDialogTypes, confirmButtonLabel: string, cancelButtonLabel: string, title: string, requireConfirmation: boolean, confirmationText?: string);
 }
-export declare class ConfirmDialogDataBuilder {
-    confirmDialogData: ConfirmDialogDataInternal;
-    private readonly dataInput?;
+/**
+ * The Builder for the ConfirmDialogData. Sets default values.
+ */
+export declare class ConfirmDialogDataBuilder extends BaseBuilder<ConfirmDialogDataInternal, ConfirmDialogData> {
     constructor(data?: ConfirmDialogData);
-    private validateInput;
-    withDefaultText(text: string[]): ConfirmDialogDataBuilder;
-    withDefaultType(type: ConfirmDialogTypes): ConfirmDialogDataBuilder;
-    withDefaultConfirmButtonLabel(label: string): ConfirmDialogDataBuilder;
-    withDefaultCancelButtonLabel(label: string): ConfirmDialogDataBuilder;
-    withDefaultTitle(title: string): ConfirmDialogDataBuilder;
-    withDefaultRequireConfirmation(requireConfirmation: boolean): ConfirmDialogDataBuilder;
-    withDefaultConfirmationText(confirmationText: string): ConfirmDialogDataBuilder;
+    protected generateBaseData(data?: ConfirmDialogData): ConfirmDialogDataInternal;
+    protected validateInput(data?: ConfirmDialogData): void;
 }

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

@@ -1,3 +1,7 @@
+/**
+ * The different types of a confirm dialog.
+ * Is used for displaying different buttons accordingly.
+ */
 export declare type ConfirmDialogTypes = 'default' | 'delete' | 'info-only';
 /**
  * The Definition of the Confirm Dialog Data.

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

@@ -3,6 +3,11 @@ import { MatDialogRef } from '@angular/material/dialog';
 import { ConfirmDialogData } from './confirm-dialog-data';
 import { ConfirmDialogDataInternal } from './confirm-dialog-data.builder';
 import * as i0 from "@angular/core";
+/**
+ * The Dialog used whenever confirmation by the user is required (e.g. When the user tries to delete an entity).
+ *
+ * Can be customized with the MAT_DIALOG_DATA "inputData". Customization options are defined in "ConfirmDialogData".
+ */
 export declare class NgxMatEntityConfirmDialogComponent implements OnInit {
     private readonly dialogRef;
     private readonly inputData;
@@ -10,7 +15,13 @@ export declare class NgxMatEntityConfirmDialogComponent implements OnInit {
     data: ConfirmDialogDataInternal;
     constructor(dialogRef: MatDialogRef<NgxMatEntityConfirmDialogComponent>, inputData: ConfirmDialogData);
     ngOnInit(): void;
+    /**
+     * Closes the dialog with value 1 to signal that the action should be run.
+     */
     confirmAction(): void;
+    /**
+     * Closes the dialog.
+     */
     cancel(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatEntityConfirmDialogComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatEntityConfirmDialogComponent, "ngx-mat-entity-confirm-dialog", never, {}, {}, never, never>;