@smallpearl/ngx-helper 0.33.49 → 20.0.2

package/mat-entity-list/index.d.ts

@@ -1,3 +1,394 @@
-export * from './src/mat-entity-list-types';
-export * from './src/providers';
-export * from './src/mat-entity-list.component';
+import { HttpContextToken, HttpClient, HttpContext, HttpParams } from '@angular/common/http';
+import { Observable, Subscription, Subject } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, AfterViewInit, ElementRef, OnInit, OnDestroy, QueryList, EventEmitter, Injector } from '@angular/core';
+import * as _smallpearl_ngx_helper_mat_entity_list from '@smallpearl/ngx-helper/mat-entity-list';
+import * as _smallpearl_ngx_helper_entity_field from '@smallpearl/ngx-helper/entity-field';
+import { SPEntityFieldSpec, SPEntityField } from '@smallpearl/ngx-helper/entity-field';
+import * as _ngneat_elf from '@ngneat/elf';
+import * as _angular_material_paginator from '@angular/material/paginator';
+import { PageEvent } from '@angular/material/paginator';
+import { MatSort } from '@angular/material/sort';
+import { MatTableDataSource, MatTable, MatColumnDef } from '@angular/material/table';
+import { DomSanitizer } from '@angular/platform-browser';
+
+interface SPMatEntityListHttpContext {
+    entityName: string;
+    entityNamePlural: string;
+    endpoint: string;
+}
+declare const SP_MAT_ENTITY_LIST_HTTP_CONTEXT: HttpContextToken<SPMatEntityListHttpContext>;
+/**
+ * Pagination HTTP request params. Actually copied from Angular's HttpParams
+ * declaration. The ReadonlyArray<string|number|boolean> is a bit of an
+ * overkill for pagination params, but what the heck. When you copy-paste,
+ * do it in full!
+ */
+type SPPageParams = {
+    [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+};
+/**
+ * An interface that the clients should provide, either via a global config
+ * (see above), that handles parsing the GET response and returns the entities
+ * stored therein. This class will allow the entity-list component to be
+ * used across different pagination response types as long as the appropriate
+ * SPMatEntityListPaginator class is provided to the component.
+ */
+interface SPMatEntityListPaginator {
+    /**
+     * Return the HTTP request params for the given page index and page size as
+     * an object. For example, for a REST API that supports 'skip' and 'top' params,
+     * the implementation would be:
+     *
+     * ```typescript
+     * getRequestPageParams(endpoint: string, pageIndex: number, pageSize: number): SPPageParams {
+     *   return {
+     *     skip: pageIndex * pageSize,
+     *     top: pageSize
+     *   };
+     * }
+     * ```
+     * @param endpoint
+     * @param pageIndex
+     * @param pageSize
+     * @returns
+     */
+    getRequestPageParams: (endpoint: string, pageIndex: number, pageSize: number) => SPPageParams;
+    /**
+     * Parse the HTTP response received from the GET request and return an object
+     * containing the total number of entities available and the array of entities
+     * for the current page. For example, for the pure DRF paginated response
+     * like below:
+     * ```json
+     * {
+     *  "count": 102,
+     *  "next": "http://api.example.org/entities/?page=3",
+     *  "previous": "http://api.example.org/entities/?page=1",
+     *  "results": [
+     *    {
+     *      "id": 1,
+     *      "name": "Entity 1"
+     *    },
+     *    {
+     *      "id": 2,
+     *      "name": "Entity 2"
+     *    }
+     *  ]
+     * }
+     * ```
+     * The implementation would be:
+     * ```typescript
+     * parseRequestResponse<TEntity extends { [P in IdKey]: PropertyKey }, IdKey extends string = 'id'>(
+     *   entityName: string,
+     *   entityNamePlural: string,
+     *   endpoint: string,
+     *   params: SPPageParams,
+     *   resp: any
+     * ): { total: number; entities: TEntity[] } {
+     *   return {
+     *     total: resp.count,
+     *     entities: resp.results
+     *   };
+     * }
+     * ```
+     * @param entityName
+     * @param entityNamePlural
+     * @param endpoint
+     * @param params
+     * @param resp
+     * @returns
+     */
+    parseRequestResponse: <TEntity extends {
+        [P in IdKey]: PropertyKey;
+    }, IdKey extends string = 'id'>(entityName: string, entityNamePlural: string, endpoint: string, params: SPPageParams, resp: any) => {
+        total: number;
+        entities: TEntity[];
+    };
+}
+/**
+ * 'entity' is really TEntity arg of SPMatEntityListComponent<TEntity>.
+ * 'column' is the column name. This allows the same value function to support
+ * multiple columns further enabing DRY.
+ */
+type COLUMN_VALUE_FN = (entity: any, column: string) => string | number | Date | boolean;
+/**
+ * Global config for SPMatEntityList component.
+ */
+interface SPMatEntityListConfig {
+    urlResolver?: (endpoint: string) => string;
+    paginator?: SPMatEntityListPaginator;
+    defaultPageSize?: number;
+    pageSizes?: Array<number>;
+    /**
+     * Provide a method to return the labels for the columns. This is useful when
+     * the columns are specified as the JSON object key names and the labels are
+     * to be transformed into a uniform manner (uppercase) or when the labels
+     * are to be dynamically localized. Note that the response can be an
+     * Observable<string> if the label is to be fetched/changed asynchronously
+     * (as that can happen in an app that supports dynamic changing of the UI
+     * language).
+     * @param entityName
+     * @param columnName
+     * @returns
+     */
+    columnLabelFn?: (entityName: string, columnName: string) => string | Observable<string>;
+}
+/**
+ * Type for custom entities loader function, which if provided will be called
+ * instead of HttpClient.get.
+ */
+type SPMatEntityListEntityLoaderFn = (params: any) => Observable<any>;
+
+declare const SP_MAT_ENTITY_LIST_CONFIG: InjectionToken<SPMatEntityListConfig>;
+
+declare class HeaderAlignmentDirective implements AfterViewInit {
+    private el;
+    headerAlignment: _angular_core.InputSignal<string | undefined>;
+    constructor(el: ElementRef);
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeaderAlignmentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HeaderAlignmentDirective, "[headerAlignment]", never, { "headerAlignment": { "alias": "headerAlignment"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Represents a request to load entities from the remote. This is used to
+ * compare two requests to determine if they are equal. This is useful to
+ * prevent duplicate requests being sent to the remote.
+ */
+declare class LoadRequest {
+    endpoint: string;
+    params: HttpParams;
+    force: boolean;
+    constructor(endpoint: string, params: HttpParams, force?: boolean);
+    isEqualToAndNotForced(prev: LoadRequest): boolean;
+}
+/**
+ * A component to display a list of entities loaded from remote.
+ */
+declare class SPMatEntityListComponent<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> implements OnInit, OnDestroy, AfterViewInit {
+    protected http: HttpClient;
+    private sanitizer;
+    private injector;
+    entityName: _angular_core.InputSignal<string>;
+    entityNamePlural: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The endpoint from where the entities are to be retrieved
+     */
+    endpoint: _angular_core.InputSignal<string>;
+    /**
+     * Custom entities loader function, which if provided will be called
+     * instead of HttpClient.get.
+     */
+    entityLoaderFn: _angular_core.InputSignal<SPMatEntityListEntityLoaderFn | undefined>;
+    /**
+     * The columns of the entity to be displayed. This is an array of
+     * SPEntityFieldSpec objects. If there's a one-to-one mapping between the
+     * column's field name, its title & the rendered value, a string can be
+     * specified instead. That is, the value of this property is a heterogeneous
+     * array consisting of SPEntityFieldSpec<> objects and strings.
+     */
+    columns: _angular_core.InputSignal<(string | SPEntityFieldSpec<TEntity, IdKey>)[]>;
+    /**
+     * Names of columns that are displayed. This will default to all the columns
+     * listed in columns.
+     */
+    displayedColumns: _angular_core.InputSignal<string[]>;
+    /**
+     * Number of entities per page. If this is not set and paginator is defined,
+     * the number of entities int in the first request, will be taken as the
+     * page size.
+     */
+    pageSize: _angular_core.InputSignal<number>;
+    /**
+     * Entity idKey, if idKey is different from the default 'id'.
+     */
+    idKey: _angular_core.InputSignal<string>;
+    /**
+     * Type of pagination -- continuous or discrete. 'infinite' pagination
+     * uses an 'infiniteScroll' and 'discrete' pagination uses a mat-paginator
+     * at the bottom to navigate between pages.
+     */
+    pagination: _angular_core.InputSignal<"infinite" | "discrete" | "none">;
+    /**
+     * Component specific paginator. Only used if pagination != 'none'.
+     */
+    paginator: _angular_core.InputSignal<SPMatEntityListPaginator | undefined>;
+    /**
+     *
+     */
+    sorter: _angular_core.InputSignal<MatSort | undefined>;
+    /**
+     * Disable sorting of rows
+     */
+    disableSort: _angular_core.InputSignal<boolean>;
+    /**
+     * Wrappers for infiniteScroll properties, for customization by the client
+     */
+    infiniteScrollContainer: _angular_core.InputSignal<any>;
+    infiniteScrollDistance: _angular_core.InputSignal<number>;
+    infiniteScrollThrottle: _angular_core.InputSignal<number>;
+    infiniteScrollWindow: _angular_core.InputSignal<boolean>;
+    /**
+     * Custom context to be set for HttpClient requests. Value for this attribute
+     * can be an array of HttpContextToken key, value pairs, or an instance of
+     * HttpContext.
+     *
+     * In the client code specify this property by initializing a member variable
+     *  as:
+  
+        ```
+        Component({
+          ...
+          template: `
+            <sp-mat-entity-list
+              [httpReqContext]="httpReqContext"
+            ></sp-mat-entity-list>
+          `
+        })
+        export class YourComponent {
+          httpReqContext: [HttpContextToken<any>, any] = [
+            MY_CONTEXT_TOKEN, 'customers'
+          ];
+          // Or [httpReqContext]="httpReqContext2" will work too.
+          httpReqContext2: HttpContext = new HttpContext().set(
+            MY_CONTEXT_TOKEN, 'customers'
+          );
+        }
+        ```
+     *
+     * Of course if you want to pass multiple context properties, declare the type
+     * as an array of array. That is, `[[HttpContextToken<any>, any]]` and
+     * initialize it appropriately.
+     */
+    httpReqContext: _angular_core.InputSignal<[HttpContextToken<any>, any] | [[HttpContextToken<any>, any]] | HttpContext | undefined>;
+    _entityNamePlural: _angular_core.Signal<string>;
+    _httpReqContext: _angular_core.Signal<HttpContext>;
+    deferViewInit: _angular_core.InputSignal<boolean>;
+    firstLoadDone: boolean;
+    allColumnNames: _angular_core.WritableSignal<string[]>;
+    _displayedColumns: _angular_core.Signal<string[]>;
+    dataSource: _angular_core.WritableSignal<MatTableDataSource<TEntity, _angular_material_paginator.MatPaginator>>;
+    table: _angular_core.Signal<MatTable<any> | undefined>;
+    sort: _angular_core.Signal<MatSort | undefined>;
+    viewColumnDefs: _angular_core.Signal<readonly MatColumnDef[]>;
+    clientColumnDefs: QueryList<MatColumnDef>;
+    contentColumnDefs: MatColumnDef[];
+    subs$: Subscription;
+    destroy$: Subject<void>;
+    entityCount: _angular_core.WritableSignal<number>;
+    pageIndex: _angular_core.WritableSignal<number>;
+    lastFetchedEntitiesCount: _angular_core.WritableSignal<number>;
+    _pageSize: _angular_core.Signal<number>;
+    _columns: _angular_core.Signal<SPEntityFieldSpec<TEntity, IdKey>[]>;
+    __columns: _angular_core.Signal<SPEntityField<TEntity, IdKey>[]>;
+    store: _ngneat_elf.Store<{
+        name: string;
+        state: {
+            entities: Record<TEntity[IdKey], TEntity>;
+            ids: TEntity[IdKey][];
+        };
+        config: {
+            idKey: IdKey;
+        };
+    }, {
+        entities: Record<TEntity[IdKey], TEntity>;
+        ids: TEntity[IdKey][];
+    }>;
+    entities$: Observable<TEntity[]>;
+    _paginator: SPMatEntityListPaginator | undefined;
+    loading: _angular_core.WritableSignal<boolean>;
+    hasMore: _angular_core.WritableSignal<boolean>;
+    activeEntity: _angular_core.WritableSignal<TEntity | undefined>;
+    activeEntityId: _angular_core.Signal<any>;
+    _prevActiveEntity: TEntity | undefined;
+    _activeEntityChange: _angular_core.EffectRef;
+    selectEntity: EventEmitter<TEntity | undefined>;
+    fieldConfig: _smallpearl_ngx_helper_entity_field.SPEntityFieldConfig;
+    entityListConfig: _smallpearl_ngx_helper_mat_entity_list.SPMatEntityListConfig;
+    /**
+     * A signal that can be used to trigger loading of more entities from the
+     * remote. This can be visualized as the event loop of the entity list
+     * component.
+     */
+    loadRequest$: Subject<LoadRequest>;
+    endpointChanged: _angular_core.EffectRef;
+    constructor(http: HttpClient, sanitizer: DomSanitizer, injector: Injector);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    /**
+     * Clear all entities in store and reload them from endpoint as if
+     * the entities are being loaded for the first time.
+     */
+    refresh(force?: boolean): void;
+    addEntity(entity: TEntity): void;
+    /**
+     * Update an entity with a modified version. Can be used by CRUD UPDATE
+     * operation to update an entity in the local store that is used to as the
+     * source of MatTableDataSource.
+     * @param id
+     * @param entity
+     */
+    updateEntity(id: TEntity[IdKey], entity: TEntity): void;
+    /**
+     * Clients can call this method when it has deleted and entity via a CRUD
+     * operation. Depending on the pagination mode, MatEntityList implements
+     * an appropriate behavior.
+     *
+     * If the pagination is 'infinite', the relevent entity is removed from our
+     * entity list. View will be repained as data store has changed.
+     *
+     * If the pagination is 'discrete', the entity is removed from the page.
+     * If this is the only entity in the page, the current pageNumber is
+     * decremented by 1 if it's possible (if the current pageNumber > 1).
+     * The page is reloaded from remote.
+     */
+    removeEntity(id: TEntity[IdKey]): void;
+    /**
+     * Build the contentColumnDefs array by enumerating all of client's projected
+     * content with matColumnDef directive.
+     */
+    buildContentColumnDefs(): void;
+    /**
+     * Build the effective columns by parsing our own <ng-container matColumnDef>
+     * statements for each column in columns() property and client's
+     * <ng-container matColumnDef> provided via content projection.
+     */
+    buildColumns(): void;
+    setupSort(): void;
+    infiniteScrollLoadNextPage(ev: any): void;
+    loadMoreEntities(forceRefresh?: boolean): void;
+    /**
+     * Creates a LoadRequest object for loading entities using the current state
+     * of the component. Therefore, if the request is for next page of entities,
+     * the LoadRequest object will have the updated page index. However, if
+     * pagination has been reset (refer to refresh()), the LoadRequest object
+     * will be for the first page of data. Note that when 'endpoint' value
+     * changes, the component's pagination state is reset causing a refresh()
+     * to be called, which in turn will create a new LoadRequest object for the
+     * first page of data.
+     * @returns LoadRequest object for the next load request.
+     */
+    private createNextLoadRequest;
+    /**
+     * Does the actual load of entities from the remote or via calling the
+     * entityLoaderFn. This method is the workhorse of the entity list
+     * 'loader-loop'.
+     * @param lr
+     * @returns Observable that emits the response from the remote or from
+     * entityLoaderFn().
+     */
+    private doActualLoad;
+    private findArrayInResult;
+    handlePageEvent(e: PageEvent): void;
+    getUrl(endpoint: string): string;
+    toggleActiveEntity(entity: TEntity | undefined): void;
+    getColumnLabel(field: SPEntityField<TEntity, IdKey>): Observable<string>;
+    isAsync(val: any): val is Observable<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SPMatEntityListComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SPMatEntityListComponent<any, any>, "sp-mat-entity-list", never, { "entityName": { "alias": "entityName"; "required": true; "isSignal": true; }; "entityNamePlural": { "alias": "entityNamePlural"; "required": false; "isSignal": true; }; "endpoint": { "alias": "endpoint"; "required": false; "isSignal": true; }; "entityLoaderFn": { "alias": "entityLoaderFn"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "idKey": { "alias": "idKey"; "required": false; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": false; "isSignal": true; }; "paginator": { "alias": "paginator"; "required": false; "isSignal": true; }; "sorter": { "alias": "sorter"; "required": false; "isSignal": true; }; "disableSort": { "alias": "disableSort"; "required": false; "isSignal": true; }; "infiniteScrollContainer": { "alias": "infiniteScrollContainer"; "required": false; "isSignal": true; }; "infiniteScrollDistance": { "alias": "infiniteScrollDistance"; "required": false; "isSignal": true; }; "infiniteScrollThrottle": { "alias": "infiniteScrollThrottle"; "required": false; "isSignal": true; }; "infiniteScrollWindow": { "alias": "infiniteScrollWindow"; "required": false; "isSignal": true; }; "httpReqContext": { "alias": "httpReqContext"; "required": false; "isSignal": true; }; "deferViewInit": { "alias": "deferViewInit"; "required": false; "isSignal": true; }; }, { "selectEntity": "selectEntity"; }, ["clientColumnDefs"], never, true, never>;
+}
+
+export { HeaderAlignmentDirective, SPMatEntityListComponent, SP_MAT_ENTITY_LIST_CONFIG, SP_MAT_ENTITY_LIST_HTTP_CONTEXT };
+export type { COLUMN_VALUE_FN, SPMatEntityListConfig, SPMatEntityListEntityLoaderFn, SPMatEntityListHttpContext, SPMatEntityListPaginator, SPPageParams };

package/mat-file-input/index.d.ts

@@ -1 +1,61 @@
-export * from './src/mat-file-input.component';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ElementRef } from '@angular/core';
+import { ControlValueAccessor, NgControl, UntypedFormControl } from '@angular/forms';
+import { MatFormFieldControl, MatFormField } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+
+declare class QQMatFileInputComponent implements ControlValueAccessor, MatFormFieldControl<File[]>, OnInit, OnDestroy {
+    _formField: MatFormField;
+    ngControl: NgControl;
+    accept: string;
+    thumbnailImageUrl: string;
+    imageFile: boolean;
+    _fileName: string;
+    inputFileUpload: ElementRef | undefined;
+    fileControl: UntypedFormControl;
+    static nextId: number;
+    stateChanges: Subject<void>;
+    focused: boolean;
+    errorState: boolean;
+    controlType: string;
+    id: string;
+    describedBy: string;
+    private _multiple;
+    ariaDescribedby: string | undefined;
+    _value: File[] | null;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    get acceptedFileTypes(): string;
+    get multiple(): boolean;
+    set multiple(value: boolean | string);
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    private _disabled;
+    private destroy$;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get fileName(): string;
+    get value(): File[] | null;
+    set value(files: File[] | string | null);
+    constructor(_formField: MatFormField, ngControl: NgControl);
+    setDescribedByIds(ids: string[]): void;
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    onContainerClick(event: MouseEvent | KeyboardEvent): void;
+    writeValue(files: File[]): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    onTouched: () => void;
+    setDisabledState(isDisabled: boolean): void;
+    onFileSelected(event: any): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    generateLocalThumbnail(file: File): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QQMatFileInputComponent, [{ optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QQMatFileInputComponent, "qq-mat-file-input", never, { "accept": { "alias": "accept"; "required": false; }; "thumbnailImageUrl": { "alias": "thumbnailImageUrl"; "required": false; }; "imageFile": { "alias": "imageFile"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { QQMatFileInputComponent };

package/mat-form-error/index.d.ts

@@ -1,6 +1,184 @@
-export * from './src/locales';
-export * from './src/ngx-mat-error-def.directive';
-export * from './src/ngx-mat-errors-for-date-range-picker.directive';
-export * from './src/ngx-mat-errors.component';
-export * from './src/ngx-error-list.component';
-export type * from './src/types';
+import * as i0 from '@angular/core';
+import { TemplateRef, FactoryProvider, InjectionToken, OnDestroy, QueryList } from '@angular/core';
+import { ValidationErrors, AbstractControl, AbstractControlDirective } from '@angular/forms';
+import * as _angular_material_form_field from '@angular/material/form-field';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import * as _angular_material_datepicker from '@angular/material/datepicker';
+import { Observable } from 'rxjs';
+
+type ErrorTemplate = {
+    template: TemplateRef<any>;
+    $implicit: ValidationErrors;
+} | {
+    template: undefined;
+    $implicit: string | string[];
+} | undefined;
+type FormFieldControl = Pick<MatFormFieldControl<any>, 'ngControl'>;
+type NgxMatErrorControls = FormFieldControl | AbstractControl | AbstractControlDirective | (FormFieldControl | AbstractControl | AbstractControlDirective)[] | undefined | null | '';
+type ErrorTransform = (error: any) => string;
+interface ErrorMessages {
+    [key: string]: string | ErrorTransform;
+}
+/**
+ * For errors: 'min', 'matDatepickerMin'
+ */
+interface MinError<T = number> {
+    min: T;
+    actual: T;
+}
+/**
+ * For errors: 'max', 'matDatepickerMax'
+ */
+interface MaxError<T = number> {
+    max: T;
+    actual: T;
+}
+/**
+ * For errors: 'minlength', 'maxlength'
+ */
+interface LengthError {
+    requiredLength: number;
+    actualLength: number;
+}
+/**
+ * For errors: 'pattern'
+ */
+interface PatternValidator {
+    requiredPattern: string;
+    actualValue: string;
+}
+/**
+ * For errors: 'matStartDateInvalid'
+ */
+interface StartDateError<D> {
+    end: D;
+    actual: D;
+}
+/**
+ * For errors: 'matEndDateInvalid'
+ */
+interface EndDateError<D> {
+    start: D;
+    actual: D;
+}
+/**
+ * For errors: 'matDatepickerParse', 'matTimepickerParse'
+ */
+interface ParseError {
+    text: string;
+}
+/**
+ * @deprecated to be removed in version 20. Please use ParseError instead
+ */
+type DatepickerParseError = ParseError;
+
+declare function errorMessagesEnFactory(locale: string, dateFormat?: string, timeFormat?: string): ErrorMessages;
+declare const NGX_MAT_ERROR_CONFIG_EN: FactoryProvider;
+
+declare function errorMessagesHuFactory(locale: string, dateFormat?: string, timeFormat?: string): ErrorMessages;
+declare const NGX_MAT_ERROR_CONFIG_HU: FactoryProvider;
+
+declare function errorMessagesPtBtFactory(locale: string, dateFormat?: string, timeFormat?: string): ErrorMessages;
+declare const NGX_MAT_ERROR_CONFIG_PT_BR: FactoryProvider;
+
+declare function errorMessagesZhHansFactory(locale: string, dateFormat?: string, timeFormat?: string): ErrorMessages;
+declare const NGX_MAT_ERROR_CONFIG_ZH_HANS: FactoryProvider;
+
+declare function errorMessagesZhHantFactory(locale: string, dateFormat?: string, timeFormat?: string): ErrorMessages;
+declare const NGX_MAT_ERROR_CONFIG_ZH_HANT: FactoryProvider;
+
+interface INgxMatErrorDef {
+    ngxMatErrorDefFor: string;
+    ngxMatErrorDefWithControl?: AbstractControlDirective | AbstractControl | string | null;
+    template: TemplateRef<any>;
+    control?: AbstractControl;
+}
+/**
+ * Lightweight injection token. When NgxMatErrorDef is not used, only this token will remain, the directive will be tree-shaken.
+ */
+declare const NGX_MAT_ERROR_DEF: InjectionToken<INgxMatErrorDef>;
+declare class NgxMatErrorDef implements INgxMatErrorDef {
+    /**
+     * Specify the error key to be used for error matching.
+     * @required
+     */
+    ngxMatErrorDefFor: string;
+    /**
+     * Specify the control to be used for error matching.
+     * @optional
+     */
+    ngxMatErrorDefWithControl?: AbstractControlDirective | AbstractControl | string | null;
+    readonly template: TemplateRef<any>;
+    private readonly controlContainer;
+    get control(): AbstractControl | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatErrorDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxMatErrorDef, "[ngxMatErrorDef]", never, { "ngxMatErrorDefFor": { "alias": "ngxMatErrorDefFor"; "required": true; }; "ngxMatErrorDefWithControl": { "alias": "ngxMatErrorDefWithControl"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * This class contains the logic of getting the default control of a MatFormField.
+ * Extend it to implement a custom getter method.
+ */
+declare class NgxMatErrorControl {
+    protected readonly matFormField: _angular_material_form_field.MatFormField | null;
+    get(): undefined | FormFieldControl | FormFieldControl[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatErrorControl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxMatErrorControl>;
+}
+
+declare class NgxMatErrorsForDateRangePicker<D> extends NgxMatErrorControl {
+    /** Returns start and end controls of the date range picker. */
+    get(): (_angular_material_datepicker.MatStartDate<D> | _angular_material_datepicker.MatEndDate<D>)[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatErrorsForDateRangePicker<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxMatErrorsForDateRangePicker<any>, "[ngx-mat-errors][forDateRangePicker]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Default error messages for form controls. These messages can be overridden
+ * by providing custom messages using the {@link NGX_MAT_ERROR_ADDL_OPTIONS}
+ * injection token. Typically, this is initialized in the root module
+ * (or AppComponent) of the application, providing the app with a global set
+ * of validation error messages.
+ *
+ * Messages specific to each form can be provided using the
+ * {@link NGX_MAT_ERROR_ADDL_OPTIONS} injection token (see below).
+ */
+declare const NGX_MAT_ERROR_DEFAULT_OPTIONS: InjectionToken<ErrorMessages | Observable<ErrorMessages>>;
+/**
+ * Additional error messages to be merged with the default error messages.
+ * These messages will override the default messages if the same key is
+ * provided. This is useful for adding custom error messages specific to a
+ * form, without having to redefine all the default messages.
+ *
+ * Typically, this is provided in the component or module where the form
+ * is defined.
+ */
+declare const NGX_MAT_ERROR_ADDL_OPTIONS: InjectionToken<ErrorMessages | Observable<ErrorMessages>>;
+declare class NgxMatErrors implements OnDestroy {
+    private readonly messages$;
+    private readonly addlMessages$;
+    private readonly defaultControl;
+    private readonly controlChangedSubject;
+    protected error$: Observable<ErrorTemplate>;
+    protected set customErrorMessages(queryList: QueryList<INgxMatErrorDef>);
+    /**
+     * @deprecated will be changed to a signal and it won't be possible to set the property from TS.
+     * Instead of setting it in a directive, the directive should extend the {@link NgxMatErrorControl } class
+     * and provide itself as it.
+     */
+    set control(control: NgxMatErrorControls);
+    /** @ignore */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatErrors, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxMatErrors, "ngx-mat-errors, [ngx-mat-errors]", never, { "control": { "alias": "ngx-mat-errors"; "required": false; }; }, {}, ["customErrorMessages"], never, true, never>;
+}
+
+declare class NgxErrorList extends NgxMatErrors {
+    isArray(e: string | string[]): e is string[];
+    set control(control: NgxMatErrorControls);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxErrorList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxErrorList, "ngx-error-list, [ngx-error-list]", never, { "control": { "alias": "ngx-error-list"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { NGX_MAT_ERROR_ADDL_OPTIONS, NGX_MAT_ERROR_CONFIG_EN, NGX_MAT_ERROR_CONFIG_HU, NGX_MAT_ERROR_CONFIG_PT_BR, NGX_MAT_ERROR_CONFIG_ZH_HANS, NGX_MAT_ERROR_CONFIG_ZH_HANT, NGX_MAT_ERROR_DEF, NGX_MAT_ERROR_DEFAULT_OPTIONS, NgxErrorList, NgxMatErrorDef, NgxMatErrors, NgxMatErrorsForDateRangePicker, errorMessagesEnFactory, errorMessagesHuFactory, errorMessagesPtBtFactory, errorMessagesZhHansFactory, errorMessagesZhHantFactory };
+export type { DatepickerParseError, EndDateError, ErrorMessages, ErrorTemplate, ErrorTransform, FormFieldControl, INgxMatErrorDef, LengthError, MaxError, MinError, NgxMatErrorControls, ParseError, PatternValidator, StartDateError };