@enigmatry/entry-components 19.0.1-preview.5 → 20.0.1-preview.1

package/README.md

@@ -29,6 +29,7 @@ These guides provides detailed steps for setting up and configuring theming with
 |17.x| = 17
 |18.x| = 18
 |19.x| = 19
+|20.x| = 20
 
 ## License
 

package/button/index.d.ts

@@ -1,5 +1,56 @@
+import * as i0 from '@angular/core';
+import { OnInit, Provider } from '@angular/core';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/material/button';
+import { ThemePalette } from '@angular/material/core';
+
+declare class EntryButtonDirective implements OnInit {
+    matClasses: {
+        [key: string]: string[];
+    };
+    private readonly _elementRef;
+    private readonly _config;
+    private readonly _matButton;
+    private readonly _matAnchor;
+    ngOnInit(): void;
+    private readonly getEntryType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EntryButtonDirective, "[mat-button][entry-submit-button],[mat-button][entry-cancel-button]", never, {}, {}, never, never, false, never>;
+}
+
+declare class EntryButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EntryButtonModule, [typeof EntryButtonDirective], [typeof i2.CommonModule, typeof i3.MatButtonModule], [typeof EntryButtonDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EntryButtonModule>;
+}
+
+/** Possible mat button variants */
+declare type MatButtonVariants = 'basic' | 'flat' | 'raised' | 'stroked';
+interface MatButtonConfig {
+    type: MatButtonVariants;
+    color?: ThemePalette;
+}
 /**
- * Generated bundle index. Do not edit.
+ * Used to provide button configuration on module or application level.
  */
-/// <amd-module name="@enigmatry/entry-components/button" />
-export * from './public-api';
+declare class EntryButtonConfig {
+    /** Submit button configuration */
+    submit: MatButtonConfig;
+    /** Cancel button configuration */
+    cancel: MatButtonConfig;
+    constructor(config?: Partial<EntryButtonConfig>);
+}
+/**
+ * Entry button config injection token.
+ *
+ * Defaults:
+ * - submit: type: 'flat', color: 'primary'
+ * - cancel: type: 'basic', color: 'accent'
+ */
+declare const ENTRY_BUTTON_CONFIG: i0.InjectionToken<EntryButtonConfig>;
+/**
+ * Can be used to provide custom button configuration.
+ */
+declare const provideEntryButtonConfig: (config: Partial<EntryButtonConfig>) => Provider;
+
+export { ENTRY_BUTTON_CONFIG, EntryButtonConfig, EntryButtonDirective, EntryButtonModule, provideEntryButtonConfig };

package/common/index.d.ts

@@ -1,5 +1,245 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ModuleWithProviders, Provider, InjectionToken } from '@angular/core';
+import * as i1 from '@angular/common';
+import { NumberInput } from '@angular/cdk/coercion';
+import { ControlValueAccessor, UntypedFormControl, NgControl } from '@angular/forms';
+import { EventManager } from '@angular/platform-browser';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpInterceptorFn } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { DateAdapter, MatDateFormats } from '@angular/material/core';
+
 /**
- * Generated bundle index. Do not edit.
+ * Auto disable button after click or submit with entry-auto-disable directive.
+ * Directive is applied to 'button[entry-auto-disable]:not([disabled])'
+ * Default auto disable interval is 2000ms (2sec)
+ *
+ * Usage
+ * <button mat-button entry-submit-button entry-auto-disable type="submit">Submit</button>
+ * or with auto disabled interval in milliseconds
+ * <button mat-button entry-submit-button entry-auto-disable="5000" type="submit">Submit</button>
  */
-/// <amd-module name="@enigmatry/entry-components/common" />
-export * from './public-api';
+declare class AutoDisableButtonDirective implements OnInit, OnDestroy {
+    private _destroy$;
+    private _disableIntervalInMs;
+    private readonly elementRef;
+    get disableIntervalInMs(): NumberInput;
+    set disableIntervalInMs(value: NumberInput);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private disableButton;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoDisableButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoDisableButtonDirective, "button[entry-auto-disable]:not([disabled])", never, { "disableIntervalInMs": { "alias": "entry-auto-disable"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Scroll to first invalid control when form is submitted.
+ * Directive is applied to 'form[formGroup],form[ngForm]' (reactive or template driven forms)
+ */
+declare class ScrollToInvalidControlDirective implements OnInit, OnDestroy {
+    private destroy$;
+    private readonly form;
+    private readonly elementRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private scrollToInvalidControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollToInvalidControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollToInvalidControlDirective, "form[formGroup],form[ngForm]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NoopControlValueAccessorDirective implements ControlValueAccessor {
+    writeValue: (_obj: any) => void;
+    registerOnChange: (_fn: any) => void;
+    registerOnTouched: (_fn: any) => void;
+    setDisabledState: (_isDisabled: boolean) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoopControlValueAccessorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NoopControlValueAccessorDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class NgControlAccessorDirective implements OnDestroy, OnInit {
+    control: UntypedFormControl;
+    ngControl: NgControl | null;
+    private destroy$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgControlAccessorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgControlAccessorDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare const NG_EVENT_PLUGINS: Provider[];
+declare class EntryCommonModule {
+    static forRoot(): ModuleWithProviders<EntryCommonModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryCommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EntryCommonModule, never, [typeof i1.CommonModule, typeof AutoDisableButtonDirective, typeof ScrollToInvalidControlDirective, typeof NoopControlValueAccessorDirective, typeof NgControlAccessorDirective], [typeof AutoDisableButtonDirective, typeof ScrollToInvalidControlDirective, typeof NoopControlValueAccessorDirective, typeof NgControlAccessorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EntryCommonModule>;
+}
+
+declare const createInjectionToken: <T>(defaultValue: T) => InjectionToken<T>;
+declare const provideConfig: <T>(token: InjectionToken<T>, factory: () => T) => Provider;
+
+/**
+ * abstract class EventManagerPlugin will be exposed in the public api
+ * https://github.com/angular/angular/pull/49969
+ *
+ * Until then creating it from reference
+ * https://github.com/angular/angular/blob/main/packages/platform-browser/src/dom/events/event_manager.ts#L93
+ *
+ * How to create custom event modifiers
+ * https://github.com/Tinkoff/ng-event-plugins,
+ * https://github.com/angular/angular/blob/main/packages/platform-browser/src/dom/events/key_events.ts
+ * https://netbasal.com/lifting-the-veil-insights-into-angulars-eventmanagerplugin-ed9d14cbb31a
+ */
+declare abstract class EventManagerPlugin {
+    manager: EventManager;
+    /** Should return `true` for every event name that should be supported by this plugin */
+    abstract supports(eventName: string): boolean;
+    /**
+     * Registers a handler for a specific element and event.
+     *
+     * @param element The HTML element to receive event notifications.
+     * @param eventName The name of the event to listen for.
+     * @param handler A function to call when the notification occurs. Receives the
+     * event object as an argument.
+     * @returns  A callback function that can be used to remove the handler.
+     */
+    abstract addEventListener(element: HTMLElement, eventName: string, handler: Function): Function;
+}
+
+/**
+ * Entry event plugin base class
+ */
+declare abstract class EntryEventManagerPlugin extends EventManagerPlugin {
+    abstract modifier: string;
+    /** return `true` for every event name that has specified modifier */
+    supports(eventName: string): boolean;
+    /** unwrap params e.g. (click.debounce.500) => ['debounce', 500] */
+    unwrapParams(eventName: string): string[];
+    /** get event name e.g. (click.debounce.500) => click */
+    unwrapEventName(eventName: string): string;
+}
+
+/**
+ * Provides event plugin for throttling events.
+ *
+ * How to use:
+ * <button (click.throttle)="doSomething($event)">
+ * <input (keyup.throttle.500)="doSomething($event)">
+ */
+declare class ThrottleEventPlugin extends EntryEventManagerPlugin {
+    modifier: string;
+    addEventListener(element: HTMLElement, eventName: string, originalHandler: Function): Function;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThrottleEventPlugin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThrottleEventPlugin>;
+}
+
+/**
+ * Provides event plugin for debouncing events.
+ *
+ * How to use:
+ * <button (click.debounce)="doSomething($event)">
+ * <input (keyup.debounce.500)="doSomething($event)">
+ */
+declare class DebounceEventPlugin extends EntryEventManagerPlugin {
+    modifier: string;
+    addEventListener(element: HTMLElement, eventName: string, originalHandler: Function): Function;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebounceEventPlugin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DebounceEventPlugin>;
+}
+
+/**
+ * @deprecated switch to acceptLanguageInterceptor function (See: https://angular.dev/guide/http/interceptors#configuring-interceptors)
+ */
+declare class AcceptLanguageInterceptor implements HttpInterceptor {
+    private localeId;
+    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AcceptLanguageInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AcceptLanguageInterceptor>;
+}
+/**
+ * Sets the Accept-Language HTTP request header using the value from LOCALE_ID.
+ */
+declare const acceptLanguageInterceptor: HttpInterceptorFn;
+
+declare abstract class EntryTimeAdapter<D> {
+    abstract getHours(date: D): number;
+    abstract getMinutes(date: D): number;
+    abstract getSeconds(date: D): number;
+    abstract setTime(date: D, hours: number, minutes: number, seconds: number): D;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryTimeAdapter<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntryTimeAdapter<any>>;
+}
+
+/**
+ * Extends DateAdapter with time support. Used by EntryDateTimePicker component.
+ */
+declare class EntryDateTimeAdapter<D, L> extends DateAdapter<D, L> implements EntryTimeAdapter<D> {
+    private readonly dateAdapter;
+    private readonly timeAdapter;
+    constructor(matDateLocale: L, dateAdapter: DateAdapter<D, L>, timeAdapter: EntryTimeAdapter<D>);
+    getYear(date: D): number;
+    getMonth(date: D): number;
+    getDate(date: D): number;
+    getDayOfWeek(date: D): number;
+    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    getDateNames(): string[];
+    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    getYearName(date: D): string;
+    getFirstDayOfWeek(): number;
+    getNumDaysInMonth(date: D): number;
+    clone(date: D): D;
+    createDate(year: number, month: number, date: number): D;
+    today(): D;
+    parse(value: any, parseFormat: any): D;
+    format(date: D, displayFormat: any): string;
+    addCalendarYears(date: D, years: number): D;
+    addCalendarMonths(date: D, months: number): D;
+    addCalendarDays(date: D, days: number): D;
+    toIso8601(date: D): string;
+    isDateInstance(obj: any): boolean;
+    isValid(date: D): boolean;
+    invalid(): D;
+    getHours(date: D): number;
+    getMinutes(date: D): number;
+    getSeconds(date: D): number;
+    setTime(date: D, hours: number, minutes: number, seconds: number): D;
+    is12HoursClock(displayFormat: any): boolean;
+    compareDate(first: D, second: D): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryDateTimeAdapter<any, any>, [{ optional: true; }, { skipSelf: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntryDateTimeAdapter<any, any>>;
+}
+
+type EntryDateTimeFormats = MatDateFormats;
+declare const defaultDateTimeFormats: {
+    parse: {
+        dateInput: string[];
+    };
+    display: {
+        dateInput: string;
+        monthYearLabel: {
+            year: string;
+            month: string;
+        };
+        dateA11yLabel: {
+            year: string;
+            month: string;
+            day: string;
+        };
+        monthYearA11yLabel: {
+            year: string;
+            month: string;
+        };
+    };
+};
+declare const ENTRY_MAT_DATE_TIME_FORMATS: InjectionToken<MatDateFormats>;
+
+declare class EntryNativeTimeAdapter extends EntryTimeAdapter<Date> {
+    getHours: (date: Date) => number;
+    getMinutes: (date: Date) => number;
+    getSeconds: (date: Date) => number;
+    setTime: (date: Date, hours: number, minutes: number, seconds: number) => Date;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryNativeTimeAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntryNativeTimeAdapter>;
+}
+declare const provideEntryNativeTimeAdapter: (dateTimeFormats?: EntryDateTimeFormats) => Provider[];
+
+export { AcceptLanguageInterceptor, AutoDisableButtonDirective, DebounceEventPlugin, ENTRY_MAT_DATE_TIME_FORMATS, EntryCommonModule, EntryDateTimeAdapter, EntryNativeTimeAdapter, EntryTimeAdapter, NG_EVENT_PLUGINS, NgControlAccessorDirective, NoopControlValueAccessorDirective, ScrollToInvalidControlDirective, ThrottleEventPlugin, acceptLanguageInterceptor, createInjectionToken, defaultDateTimeFormats, provideConfig, provideEntryNativeTimeAdapter };
+export type { EntryDateTimeFormats };

package/date-time-picker/index.d.ts

@@ -1,5 +1,102 @@
+import * as i0 from '@angular/core';
+import { Provider, OnChanges, SimpleChanges, OnInit, OnDestroy } from '@angular/core';
+import * as i4 from '@angular/forms';
+import { FormControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import * as i1 from '@enigmatry/entry-components/common';
+import { EntryDateTimeAdapter } from '@enigmatry/entry-components/common';
+import * as i3 from '@angular/common';
+import * as i5 from '@angular/material/form-field';
+import * as i6 from '@angular/material/datepicker';
+import * as i7 from '@angular/material/input';
+import * as i8 from '@angular/material/select';
+import * as i9 from '@angular/material/button';
+import * as i10 from '@angular/material/icon';
+import * as i11 from '@enigmatry/entry-components/validation';
+
 /**
- * Generated bundle index. Do not edit.
+ * Used to provide default configurations on module level.
  */
-/// <amd-module name="@enigmatry/entry-components/date-time-picker" />
-export * from './public-api';
+declare class EntryDateTimePickerConfig {
+    /** Shows seconds selector in date-time-picker pop-up (default false) */
+    showSeconds: boolean;
+    constructor(config?: Partial<EntryDateTimePickerConfig>);
+}
+/**
+ * Entry date-time-picker injection token of EntryDateTimePickerConfig type containing dialog default configurations.
+ *
+ * Defaults:
+ * - showSeconds: false
+ */
+declare const ENTRY_DATE_TIME_PICKER_CONFIG: i0.InjectionToken<EntryDateTimePickerConfig>;
+/**
+ * Can be used to provide entry date-time-picker configuration.
+ */
+declare const provideEntryDateTimePickerConfig: (config: Partial<EntryDateTimePickerConfig>) => Provider;
+
+type meridiem = 'am' | 'pm';
+declare class EntryTimePickerComponent<D> implements OnChanges {
+    class: string;
+    readonly timeAdapter: EntryDateTimeAdapter<D, unknown>;
+    private readonly hoursInDay;
+    private readonly halfADay;
+    private readonly minutesInHour;
+    date: D | undefined;
+    showSeconds: boolean;
+    is12HourClock: boolean;
+    defaultTime: D | undefined;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    meridiem: meridiem;
+    readonly hours12: number[];
+    readonly hours24: number[];
+    readonly sixty: number[];
+    get possibleHours(): number[];
+    ngOnChanges(_changes: SimpleChanges): void;
+    update(): void;
+    to12HourClock(): void;
+    to24HourClock(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryTimePickerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntryTimePickerComponent<any>, "entry-time-picker", never, { "date": { "alias": "date"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "is12HourClock": { "alias": "is12HourClock"; "required": false; }; "defaultTime": { "alias": "defaultTime"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class EntryDateTimePickerComponent<D> implements OnInit, OnDestroy {
+    class: string;
+    label: string;
+    showSeconds: boolean | undefined;
+    min: D;
+    max: D;
+    placeholder: string | undefined;
+    hint: string | undefined;
+    defaultTime: D | undefined;
+    dateTimeChanged: Subject<D>;
+    _disabled: boolean;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private ngControlAccessor;
+    private dateTimeAdapter;
+    private format;
+    private changeDetectorRef;
+    config: EntryDateTimePickerConfig;
+    get formControl(): FormControl<D>;
+    calendarControl: FormControl<D | null | undefined>;
+    is12HourClock: boolean;
+    timePicker: EntryTimePickerComponent<D>;
+    private $destroy;
+    get minDate(): D | undefined;
+    get maxDate(): D | undefined;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryDateTimePickerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntryDateTimePickerComponent<any>, "entry-date-time-picker", never, { "label": { "alias": "label"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "defaultTime": { "alias": "defaultTime"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "dateTimeChanged": "dateTimeChanged"; }, never, never, false, [{ directive: typeof i1.NoopControlValueAccessorDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.NgControlAccessorDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class EntryDateTimePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryDateTimePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EntryDateTimePickerModule, [typeof EntryDateTimePickerComponent, typeof EntryTimePickerComponent], [typeof i3.CommonModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule, typeof i5.MatFormFieldModule, typeof i6.MatDatepickerModule, typeof i7.MatInputModule, typeof i8.MatSelectModule, typeof i9.MatButtonModule, typeof i10.MatIconModule, typeof i11.EntryValidationModule], [typeof EntryDateTimePickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EntryDateTimePickerModule>;
+}
+
+export { ENTRY_DATE_TIME_PICKER_CONFIG, EntryDateTimePickerComponent, EntryDateTimePickerConfig, EntryDateTimePickerModule, provideEntryDateTimePickerConfig };

package/dialog/index.d.ts

@@ -1,5 +1,199 @@
+import * as i6 from '@angular/material/dialog';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from '@angular/core';
+import { Provider, TemplateRef, Type } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { IValidationProblemDetails } from '@enigmatry/entry-components/validation';
+import * as i5 from '@angular/common';
+import * as i7 from '@angular/material/icon';
+import * as i8 from '@angular/material/button';
+import * as i9 from '@enigmatry/entry-components/button';
+
+/** Defines horizontal alignment of dialog buttons. */
+type EntryDialogButtonsAlignment = 'start' | 'center' | 'end';
+
 /**
- * Generated bundle index. Do not edit.
+ * Used to provide default configurations on module level.
  */
-/// <amd-module name="@enigmatry/entry-components/dialog" />
-export * from './public-api';
+declare class EntryDialogConfig {
+    /** Confirm button label (default 'Ok') */
+    confirmButtonText: string;
+    /** Cancel button label (default 'Cancel') */
+    cancelButtonText: string;
+    /** Dialog buttons horizontal alignment (default 'align-right') */
+    buttonsAlignment: EntryDialogButtonsAlignment;
+    /** Determines if close button is visible (default is true) */
+    hideClose: boolean;
+    /** Disable closing dialog when pressing escape or clicking on backdrop (default false) */
+    disableClose: boolean;
+    constructor(config?: Partial<EntryDialogConfig>);
+}
+/**
+ * Entry dialog injection token of EntryDialogConfig type containing dialog default configurations.
+ *
+ * Defaults:
+ * - confirmButtonText: 'Ok'
+ * - cancelButtonText: 'Cancel'
+ * - buttonsAlignment: 'end'
+ * - hideClose: true
+ * - disableClose: false
+ */
+declare const ENTRY_DIALOG_CONFIG: i0.InjectionToken<EntryDialogConfig>;
+/**
+ * Can be used to provide entry dialog configuration.
+ */
+declare const provideEntryDialogConfig: (config: Partial<EntryDialogConfig>) => Provider;
+
+/**
+ * Base Entry dialog component. Must be extended when building custom dialogs.
+ *
+ * @example
+ * ```html
+ * <entry-dialog title="TITLE"><p>Dialog content</p></entry-dialog>
+ * ```
+ */
+declare class EntryDialogComponent {
+    protected readonly mdDialogRef: MatDialogRef<EntryDialogComponent>;
+    protected readonly config: EntryDialogConfig;
+    /** Dialog header title  */
+    title: string;
+    /** Dialog buttons horizontal alignment */
+    buttonsAlignment: EntryDialogButtonsAlignment;
+    /** Confirm button label */
+    confirmButtonText: string;
+    /** Cancel button label */
+    cancelButtonText: string;
+    /** Show or hide dialog buttons */
+    hideButtons: boolean;
+    /** Show or hide dialog cancel button */
+    hideCancel: boolean;
+    /** Show or hide dialog close button */
+    hideClose: boolean;
+    /** Enable or disable dialog confirm button */
+    disableConfirm: boolean;
+    /** Provide custom buttons template */
+    buttonsTemplate: TemplateRef<any> | null | undefined;
+    confirm: () => Observable<unknown>;
+    cancel: () => void;
+    onSubmit: () => rxjs.Subscription;
+    close: (value?: unknown) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntryDialogComponent, "entry-dialog", never, { "title": { "alias": "title"; "required": false; }; "buttonsAlignment": { "alias": "buttonsAlignment"; "required": false; }; "confirmButtonText": { "alias": "confirmButtonText"; "required": false; }; "cancelButtonText": { "alias": "cancelButtonText"; "required": false; }; "hideButtons": { "alias": "hideButtons"; "required": false; }; "hideCancel": { "alias": "hideCancel"; "required": false; }; "hideClose": { "alias": "hideClose"; "required": false; }; "disableConfirm": { "alias": "disableConfirm"; "required": false; }; "buttonsTemplate": { "alias": "buttonsTemplate"; "required": false; }; "confirm": { "alias": "confirm"; "required": false; }; "cancel": { "alias": "cancel"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+/**
+ * Alert dialog data.
+ */
+interface IEntryAlertDialogData {
+    /** Dialog header title */
+    title: string;
+    /** Dialog content message */
+    message: string;
+    /** Optional dialog buttons horizontal alignment */
+    buttonsAlignment: EntryDialogButtonsAlignment | undefined;
+    /** Optional dialog confirm text label */
+    confirmText?: string | undefined;
+    /** Optionally show or hide dialog close button */
+    hideClose: boolean | undefined;
+    /** Optionally disable closing dialog when pressing escape or clicking on backdrop */
+    disableClose?: boolean | undefined;
+}
+
+declare class EntryAlertDialogComponent extends EntryDialogComponent {
+    protected readonly mdDialogRef: MatDialogRef<EntryDialogComponent>;
+    readonly config: EntryDialogConfig;
+    readonly data: IEntryAlertDialogData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryAlertDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntryAlertDialogComponent, "entry-alert-dialog", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Confirm dialog data. Extends IEntryAlertDialogData.
+ */
+interface IEntryConfirmDialogData extends IEntryAlertDialogData {
+    /** Optional dialog cancel text label */
+    cancelText?: string | undefined;
+}
+
+declare class EntryConfirmDialogComponent extends EntryDialogComponent {
+    protected readonly mdDialogRef: MatDialogRef<EntryDialogComponent>;
+    readonly config: EntryDialogConfig;
+    readonly data: IEntryConfirmDialogData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryConfirmDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntryConfirmDialogComponent, "entry-confirm-dialog", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Error dialog data.
+ */
+interface IEntryErrorDialogData extends IEntryAlertDialogData {
+    /** Errors to display */
+    errors: string[] | IValidationProblemDetails;
+}
+
+declare class EntryErrorDialogComponent extends EntryDialogComponent {
+    errors: string[];
+    protected readonly mdDialogRef: MatDialogRef<EntryDialogComponent>;
+    readonly config: EntryDialogConfig;
+    readonly data: IEntryErrorDialogData;
+    constructor();
+    private extractValidationErrors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryErrorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntryErrorDialogComponent, "entry-error-dialog", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * Used to open built-in and custom entry dialogs.
+ */
+declare class EntryDialogService {
+    protected readonly config: EntryDialogConfig;
+    private readonly matDialog;
+    /**
+     * Opens alert dialog.
+     *
+     * @param data - Contains title, message and optional confirm button text
+     * @returns `true` if confirmed, `undefined` if closed by clicking on backdrop or pressing escape
+     */
+    openAlert: (data: Partial<IEntryAlertDialogData>) => Observable<true | undefined>;
+    /**
+     * Opens confirm dialog.
+     *
+     * @param data - Contains title, message and optional confirm/cancel buttons text
+     * @returns `true` if confirmed, `false` if canceled or closed, `undefined` if closed by clicking on backdrop or pressing escape
+     */
+    openConfirm: (data: Partial<IEntryConfirmDialogData>) => Observable<boolean | undefined>;
+    /**
+     * Opens error dialog.
+     *
+     * @param data - Contains title, errors and optional confirm button text
+     * @returns `true` if confirmed, `undefined` if closed by clicking on backdrop or pressing escape
+     */
+    openError: (data: Partial<IEntryErrorDialogData>) => Observable<true | undefined>;
+    /**
+     * Opens dialog with custom component.
+     *
+     * @param component - Dialog custom component implementation
+     * @param data - Optional parameter used to supply component with input parameters
+     * @param disableClose - Optional parameter that disable closing dialog when pressing escape or clicking on backdrop
+     * @param cssClass - Optional parameter used to set custom class to Material overlay pane
+     * @returns Any result custom implementation provides
+     */
+    open: (component: Type<EntryDialogComponent>, data?: unknown, disableClose?: boolean | undefined, cssClass?: string) => Observable<any>;
+    /**
+     * Closes all opened dialogs.
+     */
+    closeAll: () => void;
+    private setPanelClassFor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntryDialogService>;
+}
+
+declare class EntryDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntryDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EntryDialogModule, [typeof EntryDialogComponent, typeof EntryAlertDialogComponent, typeof EntryConfirmDialogComponent, typeof EntryErrorDialogComponent], [typeof i5.CommonModule, typeof i6.MatDialogModule, typeof i7.MatIconModule, typeof i8.MatButtonModule, typeof i9.EntryButtonModule], [typeof EntryDialogComponent, typeof EntryAlertDialogComponent, typeof EntryConfirmDialogComponent, typeof EntryErrorDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EntryDialogModule>;
+}
+
+export { ENTRY_DIALOG_CONFIG, EntryAlertDialogComponent, EntryConfirmDialogComponent, EntryDialogComponent, EntryDialogConfig, EntryDialogModule, EntryDialogService, EntryErrorDialogComponent, provideEntryDialogConfig };
+export type { EntryDialogButtonsAlignment, IEntryAlertDialogData, IEntryConfirmDialogData, IEntryErrorDialogData };