@energycap/components 0.41.0 → 0.41.1-ECAP-27592-angular-17.20241220-1140

package/lib/display/dialog/dialog-content.d.ts

@@ -1,19 +1,19 @@
-import { EventEmitter } from "@angular/core";
-/**
- * This interface represents the contract between the dialog component (the "shell" around that masks the background)
- * and the body of the dialog which can be almost any component. It exposes a way for us to pass data into and out of
- * the body from the hosting page with strong type information
- */
-export interface DialogContent<T> {
-    /** Unique identifier for the implementing class. */
-    dialogId: string;
-    /**
-     * The data that is passed to the inner dialog component when it opens from the hosting page.
-     * Will be called before any angular lifecycle hooks.
-     */
-    onOpen?: (openContext?: T) => void;
-    /** An event emitter that will emit an event when the dialog action has completed successfully */
-    onDialogSave: EventEmitter<T>;
-    /** An event emitter that will emit an event when the dialog action has been canceled */
-    onDialogCancel: EventEmitter<void>;
-}
+import { EventEmitter } from "@angular/core";
+/**
+ * This interface represents the contract between the dialog component (the "shell" around that masks the background)
+ * and the body of the dialog which can be almost any component. It exposes a way for us to pass data into and out of
+ * the body from the hosting page with strong type information
+ */
+export interface DialogContent<T> {
+    /** Unique identifier for the implementing class. */
+    dialogId: string;
+    /**
+     * The data that is passed to the inner dialog component when it opens from the hosting page.
+     * Will be called before any angular lifecycle hooks.
+     */
+    onOpen?: (openContext?: T) => void;
+    /** An event emitter that will emit an event when the dialog action has completed successfully */
+    onDialogSave: EventEmitter<T>;
+    /** An event emitter that will emit an event when the dialog action has been canceled */
+    onDialogCancel: EventEmitter<void>;
+}

package/lib/display/dialog/dialog-group/dialog-group.component.d.ts

@@ -1,32 +1,32 @@
-import { OnDestroy, OnInit } from '@angular/core';
-import { DialogOpenStartEvent } from '../dialog-types';
-import { DialogService } from '../dialog.service';
-import * as i0 from "@angular/core";
-export declare class DialogGroupComponent implements OnInit, OnDestroy {
-    private dialogService;
-    activeDialogEvents: DialogOpenStartEvent<any>[];
-    private destroyed;
-    constructor(dialogService: DialogService);
-    /**When the group component is created, start watching for any DialogOpenStart events
-     * so that the group can react and make the matching dialog. New dialogs get assigned unique
-     * eventIds so that when they close we know exactly which one is done and we can take it
-     * out of the list of active dialogs
-     */
-    ngOnInit(): void;
-    /** When the dialog group is destroyed we no longer want to listen for any open events. */
-    ngOnDestroy(): void;
-    /**The dialog component completed opening (including animation delay) and
-     * emits an event that tells us it is ready. The group can then pump out a dialog
-     * openEnd event (kinda NavigationEnd in the router) to tell anybody who cares that
-     * the dialog is now ready.
-     */
-    dialogOpened(dialogOpenEvent: DialogOpenStartEvent<any>, dialogId: string): void;
-    /** The dialog has closed (after animation delay) and emitted an event to tell the hosting component.
-     * We handle the event and pump a matching DialogCloseEvent so that anybody who cares can know that the
-     * dialog instance referenced by dialogOpenEvent.eventId is gone now. We remove it from our list of
-     * active dialogs which pulls it out of the DOM too
-     */
-    dialogClosed(dialogOpenEvent: DialogOpenStartEvent<any>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DialogGroupComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DialogGroupComponent, "ec-dialog-group", never, {}, {}, never, never, false, never>;
-}
+import { OnDestroy, OnInit } from '@angular/core';
+import { DialogOpenStartEvent } from '../dialog-types';
+import { DialogService } from '../dialog.service';
+import * as i0 from "@angular/core";
+export declare class DialogGroupComponent implements OnInit, OnDestroy {
+    private dialogService;
+    activeDialogEvents: DialogOpenStartEvent<any>[];
+    private destroyed;
+    constructor(dialogService: DialogService);
+    /**When the group component is created, start watching for any DialogOpenStart events
+     * so that the group can react and make the matching dialog. New dialogs get assigned unique
+     * eventIds so that when they close we know exactly which one is done and we can take it
+     * out of the list of active dialogs
+     */
+    ngOnInit(): void;
+    /** When the dialog group is destroyed we no longer want to listen for any open events. */
+    ngOnDestroy(): void;
+    /**The dialog component completed opening (including animation delay) and
+     * emits an event that tells us it is ready. The group can then pump out a dialog
+     * openEnd event (kinda NavigationEnd in the router) to tell anybody who cares that
+     * the dialog is now ready.
+     */
+    dialogOpened(dialogOpenEvent: DialogOpenStartEvent<any>, dialogId: string): void;
+    /** The dialog has closed (after animation delay) and emitted an event to tell the hosting component.
+     * We handle the event and pump a matching DialogCloseEvent so that anybody who cares can know that the
+     * dialog instance referenced by dialogOpenEvent.eventId is gone now. We remove it from our list of
+     * active dialogs which pulls it out of the DOM too
+     */
+    dialogClosed(dialogOpenEvent: DialogOpenStartEvent<any>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogGroupComponent, "ec-dialog-group", never, {}, {}, never, never, false, never>;
+}

package/lib/display/dialog/dialog-types.d.ts

@@ -1,130 +1,130 @@
-import { TemplateRef, Type } from '@angular/core';
-import { DialogContent } from './dialog-content';
-/**A base class from which all dialog events extend. This class models the dialog actions very much
- * like the Angular RouterEvents.
- */
-export declare class DialogEvent {
-    /**A unique value representing this particular instance of the event, used to match open and close events together */
-    eventId?: string | undefined;
-    /**The ID of the dialog itself, typically matching the DialogContent. Something like "DeleteConfirmation" or "EditReading" etc.
-     * Useful for telemetry logging to track users opening and closing dialogs
-    */
-    dialogId: string;
-    /** The action the dialog event represents. Can also be determined by using the class of the event with the
-     * instanceof operator.
-     */
-    dialogAction: 'openStart' | 'open' | 'close' | 'closeLatest';
-    constructor(
-    /**A unique value representing this particular instance of the event, used to match open and close events together */
-    eventId?: string | undefined, 
-    /**The ID of the dialog itself, typically matching the DialogContent. Something like "DeleteConfirmation" or "EditReading" etc.
-     * Useful for telemetry logging to track users opening and closing dialogs
-    */
-    dialogId?: string, 
-    /** The action the dialog event represents. Can also be determined by using the class of the event with the
-     * instanceof operator.
-     */
-    dialogAction?: 'openStart' | 'open' | 'close' | 'closeLatest');
-}
-/**Emitted when the dialog open has been triggered, but the dialog itself hasn't initialized yet.
- * This event creates its own unique identifier so that that particular instance of the dialog can be found
- * when closed later on. The context is used to fill the dialog itself, and may include state or callbacks.
- * Various options are available to change the dialog appearance. These events are generally created
- * by the @see DialogService.open() call
- */
-export declare class DialogOpenStartEvent<T> extends DialogEvent {
-    content: Type<DialogContent<T>> | TemplateRef<any>;
-    context?: T | undefined;
-    options?: DialogOptions | undefined;
-    constructor(content: Type<DialogContent<T>> | TemplateRef<any>, context?: T | undefined, options?: DialogOptions | undefined);
-}
-/**Emitted when the dialog has finished opening and been properly initialized. It includes
- * the eventId, which uniquely identifies the particular instance of the dialog open event so that we can
- * close that specific dialog later on. The dialogId can be used for telemetry, and may be set to something
- * like "Confirm Delete" or "Edit Reading" etc.
- */
-export declare class DialogOpenEndEvent extends DialogEvent {
-    constructor(eventId?: string, dialogId?: string);
-}
-/**Emitted when the dialog close has completed and a result is available. Check result.save to know if the dialog change
- * was committed (true) or cancelled (false). Cancel can be set if the dialog was automatically closed by clicking in the
- * background or resizing the window when using the panel view or closeOnResize.
- */
-export declare class DialogCloseEvent<T> extends DialogEvent {
-    /**The result of the dialog event, including weather it was saved or cancelled and the context's final state*/
-    dialogResult: DialogResult<any>;
-    constructor(eventId?: string, dialogId?: string, save?: boolean, context?: T);
-}
-/**Used to tell the dialog group to close whatever dialog was opened most recently with the given result
- * This allows a TemplateRef based panel (that's not coming from DialogComponent) to close itself or
- * an external process to close a dialog that is open
- */
-export declare class DialogCloseLatestEvent<T> extends DialogEvent {
-    /**The result of the dialog event, including weather it was saved or cancelled and the context's final state*/
-    dialogResult: DialogResult<any>;
-    constructor(result: DialogResult<T>);
-}
-/**
- * This interface specifies extra options to configure behavior of the Dialog Component
- */
-export interface DialogOptions {
-    /**
-     * Function to execute before dialog opens.  Leave `undefined` or return true to allow
-     * dialog to open.
-     *
-     * Can be used to check for unsaved changes on the underlying page before opening.
-     *
-     * @example
-       constructor( private unsavedChangesGuard: CanDeactivateUnsavedChangesGuard ){};
-       //...
-       const options: DialogOptions = { canOpenDialog: this.unsavedChangesGuard.canDeactivate };
-     */
-    canOpenDialog?: () => Promise<boolean>;
-    /** Configures when the dialog emits its result in relation to a closing animation event */
-    emitResultOn?: DialogAnimationEvent;
-    /** Display the dialog as a side panel that slides in */
-    displayAsPanel?: boolean;
-    /** Set the dialog mask color to transparent. Defaults to true when dialog is displayed as a panel */
-    transparentMask?: boolean;
-    /**
-     * Set the dialog mask to not display at all. Allows the user to click on elements behind the dialog.
-     * Only applicable when displayAsPanel is true.
-     * Defaults to false.
-     */
-    noMask?: boolean;
-    /** Align the dialog window to the top instead of centered. */
-    alignToTop?: boolean;
-    /** Set the top margin of the dialog window. Only takes effect if alignToTop is true.
-     * Must include units, i.e. "32rem" or "10vh"
-     */
-    alignToTopMargin?: string;
-    /**
-     * Set to true if the dialog should automatically close when the window is resized.
-     * This is useful if you are conditionally showing/hiding the dialog content as a static part of the page
-     * when the screen gets wide enough
-     */
-    closeOnResize?: boolean;
-    size?: DialogSize;
-    /**
-     * Used to specify a custom min-width of the dialog. Only takes effect if size is set to dynamic.
-     * Must include units, i.e. "32rem" or "640px"
-     */
-    minWidth?: string;
-}
-/**
- * Returned when a dialog is closed.
- * Specifies if the dialog was saved and contains an optional context.
- */
-export declare class DialogResult<T> {
-    save: boolean;
-    context?: T | undefined;
-    constructor(save: boolean, context?: T | undefined);
-}
-/** Options for size of dialog */
-export type DialogSize = number | 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge' | 'full' | 'dynamic';
-/**
- * Dialog Animation Events:
- * - BeginClose: When the close animation starts.
- * - EndClose: When the close animation finishes
- */
-export type DialogAnimationEvent = 'BeginClose' | 'EndClose';
+import { TemplateRef, Type } from '@angular/core';
+import { DialogContent } from './dialog-content';
+/**A base class from which all dialog events extend. This class models the dialog actions very much
+ * like the Angular RouterEvents.
+ */
+export declare class DialogEvent {
+    /**A unique value representing this particular instance of the event, used to match open and close events together */
+    eventId?: string | undefined;
+    /**The ID of the dialog itself, typically matching the DialogContent. Something like "DeleteConfirmation" or "EditReading" etc.
+     * Useful for telemetry logging to track users opening and closing dialogs
+    */
+    dialogId: string;
+    /** The action the dialog event represents. Can also be determined by using the class of the event with the
+     * instanceof operator.
+     */
+    dialogAction: 'openStart' | 'open' | 'close' | 'closeLatest';
+    constructor(
+    /**A unique value representing this particular instance of the event, used to match open and close events together */
+    eventId?: string | undefined, 
+    /**The ID of the dialog itself, typically matching the DialogContent. Something like "DeleteConfirmation" or "EditReading" etc.
+     * Useful for telemetry logging to track users opening and closing dialogs
+    */
+    dialogId?: string, 
+    /** The action the dialog event represents. Can also be determined by using the class of the event with the
+     * instanceof operator.
+     */
+    dialogAction?: 'openStart' | 'open' | 'close' | 'closeLatest');
+}
+/**Emitted when the dialog open has been triggered, but the dialog itself hasn't initialized yet.
+ * This event creates its own unique identifier so that that particular instance of the dialog can be found
+ * when closed later on. The context is used to fill the dialog itself, and may include state or callbacks.
+ * Various options are available to change the dialog appearance. These events are generally created
+ * by the @see DialogService.open() call
+ */
+export declare class DialogOpenStartEvent<T> extends DialogEvent {
+    content: Type<DialogContent<T>> | TemplateRef<any>;
+    context?: T | undefined;
+    options?: DialogOptions | undefined;
+    constructor(content: Type<DialogContent<T>> | TemplateRef<any>, context?: T | undefined, options?: DialogOptions | undefined);
+}
+/**Emitted when the dialog has finished opening and been properly initialized. It includes
+ * the eventId, which uniquely identifies the particular instance of the dialog open event so that we can
+ * close that specific dialog later on. The dialogId can be used for telemetry, and may be set to something
+ * like "Confirm Delete" or "Edit Reading" etc.
+ */
+export declare class DialogOpenEndEvent extends DialogEvent {
+    constructor(eventId?: string, dialogId?: string);
+}
+/**Emitted when the dialog close has completed and a result is available. Check result.save to know if the dialog change
+ * was committed (true) or cancelled (false). Cancel can be set if the dialog was automatically closed by clicking in the
+ * background or resizing the window when using the panel view or closeOnResize.
+ */
+export declare class DialogCloseEvent<T> extends DialogEvent {
+    /**The result of the dialog event, including weather it was saved or cancelled and the context's final state*/
+    dialogResult: DialogResult<any>;
+    constructor(eventId?: string, dialogId?: string, save?: boolean, context?: T);
+}
+/**Used to tell the dialog group to close whatever dialog was opened most recently with the given result
+ * This allows a TemplateRef based panel (that's not coming from DialogComponent) to close itself or
+ * an external process to close a dialog that is open
+ */
+export declare class DialogCloseLatestEvent<T> extends DialogEvent {
+    /**The result of the dialog event, including weather it was saved or cancelled and the context's final state*/
+    dialogResult: DialogResult<any>;
+    constructor(result: DialogResult<T>);
+}
+/**
+ * This interface specifies extra options to configure behavior of the Dialog Component
+ */
+export interface DialogOptions {
+    /**
+     * Function to execute before dialog opens.  Leave `undefined` or return true to allow
+     * dialog to open.
+     *
+     * Can be used to check for unsaved changes on the underlying page before opening.
+     *
+     * @example
+       constructor( private unsavedChangesGuard: CanDeactivateUnsavedChangesGuard ){};
+       //...
+       const options: DialogOptions = { canOpenDialog: this.unsavedChangesGuard.canDeactivate };
+     */
+    canOpenDialog?: () => Promise<boolean>;
+    /** Configures when the dialog emits its result in relation to a closing animation event */
+    emitResultOn?: DialogAnimationEvent;
+    /** Display the dialog as a side panel that slides in */
+    displayAsPanel?: boolean;
+    /** Set the dialog mask color to transparent. Defaults to true when dialog is displayed as a panel */
+    transparentMask?: boolean;
+    /**
+     * Set the dialog mask to not display at all. Allows the user to click on elements behind the dialog.
+     * Only applicable when displayAsPanel is true.
+     * Defaults to false.
+     */
+    noMask?: boolean;
+    /** Align the dialog window to the top instead of centered. */
+    alignToTop?: boolean;
+    /** Set the top margin of the dialog window. Only takes effect if alignToTop is true.
+     * Must include units, i.e. "32rem" or "10vh"
+     */
+    alignToTopMargin?: string;
+    /**
+     * Set to true if the dialog should automatically close when the window is resized.
+     * This is useful if you are conditionally showing/hiding the dialog content as a static part of the page
+     * when the screen gets wide enough
+     */
+    closeOnResize?: boolean;
+    size?: DialogSize;
+    /**
+     * Used to specify a custom min-width of the dialog. Only takes effect if size is set to dynamic.
+     * Must include units, i.e. "32rem" or "640px"
+     */
+    minWidth?: string;
+}
+/**
+ * Returned when a dialog is closed.
+ * Specifies if the dialog was saved and contains an optional context.
+ */
+export declare class DialogResult<T> {
+    save: boolean;
+    context?: T | undefined;
+    constructor(save: boolean, context?: T | undefined);
+}
+/** Options for size of dialog */
+export type DialogSize = number | 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge' | 'full' | 'dynamic';
+/**
+ * Dialog Animation Events:
+ * - BeginClose: When the close animation starts.
+ * - EndClose: When the close animation finishes
+ */
+export type DialogAnimationEvent = 'BeginClose' | 'EndClose';

package/lib/display/dialog/dialog.component.d.ts

@@ -1,120 +1,120 @@
-import { ComponentFactoryResolver, ComponentRef, EventEmitter, Type, ViewContainerRef, TemplateRef } from '@angular/core';
-import { WindowService } from '../../core/window.service';
-import { DialogContent } from './dialog-content';
-import { DialogSize, DialogOptions, DialogResult } from './dialog-types';
-import { DialogService } from './dialog.service';
-import * as i0 from "@angular/core";
-/** These values need to be kept in sync with dialog-base.scss */
-export declare const DialogOpenDuration: number;
-export declare const DialogCloseDuration: number;
-export declare const PanelOpenDuration: number;
-export declare const PanelCloseDuration: number;
-export declare class DialogComponent {
-    private componentFactoryResolver;
-    private windowService;
-    private dialogService;
-    private documentRef;
-    /**
-     * Add/remove the is-open css class to the host element when the dialog is opened/closed.
-     * Styles use the is-open class to show/hide the dialog.
-     */
-    isOpen: boolean;
-    /**
-     * Add the fade-in css class to the host element when the dialog is opening. Remove when transition is complete.
-     * Styles use the fade-in class to apply a fade-in transition while the dialog is opening.
-     */
-    fadeIn: boolean;
-    /**
-     * Add the fade-out css class to the host element when the dialog is closing. Remove when transition is complete.
-     * Styles use the fade-out class to apply a fade-out transition while the dialog is closing.
-     */
-    fadeOut: boolean;
-    displayAsPanel: boolean;
-    alignToTop: boolean;
-    alignToTopMargin?: string;
-    transparentMask: boolean;
-    noMask: boolean;
-    onOverlayClick(event: MouseEvent): void;
-    /**
-     * Defines the width of the dialog (height is auto). Can be a number that will be converted to pixels, or xsmall(320px), small(480px), medium(640px), or large(1024px)
-     */
-    set size(value: DialogSize);
-    get size(): DialogSize;
-    /**
-     * Defines the width of the dialog (height is auto). Can be a number that will be converted to pixels, or xsmall(320px), small(480px), medium(640px), or large(1024px)
-     */
-    private _size;
-    /**
-     * Bound to the host. The classes set the --ec-dialog-width variable to our default 'small', 'medium', etc. sizes.
-     * Undefined when the size is a number, which is used for custom sizes.
-     */
-    dialogSizeClass?: string;
-    content?: Type<DialogContent<any>> | TemplateRef<any>;
-    context?: any;
-    options?: DialogOptions;
-    /**Only set if this particular instance of a dialog should be identified separately from others.
-     * If provided, this is emitted to the dialog service with OpenEnd and Close events. Direct usage
-     * of the DialogComponent from outside a DialogGroup does not usually require using this parameter as
-     * the dialog reference itself functions as the identifier
-     */
-    dialogOpenStartEventId?: string;
-    /**
-     * Emits an event when the dialog is opened
-     */
-    opened: EventEmitter<string>;
-    /**
-     * Emits an event when the dialog is closed
-     */
-    closed: EventEmitter<DialogResult<any>>;
-    /**
-     * The container where the component will be loaded
-     */
-    contentContainer: ViewContainerRef;
-    /**
-     * Custom width of the dialog in pixels. Set by defining the size property
-     * as a number value.
-     */
-    width?: number;
-    /**
-     * Custom min-width of the dialog. Only takes effect if size is set to dynamic.
-     * Must include units, i.e. "32rem" or "640px"
-     */
-    minWidth?: string;
-    /**
-     * A reference of the component once it has been loaded
-     */
-    componentRef?: ComponentRef<any>;
-    private previouslyFocusedElement;
-    constructor(componentFactoryResolver: ComponentFactoryResolver, windowService: WindowService, dialogService: DialogService, documentRef: Document);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    /**
-     * Clear and previously loaded content
-     * Load the component
-     * Save a reference of the loaded component
-     * Show the dialog and fade in
-     */
-    open<T>(component: Type<DialogContent<T>> | TemplateRef<any>, context?: T, options?: DialogOptions): Promise<void>;
-    /**
-     * Fade the dialog out and hide
-     */
-    close<T>(result?: DialogResult<T>): void;
-    /**Open the dialog and attach handlers to the cancel and save events to close it and notify the hosting page */
-    private openDialogComponent;
-    /**
-     * Reset options so they don't persist next time the
-     * root dialog is opened
-     * @deprecated
-     */
-    private resetOptions;
-    /** If they turned on closeOnResize, automatically close the dialog any time somebody resizes the window.
-      * This is useful for responsive layouts to prevent having the dialogContent on the screen twice */
-    private handleCloseOnResize;
-    /**Extract the dialogId from the dialog content, if it has one. Template-based dialogs generally don't.
-     * We fall back to empty string to allow anybody listening for dialogEvents to still record the open/close even if
-     * the dialog itself does not say what the name is.
-     */
-    private getDialogId;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "ec-dialog", never, { "size": "size"; "content": "content"; "context": "context"; "options": "options"; "dialogOpenStartEventId": "dialogOpenStartEventId"; }, { "opened": "opened"; "closed": "closed"; }, never, never, false, never>;
-}
+import { ComponentFactoryResolver, ComponentRef, EventEmitter, Type, ViewContainerRef, TemplateRef } from '@angular/core';
+import { WindowService } from '../../core/window.service';
+import { DialogContent } from './dialog-content';
+import { DialogSize, DialogOptions, DialogResult } from './dialog-types';
+import { DialogService } from './dialog.service';
+import * as i0 from "@angular/core";
+/** These values need to be kept in sync with dialog-base.scss */
+export declare const DialogOpenDuration: number;
+export declare const DialogCloseDuration: number;
+export declare const PanelOpenDuration: number;
+export declare const PanelCloseDuration: number;
+export declare class DialogComponent {
+    private componentFactoryResolver;
+    private windowService;
+    private dialogService;
+    private documentRef;
+    /**
+     * Add/remove the is-open css class to the host element when the dialog is opened/closed.
+     * Styles use the is-open class to show/hide the dialog.
+     */
+    isOpen: boolean;
+    /**
+     * Add the fade-in css class to the host element when the dialog is opening. Remove when transition is complete.
+     * Styles use the fade-in class to apply a fade-in transition while the dialog is opening.
+     */
+    fadeIn: boolean;
+    /**
+     * Add the fade-out css class to the host element when the dialog is closing. Remove when transition is complete.
+     * Styles use the fade-out class to apply a fade-out transition while the dialog is closing.
+     */
+    fadeOut: boolean;
+    displayAsPanel: boolean;
+    alignToTop: boolean;
+    alignToTopMargin?: string;
+    transparentMask: boolean;
+    noMask: boolean;
+    onOverlayClick(event: MouseEvent): void;
+    /**
+     * Defines the width of the dialog (height is auto). Can be a number that will be converted to pixels, or xsmall(320px), small(480px), medium(640px), or large(1024px)
+     */
+    set size(value: DialogSize);
+    get size(): DialogSize;
+    /**
+     * Defines the width of the dialog (height is auto). Can be a number that will be converted to pixels, or xsmall(320px), small(480px), medium(640px), or large(1024px)
+     */
+    private _size;
+    /**
+     * Bound to the host. The classes set the --ec-dialog-width variable to our default 'small', 'medium', etc. sizes.
+     * Undefined when the size is a number, which is used for custom sizes.
+     */
+    dialogSizeClass?: string;
+    content?: Type<DialogContent<any>> | TemplateRef<any>;
+    context?: any;
+    options?: DialogOptions;
+    /**Only set if this particular instance of a dialog should be identified separately from others.
+     * If provided, this is emitted to the dialog service with OpenEnd and Close events. Direct usage
+     * of the DialogComponent from outside a DialogGroup does not usually require using this parameter as
+     * the dialog reference itself functions as the identifier
+     */
+    dialogOpenStartEventId?: string;
+    /**
+     * Emits an event when the dialog is opened
+     */
+    opened: EventEmitter<string>;
+    /**
+     * Emits an event when the dialog is closed
+     */
+    closed: EventEmitter<DialogResult<any>>;
+    /**
+     * The container where the component will be loaded
+     */
+    contentContainer: ViewContainerRef;
+    /**
+     * Custom width of the dialog in pixels. Set by defining the size property
+     * as a number value.
+     */
+    width?: number;
+    /**
+     * Custom min-width of the dialog. Only takes effect if size is set to dynamic.
+     * Must include units, i.e. "32rem" or "640px"
+     */
+    minWidth?: string;
+    /**
+     * A reference of the component once it has been loaded
+     */
+    componentRef?: ComponentRef<any>;
+    private previouslyFocusedElement;
+    constructor(componentFactoryResolver: ComponentFactoryResolver, windowService: WindowService, dialogService: DialogService, documentRef: Document);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Clear and previously loaded content
+     * Load the component
+     * Save a reference of the loaded component
+     * Show the dialog and fade in
+     */
+    open<T>(component: Type<DialogContent<T>> | TemplateRef<any>, context?: T, options?: DialogOptions): Promise<void>;
+    /**
+     * Fade the dialog out and hide
+     */
+    close<T>(result?: DialogResult<T>): void;
+    /**Open the dialog and attach handlers to the cancel and save events to close it and notify the hosting page */
+    private openDialogComponent;
+    /**
+     * Reset options so they don't persist next time the
+     * root dialog is opened
+     * @deprecated
+     */
+    private resetOptions;
+    /** If they turned on closeOnResize, automatically close the dialog any time somebody resizes the window.
+      * This is useful for responsive layouts to prevent having the dialogContent on the screen twice */
+    private handleCloseOnResize;
+    /**Extract the dialogId from the dialog content, if it has one. Template-based dialogs generally don't.
+     * We fall back to empty string to allow anybody listening for dialogEvents to still record the open/close even if
+     * the dialog itself does not say what the name is.
+     */
+    private getDialogId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "ec-dialog", never, { "size": { "alias": "size"; "required": false; }; "content": { "alias": "content"; "required": false; }; "context": { "alias": "context"; "required": false; }; "options": { "alias": "options"; "required": false; }; "dialogOpenStartEventId": { "alias": "dialogOpenStartEventId"; "required": false; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, false, never>;
+}