@progress/kendo-angular-dialog 24.2.2-develop.9 → 25.0.0-develop.1

package/index.d.ts

@@ -2,34 +2,1665 @@
 * Copyright © 2026 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-export { DialogComponent } from './dialog/dialog.component';
-export { DialogTitleBarComponent } from './dialog/dialog-titlebar.component';
-export { DialogContentBase } from './dialog/dialog-content-base';
-export { DialogActionsComponent } from './dialog/dialog-actions.component';
-export { DialogService } from './dialog/dialog.service';
-export { DialogContainerService } from './dialog/dialog-container.service';
-export { DialogCloseResult, DialogRef, DialogSettings, DialogAction, DialogResult, DialogAnimation, DialogActionDivider } from './dialog/models/';
-export { ActionsLayout } from './common/actions-layout';
-export { DialogAnimationType } from './common/animation-types';
-export { AnimationDirection } from './common/dialog-animation-direction';
-export { WindowComponent } from './window/window.component';
-export { WindowTitleBarComponent } from './window/window-titlebar.component';
-export { WindowMaximizeActionDirective } from './window/actions/window-maximize-action.directive';
-export { WindowMinimizeActionDirective } from './window/actions/window-minimize-action.directive';
-export { WindowCloseActionDirective } from './window/actions/window-close-action.directive';
-export { WindowRestoreActionDirective } from './window/actions/window-restore-action.directive';
-export { WindowState, WindowSettings, WindowDimensionSetting, WindowRef, WindowCloseResult } from './window/models';
-export { WindowService } from './window/window.service';
-export { WindowContainerService } from './window/window-container.service';
-export { DragResizeService } from './window/drag-resize.service';
-export { NavigationService } from './window/navigation.service';
-export { DialogModule } from './dialog.module';
-export { WindowModule } from './window.module';
-export { DialogsModule } from './dialogs.module';
-export { DialogContainerDirective } from './dialog/dialog-container.directive';
-export { Messages } from './localization/messages';
-export { LocalizedMessagesDirective } from './localization/localized-messages.directive';
-export { CustomMessagesComponent } from './localization/custom-messages.component';
-export { WindowContainerDirective } from './window/window-container.directive';
-export { PreventableEvent } from './common/preventable-event';
-export * from './directives';
+import * as i0 from '@angular/core';
+import { ElementRef, TemplateRef, EventEmitter, AfterViewInit, NgZone, AfterContentInit, OnInit, OnDestroy, QueryList, Renderer2, ChangeDetectorRef, ComponentRef, ViewContainerRef, OnChanges, SimpleChange } from '@angular/core';
+import { AnimationBuilder } from '@angular/animations';
+import { ButtonThemeColor, ButtonFillMode, Button } from '@progress/kendo-angular-buttons';
+import { SVGIcon } from '@progress/kendo-svg-icons';
+import { LocalizationService, ComponentMessages } from '@progress/kendo-angular-l10n';
+import { LicenseMessage } from '@progress/kendo-licensing';
+import { Observable, Subscription } from 'rxjs';
+import { DraggableDirective } from '@progress/kendo-angular-common';
+
+/**
+ * Represents the settings for Dialog actions when you open a Dialog through `DialogService`.
+ *
+ * Use the `DialogAction` class to configure action buttons in the Dialog. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/dialogservice#open))
+ *
+ */
+declare class DialogAction {
+    /**
+     * Sets the text of the action button.
+     */
+    text: string;
+    /**
+     * Sets the theme color of the action button. The theme color applies to the background, border, and text.
+     */
+    themeColor?: ButtonThemeColor;
+    /**
+     * Sets the background and border styles of the action button.
+     */
+    fillMode?: ButtonFillMode;
+    /**
+     * Sets the CSS classes for the action button. Accepts any value supported by [`ngClass`](link:site.data.urls.angular['ngclassapi']).
+     */
+    cssClass?: any;
+    /**
+     * Sets the [SVG icon](https://www.telerik.com/kendo-angular-ui/components/icons/svgicon/svgicon-list) to display in the action button.
+     */
+    svgIcon?: SVGIcon;
+    /**
+     * Sets the name of the [font icon](https://www.telerik.com/kendo-angular-ui/components/icons/icon/icon-list) to display in the action button.
+     */
+    icon?: string;
+    /**
+     * @hidden
+     */
+    disabled?: boolean;
+}
+
+/**
+ * Represents the layout for the Dialog action buttons.
+ *
+ * Use the `ActionsLayout` type to set the alignment of action buttons in the Dialog.
+ *
+ */
+type ActionsLayout = 'start' | 'center' | 'end' | 'stretched';
+
+/**
+ * Represents a Dialog action used as a divider between action buttons.
+ *
+ * Use the `DialogActionDivider` type to add a visual spacer in the Dialog actions area.
+ *
+ */
+type DialogActionDivider = 'spacer';
+
+/**
+ * Represents the action buttons of the Dialog.
+ * ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/action-buttons))
+ *
+ * ```html
+ * <kendo-dialog>
+ *  <kendo-dialog-actions>
+ *     <button kendoButton fillMode="flat" themeColor="primary" (click)="onPrimaryActionClick()">
+ *       Primary Action
+ *    </button>
+ *  </kendo-dialog-actions>
+ * </kendo-dialog>
+ * ```
+ */
+declare class DialogActionsComponent {
+    el: ElementRef;
+    /**
+     * Allows the declarative specification of the Dialog `actions`.
+     */
+    set actions(value: DialogAction[] | TemplateRef<any>);
+    /**
+     * @hidden
+     */
+    actionsArray: DialogAction[];
+    /**
+     * @hidden
+     */
+    actionsTemplate: TemplateRef<any>;
+    /**
+     * Sets the possible layout of the action buttons.
+     * @default 'stretched'
+     */
+    layout: ActionsLayout;
+    /**
+     * Fires when the user clicks an action button.
+     */
+    action: EventEmitter<DialogAction>;
+    hostClasses: boolean;
+    get startClassName(): boolean;
+    get centerClassName(): boolean;
+    get endClassName(): boolean;
+    get stretchedClassName(): boolean;
+    constructor(el: ElementRef);
+    /**
+     * @hidden
+     */
+    onButtonClick(action: DialogAction, _e?: any): void;
+    /**
+     * @hidden
+     */
+    isDivider(action: DialogAction | DialogActionDivider): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogActionsComponent, "kendo-dialog-actions", never, { "actions": { "alias": "actions"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; }, { "action": "action"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Represents a preventable event in Dialog and Window components.
+ *
+ */
+declare class PreventableEvent {
+    private prevented;
+    /**
+     * @hidden
+     */
+    constructor();
+    /**
+     * Prevents the default action for a specified event.
+     * In this way, the source component suppresses the built-in behavior that follows the event.
+     */
+    preventDefault(): void;
+    /**
+     * If the event is prevented by any of its subscribers, returns `true`.
+     *
+     * @returns `true` if the default action was prevented. Otherwise, returns `false`.
+     */
+    isDefaultPrevented(): boolean;
+}
+
+/**
+ * Represents the [Kendo UI DialogTitleBar component for Angular](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/dialogtitlebarcomponent).
+ *
+ * Use this component as part of the Dialog content when you create the Dialog dynamically with an [Angular service](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/service).
+ *
+ * ```html
+ * <kendo-dialog>
+ *   <kendo-dialog-titlebar [id]="dialogId" (close)="onClose()">
+ *      Dialog Title
+ *   </kendo-dialog-titlebar>
+ * </kendo-dialog>
+ * ```
+ *
+ */
+declare class DialogTitleBarComponent implements AfterViewInit {
+    private zone;
+    private hostElement;
+    private localizationService;
+    /**
+     * Fires when the close button in the title bar is clicked.
+     */
+    close: EventEmitter<PreventableEvent>;
+    /**
+     * @hidden
+     */
+    id: string;
+    /**
+     * @hidden
+     */
+    closeTitle: string;
+    /**
+     * @hidden
+     */
+    closable: boolean;
+    get className(): true;
+    /**
+     * @hidden
+     */
+    xIcon: SVGIcon;
+    constructor(zone: NgZone, hostElement: ElementRef, localizationService: LocalizationService);
+    get closeButtonTitle(): string;
+    ngAfterViewInit(): void;
+    /**
+     * @hidden
+     */
+    onCloseClick(e: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogTitleBarComponent, [null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogTitleBarComponent, "kendo-dialog-titlebar", never, { "id": { "alias": "id"; "required": false; }; "closeTitle": { "alias": "closeTitle"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; }, { "close": "close"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Represents the available Dialog animation types.
+ *
+ * Use the `DialogAnimationType` type to specify the animation for Dialog transitions.
+ *
+ */
+type DialogAnimationType = 'translate' | 'slide' | 'fade' | 'expand' | 'zoom';
+
+/**
+ * Represents the available directions for the Dialog opening animation.
+ *
+ * Use the `AnimationDirection` type to set the direction for Dialog animations.
+ *
+ */
+type AnimationDirection = 'up' | 'down' | 'right' | 'left';
+
+/**
+ * Represents the settings for Dialog animations when you open the Dialog component.
+ *
+ * Use the `DialogAnimation` interface to configure animation duration, type, and direction. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/animations))
+ *
+ */
+interface DialogAnimation {
+    /**
+     * Sets the duration of the Dialog opening animation in milliseconds.
+     */
+    duration?: number;
+    /**
+     * Sets the Dialog opening animation type.
+     */
+    type?: DialogAnimationType;
+    /**
+     * Sets the direction of the Dialog opening animation. Applies to the `slide` and `expand` animation types.
+     */
+    direction?: AnimationDirection;
+}
+
+/**
+ * Represents the [Kendo UI Dialog component for Angular](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog).
+ *
+ * Use this component to display modal dialog windows in your application.
+ *
+ * @example
+ * ```ts
+ * import { Component } from '@angular/core';
+ *
+ * @Component({
+ *   selector: 'my-app',
+ *   template: `
+ *     <kendo-dialog title="Example Dialog">
+ *       <p>Dialog content goes here.</p>
+ *     </kendo-dialog>
+ *   `
+ * })
+ * export class AppComponent {}
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link DialogTitleBarComponent}, {@link DialogActionsComponent}, {@link CustomMessagesComponent}.
+ */
+declare class DialogComponent implements AfterContentInit, AfterViewInit, OnInit, OnDestroy {
+    private wrapper;
+    private renderer;
+    private cdr;
+    private ngZone;
+    private builder;
+    /**
+     * Specifies the action buttons to render in the Dialog.
+     *
+     * @type {DialogAction[]}
+     */
+    actions: DialogAction[];
+    /**
+     * Sets the layout of the action buttons in the Dialog. Applies only if you specify action buttons through the `actions` option.
+     *
+     * @type {ActionsLayout}
+     * @default 'stretched'
+     */
+    actionsLayout: ActionsLayout;
+    /**
+     * Sets the query selector for the element to receive initial focus. ([See examples.](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/initial-focus))
+     *
+     * @type {string}
+     *
+     * @remarks
+     * This property is related to accessibility.
+     */
+    autoFocusedElement: string;
+    /**
+     * Specifies whether the Dialog can be closed by the **Close** button in the title bar or by pressing the `Esc` key.
+     *
+     * @type {boolean}
+     * @default true
+     */
+    set closable(value: boolean);
+    get closable(): boolean;
+    /**
+     * Sets the text in the Dialog title bar.
+     *
+     * @type {string}
+     */
+    title: string;
+    /**
+     * Sets the width of the Dialog. Use a number for pixels or a string for units (for example, `50%`).
+     *
+     * @type {number | string}
+     */
+    width: number | string;
+    /**
+     * Sets the minimum width of the Dialog. Use a number for pixels or a string for units (for example, `50%`).
+     *
+     * @type {number | string}
+     */
+    minWidth: number | string;
+    /**
+     * Sets the maximum width of the Dialog. Use a number for pixels or a string for units (for example, `50%`).
+     *
+     * @type {number | string}
+     */
+    maxWidth: number | string;
+    /**
+     * Sets the height of the Dialog. Use a number for pixels or a string for units (for example, `50%`).
+     *
+     * @type {number | string}
+     */
+    height: number | string;
+    /**
+     * Sets the minimum height of the Dialog. Use a number for pixels or a string for units (for example, `50%`).
+     *
+     * @type {number | string}
+     */
+    minHeight: number | string;
+    /**
+     * Sets the maximum height of the Dialog. Use a number for pixels or a string for units (for example, `50%`).
+     *
+     * @type {number | string}
+     */
+    maxHeight: number | string;
+    /**
+     * Configures the Dialog opening animation ([see example](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/animations)).
+     * The default animation type is `translate` and the duration is `300ms`.
+     *
+     * @type {boolean | DialogAnimation}
+     * @default true
+     */
+    animation: boolean | DialogAnimation;
+    /**
+     * @hidden
+     */
+    set htmlAttributes(attributes: {
+        [key: string]: string;
+    });
+    get htmlAttributes(): {
+        [key: string]: string;
+    };
+    /**
+     * @hidden
+     */
+    set cssClass(classes: any);
+    get cssClass(): any;
+    /**
+     * @hidden
+     */
+    contentTemplate: TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    titleId: string;
+    /**
+     * @hidden
+     */
+    contentId: string;
+    /**
+     * @hidden
+     */
+    closeTitle: string;
+    /**
+     * @hidden
+     */
+    showLicenseWatermark: boolean;
+    /**
+     * @hidden
+     */
+    licenseMessage?: LicenseMessage;
+    /**
+     * Emits when the user clicks an action button in the Dialog. Fires only if you specify action buttons through the `actions` option.
+     *
+     * @type {EventEmitter<DialogAction>}
+     */
+    action: EventEmitter<DialogAction>;
+    /**
+     * Emits when the user clicks the **Close** button or presses the `ESC` key.
+     *
+     * @type {EventEmitter<any>}
+     */
+    close: EventEmitter<any>;
+    get dir(): string;
+    tabIndex: number;
+    titlebarContent: QueryList<DialogTitleBarComponent>;
+    titlebarView: QueryList<DialogTitleBarComponent>;
+    actionsView: DialogActionsComponent;
+    dialog: ElementRef;
+    private _htmlAttributes;
+    private _cssClass;
+    private _closable;
+    private direction;
+    private subscriptions;
+    private domSubs;
+    constructor(wrapper: ElementRef, renderer: Renderer2, localization: LocalizationService, cdr: ChangeDetectorRef, ngZone: NgZone, builder: AnimationBuilder);
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Focuses the wrapper of the Dialog component.
+     */
+    focus(): void;
+    private initDomEvents;
+    private onKeyDown;
+    private setServiceClasses;
+    /**
+     * @hidden
+     */
+    private handleInitialFocus;
+    /**
+     * @hidden
+     */
+    private findPrimary;
+    /**
+     * @hidden
+     */
+    private handleActionButtonFocus;
+    /**
+     * @hidden
+     */
+    private keepFocusWithinComponent;
+    /**
+     * @hidden
+     */
+    private shouldFocusPrimary;
+    /**
+     * @hidden
+     */
+    private getAllFocusableChildren;
+    /**
+     * @hidden
+     */
+    private getFirstAndLastFocusable;
+    /**
+     * @hidden
+     */
+    private generateTitleId;
+    /**
+     * @hidden
+     */
+    private generateContentId;
+    get wrapperClass(): boolean;
+    get styles(): any;
+    private bubble;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "kendo-dialog", ["kendoDialog"], { "actions": { "alias": "actions"; "required": false; }; "actionsLayout": { "alias": "actionsLayout"; "required": false; }; "autoFocusedElement": { "alias": "autoFocusedElement"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "title": { "alias": "title"; "required": false; }; "width": { "alias": "width"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "height": { "alias": "height"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; }, { "action": "action"; "close": "close"; }, ["titlebarContent"], ["kendo-dialog-titlebar", "*", "kendo-dialog-actions"], true, never>;
+}
+
+/**
+ * Represents the result when the **Close** button is clicked in a Dialog opened through `DialogService`.
+ *
+ * Used when the results from the Dialogs that are opened through `DialogService` are filtered. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/dialogservice#open))
+ *
+ */
+declare class DialogCloseResult {
+}
+
+/**
+ * Represents the possible result types of the Dialog.
+ *
+ * Use the `DialogResult` type to handle the result when a Dialog closes. If the result is a [`DialogCloseResult`](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/dialogcloseresult), the **Close** button was clicked.
+ * Otherwise, the value is the configuration of the action button that was clicked. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/dialogservice#open))
+ *
+ */
+type DialogResult = DialogCloseResult | DialogAction;
+
+/**
+ * Holds references to the Dialog instance and published events when you open a Dialog through the `DialogService`.
+ *
+ * Use the `DialogRef` class to control and interact with Dialogs opened programmatically. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/dialogservice#open))
+ *
+ */
+declare class DialogRef {
+    /**
+     * Emits events when the Dialog is closed either through the **Close** button of the title bar or through the action buttons. If the **Close** button of the title bar is clicked, `DialogResult` is a `DialogCloseResult` instance. If the Dialog is closed through the action buttons, `DialogResult` contains the object that was passed when the Dialog was opened. When `close` is called with an argument, the result is the passed argument.
+     */
+    result: Observable<DialogResult>;
+    /**
+     * A reference to the Dialog instance.
+     */
+    dialog: ComponentRef<DialogComponent>;
+    /**
+     * A reference to the child component of the Dialog. Available when the Dialog is opened with [component content](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/service#rendering-the-content-area).
+     */
+    content: ComponentRef<any>;
+    /**
+     * Closes the Dialog programmatically. When called without a value, the resulting Observable emits an empty `DialogCloseResult` object. When called with a value, the resulting Observable emits the provided value.
+     *
+     * ```ts
+     * // Close without arguments: Returns an empty `DialogCloseResult` object.
+     * dialogRef.close();
+     *
+     * // Simulate clicking an action button: Pass a `DialogAction` object.
+     * dialogRef.close({ text: 'OK', primary: true });
+     *
+     * // Return custom data: Pass a custom object.
+     * dialogRef.close({ success: true, data: { id: 123 } });
+     * ```
+     */
+    close: Function;
+}
+
+/**
+ * Serves as the base class for a component provided as Dialog content through the `content` property.
+ * ([See example](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/service#single-component-rendering)).
+ *
+ * @example
+ * ```ts
+ * @Component({ ... })
+ * export class UserInfoComponent extends DialogContentBase {
+ *   constructor(public dialog: DialogRef) {
+ *     super(dialog);
+ *   }
+ * }
+ * ```
+ *
+ */
+declare class DialogContentBase {
+    dialog: DialogRef;
+    /**
+     * @hidden
+     */
+    dialogTitleBar: DialogTitleBarComponent;
+    /**
+     * @hidden
+     */
+    dialogActions: DialogActionsComponent;
+    constructor(dialog: DialogRef);
+    /**
+     * @hidden
+     */
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogContentBase, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class DialogContainerService {
+    private static container;
+    set container(container: ViewContainerRef);
+    get container(): ViewContainerRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContainerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogContainerService>;
+}
+
+/**
+ * Represents the settings for opening a Dialog through the `DialogService`.
+ * ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/dialogservice#open))
+ *
+ */
+declare class DialogSettings {
+    /**
+     * Use the `preventAction` callback to check if the pressed Dialog action should be prevented. If `true`, the Dialog does not close.
+     * If the **Close** button in the title bar is clicked, `DialogResult` is a `DialogCloseResult` instance.
+     * If the action buttons are used to close the Dialog, `DialogResult` contains the object passed when opening the Dialog. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/service#dialog-close-prevention))
+     * @param {DialogResult} ev The Dialog result.
+     * @param {DialogRef} [dialogRef] The Dialog reference, provided only when you create the Dialog using a component.
+     * @returns Returns `true` to prevent closing the Dialog.
+     */
+    preventAction?: (ev: DialogResult, dialogRef?: DialogRef) => boolean;
+    /**
+     * Sets the Dialog `title`. If you omit `title`, the Dialog does not render a **Close** button.
+     */
+    title?: string;
+    /**
+     * Sets the CSS classes for the Dialog wrapper element. Accepts any value supported by [`ngClass`](link:site.data.urls.angular['ngclassapi']).
+     */
+    cssClass?: any;
+    /**
+     * Configures the Dialog opening `animation` ([see example](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/animations)).
+     * @default { type: 'translate', duration: 300 }
+     */
+    animation?: boolean | DialogAnimation;
+    /**
+     * Sets the HTML attributes for the Dialog wrapper element. Accepts string key-value pairs.
+     *
+     * @remarks
+     * This option is related to accessibility.
+     */
+    htmlAttributes?: {
+        [key: string]: string;
+    };
+    /**
+     * Defines the Dialog `content`. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/service#rendering-the-content-area))
+     */
+    content?: string | TemplateRef<any> | Function;
+    /**
+     * Sets the width of the Dialog.
+     * Use a number for pixels or a string for other units, for example, `50%`.
+     */
+    width?: number | string;
+    /**
+     * Sets the minimum width of the Dialog.
+     * Use a number for pixels or a string for other units, for example, `50%`.
+     */
+    minWidth?: number | string;
+    /**
+     * Sets the maximum width of the Dialog.
+     * Use a number for pixels or a string for other units, for example, `50%`.
+     */
+    maxWidth?: number | string;
+    /**
+     * Sets the height of the Dialog.
+     * Use a number for pixels or a string for other units, for example, `50%`.
+     */
+    height?: number | string;
+    /**
+     * Sets the minimum height of the Dialog.
+     * Use a number for pixels or a string for other units, for example, `50%`.
+     */
+    minHeight?: number | string;
+    /**
+     * Sets the maximum height of the Dialog.
+     * Use a number for pixels or a string for other units, for example, `50%`.
+     */
+    maxHeight?: number | string;
+    /**
+     * Defines the container where the Dialog is inserted. This changes the place in the page hierarchy where the Dialog appears. The component styling stays the same.
+     */
+    appendTo?: ViewContainerRef;
+    /**
+     * Sets the `closeTitle` for the **Close** button.
+     */
+    closeTitle?: string;
+    /**
+     * Specifies whether the Dialog can be closed by the **Close** button in the title bar or by pressing the `Esc` key.
+     * @default true
+     */
+    closable?: boolean;
+    /**
+     * Sets the Dialog `actions` buttons.
+     */
+    actions?: any[] | TemplateRef<any>;
+    /**
+     * Sets the layout of the Dialog action buttons with `actionsLayout`.
+     */
+    actionsLayout?: ActionsLayout;
+    /**
+     * Sets the query selector for the element to focus automatically with `autoFocusedElement`.
+     */
+    autoFocusedElement?: string;
+}
+
+/**
+ * Provides a service for opening Dialog windows dynamically ([see example](https://www.telerik.com/kendo-angular-ui/components/dialogs/dialog/service)).
+ */
+declare class DialogService {
+    private containerService;
+    constructor(containerService: DialogContainerService);
+    /**
+     * Opens a Dialog window. Requires an element in the application that uses the
+     * [`kendoDialogContainer`](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/dialogcontainerdirective) directive.
+     * The created Dialog mounts in the DOM directly after that element.
+     *
+     * @param {DialogAction} options - The options that define the Dialog.
+     * @returns {DialogRef} - A reference to the Dialog object and its convenience properties.
+     *
+     * @example
+     * ```typescript
+     * const dialog = this.dialogService.open({
+     *   title: 'Confirm',
+     *   content: 'Are you sure?',
+     *   actions: [
+     *     { text: 'No' },
+     *     { text: 'Yes', themeColor: 'primary' }
+     *   ]
+     * });
+     * dialog.result.subscribe(result => {
+     *   // handle result
+     * });
+     * ```
+     */
+    open(options: DialogSettings): DialogRef;
+    private initializeDialog;
+    private applyOptions;
+    private contentFrom;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}
+
+/**
+ * @hidden
+ */
+interface ChangeEvent {
+    top?: number;
+    left?: number;
+    width?: number;
+    height?: number;
+}
+
+/**
+ * @hidden
+ */
+type WindowPosition = 'absolute' | 'fixed';
+/**
+ * Represents the possible states of the Window component.
+ */
+type WindowState = 'minimized' | 'maximized' | 'default';
+/**
+ * Represents the dimensions of the Window that can be resized dynamically.
+ */
+type WindowDimensionSetting = 'width' | 'height';
+/**
+ * Represents the offset of the Window that can be set dynamically.
+ */
+type WindowOffsetSetting = 'top' | 'left';
+
+/**
+ * @hidden
+ */
+interface WindowOptions {
+    width?: number;
+    height?: number;
+    minWidth: number;
+    minHeight: number;
+    top?: number;
+    left?: number;
+    position: WindowPosition;
+    state: WindowState;
+    draggable: boolean;
+    resizable: boolean;
+}
+
+/**
+ * @hidden
+ */
+declare class DragResizeService implements OnDestroy {
+    private ngZone;
+    close: EventEmitter<any>;
+    focus: EventEmitter<any>;
+    change: EventEmitter<ChangeEvent>;
+    stateChange: EventEmitter<WindowState>;
+    dragStart: EventEmitter<any>;
+    dragEnd: EventEmitter<any>;
+    resizeStart: EventEmitter<string>;
+    resizeEnd: EventEmitter<any>;
+    options: WindowOptions;
+    restoreOptions: WindowOptions;
+    window: ElementRef;
+    lastAction: string;
+    subscriptions: Subscription;
+    dragSubscription: Subscription;
+    constructor(ngZone: NgZone);
+    ngOnDestroy(): void;
+    init(el: ElementRef): void;
+    onDrag(el: DraggableDirective): void;
+    handleDrag({ originalX, originalY, pageX, pageY, startPosition }: {
+        originalX: any;
+        originalY: any;
+        pageX: any;
+        pageY: any;
+        startPosition: any;
+    }): void;
+    onResize(handle: DraggableDirective, direction: string): void;
+    handleResize(initial: any, dir: string, deltaX: number, deltaY: number): void;
+    restoreAction(): void;
+    defaultState(): void;
+    storeOptions(): void;
+    maximizeAction(): void;
+    maximizeState(): void;
+    minimizeAction(): void;
+    minimizeState(): void;
+    /**
+     * Handles manual changes of the 'state' property.
+     * Required to distinguish them from action clicks.
+     */
+    applyManualState(previousState?: WindowState): void;
+    closeAction(): void;
+    ensureWidth(): void;
+    center(): void;
+    currentOffsetAndPosition(): any;
+    currentPosition(): any;
+    setPosition(): void;
+    setRestoreOption(style: string, value: number): void;
+    get nextPossibleZIndex(): number;
+    get nextZIndex(): number;
+    get windowViewPort(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragResizeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragResizeService>;
+}
+
+/**
+ * @hidden
+ */
+declare class ResizeHandleDirective implements OnInit, OnDestroy {
+    draggable: DraggableDirective;
+    private el;
+    private renderer;
+    private service;
+    direction: string;
+    get hostClass(): boolean;
+    private subscriptions;
+    constructor(draggable: DraggableDirective, el: ElementRef, renderer: Renderer2, service: DragResizeService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setDisplay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeHandleDirective, [{ host: true; }, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeHandleDirective, "[kendoWindowResizeHandle]", never, { "direction": { "alias": "direction"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the title bar of the Window component.
+ *
+ */
+declare class WindowTitleBarComponent implements OnInit, AfterViewInit, OnDestroy {
+    el: ElementRef;
+    private ngZone;
+    /**
+     * @hidden
+     */
+    template: TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    id: string;
+    /**
+     * @hidden
+     */
+    service: DragResizeService;
+    private dragDirective;
+    private dragSubscription;
+    private stateSubscription;
+    constructor(el: ElementRef, service: DragResizeService, ngZone: NgZone);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * @hidden
+     */
+    subscribeDrag(): void;
+    /**
+     * @hidden
+     */
+    subscribeStateChange(): void;
+    /**
+     * @hidden
+     */
+    unsubscribeDrag(): void;
+    /**
+     * @hidden
+     */
+    unsubscribeState(): void;
+    get className(): true;
+    get touchAction(): string;
+    /**
+     * @hidden
+     */
+    handle(ev: any): void;
+    protected get isDraggable(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowTitleBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WindowTitleBarComponent, "kendo-window-titlebar", never, { "template": { "alias": "template"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class NavigationService {
+    private window;
+    private ngZone;
+    constructor(window: DragResizeService, ngZone: NgZone);
+    process(ev: KeyboardEvent): void;
+    handleArrow(key: string, ev: KeyboardEvent): void;
+    handleEscape(): void;
+    handleDrag(key: string): void;
+    handleResize(key: string): void;
+    handleStateChange(key: string, state: WindowState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
+}
+
+/**
+ * Defines the text of the labels that appear in the Window. Use for localization.
+ *
+ */
+interface WindowMessages {
+    /**
+     * Specifies the title of the close button.
+     */
+    closeTitle?: string;
+    /**
+     * Specifies the title of the restore button.
+     */
+    restoreTitle?: string;
+    /**
+     * Specifies the title of the maximize button.
+     */
+    maximizeTitle?: string;
+    /**
+     * Specifies the title of the minimize button.
+     */
+    minimizeTitle?: string;
+}
+
+/**
+ * Represents the [Kendo UI Window component for Angular](https://www.telerik.com/kendo-angular-ui/components/dialogs/window).
+ *
+ * @example
+ * ```html
+ * <kendo-window title="My Window" [width]="400" [height]="300">
+ * </kendo-window>
+ * ```
+ *
+  * @remarks
+ * Supported children components are: {@link CustomMessagesComponent}, {@link WindowTitleBarComponent}.
+ */
+declare class WindowComponent implements OnInit, OnDestroy, OnChanges, AfterViewInit {
+    private el;
+    private renderer;
+    private service;
+    private navigation;
+    private ngZone;
+    private localization;
+    /**
+     * Specifies the query selector used to set the initial focus ([see examples](https://www.telerik.com/kendo-angular-ui/components/dialogs/window/initial-focus)).
+     *
+     * @remarks
+     * This property is related to accessibility.
+     */
+    autoFocusedElement: string;
+    /**
+     * Sets the text in the title bar.
+     */
+    title: string;
+    /**
+     * Specifies if the user can drag the component.
+     * @default true
+     */
+    set draggable(value: boolean);
+    get draggable(): boolean;
+    /**
+     * Specifies if the user can resize the component.
+     * @default true
+     */
+    set resizable(value: boolean);
+    get resizable(): boolean;
+    /**
+     * @hidden
+     */
+    set cssClass(classes: any);
+    get cssClass(): any;
+    /**
+     * @hidden
+     */
+    set htmlAttributes(attributes: {
+        [key: string]: string;
+    });
+    get htmlAttributes(): {
+        [key: string]: string;
+    };
+    /**
+     * Specifies if the content stays in the DOM when minimized.
+     * @default false
+     */
+    keepContent: boolean;
+    /**
+     * Sets the initial state of the Window.
+     */
+    set state(value: WindowState);
+    get state(): WindowState;
+    /**
+     * Sets the minimum width in pixels.
+     * @default 120
+     */
+    set minWidth(value: number);
+    get minWidth(): number;
+    /**
+     * Sets the minimum height in pixels.
+     * @default 100
+     */
+    set minHeight(value: number);
+    get minHeight(): number;
+    /**
+     * Sets the width in pixels.
+     */
+    set width(value: number);
+    get width(): number;
+    /**
+     * Sets the height in pixels.
+     */
+    set height(value: number);
+    get height(): number;
+    /**
+     * Sets the initial top offset in pixels.
+     */
+    set top(value: number);
+    get top(): number;
+    /**
+     * Sets the initial left offset in pixels.
+     */
+    set left(value: number);
+    get left(): number;
+    get closeButtonTitle(): string;
+    get restoreButtonTitle(): string;
+    get maximizeButtonTitle(): string;
+    get minimizeButtonTitle(): string;
+    /**
+     * Fires when the user starts to move the Window.
+     */
+    dragStart: EventEmitter<any>;
+    /**
+     * Fires after the Window has been moved by the user.
+     */
+    dragEnd: EventEmitter<any>;
+    /**
+     * Fires when the user starts to resize the Window.
+     */
+    resizeStart: EventEmitter<any>;
+    /**
+     * Fires after the Window has been resized by the user.
+     */
+    resizeEnd: EventEmitter<any>;
+    /**
+     * Fires when the user closes the Window.
+     */
+    close: EventEmitter<any>;
+    /**
+     * Fires when the `width` property is updated after resizing. The event data contains the new width. Allows two-way binding of the `width` property.
+     */
+    widthChange: EventEmitter<number>;
+    /**
+     * Fires when the `height` property is updated after resizing. The event data contains the new height. Allows two-way binding of the `height` property.
+     */
+    heightChange: EventEmitter<number>;
+    /**
+     * Fires when the `top` property is updated after dragging or resizing. The event data contains the new top offset. Allows two-way binding of the `top` property.
+     */
+    topChange: EventEmitter<number>;
+    /**
+     * Fires when the `left` property is updated after dragging or resizing. The event data contains the new left offset. Allows two-way binding of the `left` property.
+     */
+    leftChange: EventEmitter<number>;
+    /**
+     * Fires when the `state` property is updated. The event data contains the new state. Allows two-way binding of the `state` property.
+     */
+    stateChange: EventEmitter<WindowState>;
+    /**
+     * @hidden
+     */
+    contentTemplate: TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    titleBarTemplate: TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    messages: WindowMessages;
+    /**
+     * @hidden
+     */
+    showLicenseWatermark: boolean;
+    /**
+     * @hidden
+     */
+    licenseMessage?: LicenseMessage;
+    tabIndex: number;
+    role: string;
+    hostClass: boolean;
+    get dir(): string;
+    titleBarView: WindowTitleBarComponent;
+    titleBarContent: WindowTitleBarComponent;
+    resizeHandles: QueryList<ResizeHandleDirective>;
+    resizeDirections: Array<string>;
+    /**
+     * @hidden
+     */
+    titleId: string;
+    private _htmlAttributes;
+    private _cssClass;
+    private direction;
+    private draged;
+    private resized;
+    private windowSubscription;
+    private domSubs;
+    private localizationChangeSubscription;
+    private stateAppliedByAction;
+    constructor(el: ElementRef, renderer: Renderer2, service: DragResizeService, navigation: NavigationService, ngZone: NgZone, localization: LocalizationService);
+    ngAfterViewInit(): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: {
+        [propertyName: string]: SimpleChange;
+    }): void;
+    ngOnDestroy(): void;
+    /**
+     * Focuses the wrapper of the Window component.
+     */
+    focus(): void;
+    /**
+     * Brings the current Window component on top of other Window components on the page.
+     */
+    bringToFront(): void;
+    /**
+     * Manually updates the `width` or `height` option of the Window.
+     * The required style will be applied to the Window wrapper element and the
+     * corresponding property of the component instance will be updated.
+     * This method is intended to be used for sizing dynamically created components using the
+     * [`WindowService`](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/windowservice)
+     * @param dimension The option to update.
+     * @param value The value in pixels.
+     */
+    setDimension(dimension: WindowDimensionSetting, value: number): void;
+    /**
+     * Manually updates the `top` or `left` offset of the Window.
+     * The required style will be applied to the Window wrapper element and the
+     * corresponding property of the component instance will be updated.
+     * This method is intended to be used for positioning dynamically created components using the
+     * [`WindowService`](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/windowservice)
+     * @param offset The option to update.
+     * @param value The value in pixels.
+     */
+    setOffset(offset: WindowOffsetSetting, value: number): void;
+    get showDefaultTitleBar(): boolean;
+    get styleMinWidth(): string;
+    get styleMinHeight(): string;
+    get stylePosition(): string;
+    get wrapperMaximizedClass(): boolean;
+    get wrapperMinimizedClass(): boolean;
+    /**
+     * @hidden
+     */
+    onComponentFocus(): void;
+    /**
+     * @hidden
+     */
+    onComponentBlur(): void;
+    private subscribeEvents;
+    private initDomEvents;
+    private onKeyDown;
+    private setServiceClasses;
+    private setNextZIndex;
+    private setInitialOffset;
+    private updateAllOffset;
+    private setStyle;
+    private removeStyle;
+    private get options();
+    private setOption;
+    private handleInitialFocus;
+    /**
+     * @hidden
+     */
+    private generateTitleId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WindowComponent, "kendo-window", ["kendoWindow"], { "autoFocusedElement": { "alias": "autoFocusedElement"; "required": false; }; "title": { "alias": "title"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "keepContent": { "alias": "keepContent"; "required": false; }; "state": { "alias": "state"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "top": { "alias": "top"; "required": false; }; "left": { "alias": "left"; "required": false; }; }, { "dragStart": "dragStart"; "dragEnd": "dragEnd"; "resizeStart": "resizeStart"; "resizeEnd": "resizeEnd"; "close": "close"; "widthChange": "widthChange"; "heightChange": "heightChange"; "topChange": "topChange"; "leftChange": "leftChange"; "stateChange": "stateChange"; }, ["titleBarContent"], ["kendo-window-titlebar", "*"], true, never>;
+}
+
+/**
+ * Represents the maximize action directive of the Window component.
+ *
+ * ```html
+ * <button kendoWindowMaximizeAction>Maximize</button>
+ * ```
+ */
+declare class WindowMaximizeActionDirective extends Button {
+    /**
+     * @hidden
+     */
+    window: any;
+    buttonType: string;
+    buttonClass: boolean;
+    /**
+     * @hidden
+     */
+    windowIcon: SVGIcon;
+    constructor(el: ElementRef, renderer: Renderer2, _service: DragResizeService, localization: LocalizationService, ngZone: NgZone);
+    /**
+     * @hidden
+     */
+    onClick(): void;
+    get visible(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowMaximizeActionDirective, [null, null, { optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WindowMaximizeActionDirective, "button[kendoWindowMaximizeAction]", ["kendoWindowMaximizeAction"], { "window": { "alias": "window"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Represents the minimize action directive of the Window component.
+ *
+ * ```html
+ * <button kendoWindowMinimizeAction>Minimize</button>
+ * ```
+ */
+declare class WindowMinimizeActionDirective extends Button {
+    /**
+     * @hidden
+     */
+    window: any;
+    buttonType: string;
+    buttonClass: boolean;
+    /**
+     * @hidden
+     */
+    windowMinimizeIcon: SVGIcon;
+    constructor(el: ElementRef, renderer: Renderer2, _service: DragResizeService, localization: LocalizationService, ngZone: NgZone);
+    /**
+     * @hidden
+     */
+    onClick(): void;
+    get visible(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowMinimizeActionDirective, [null, null, { optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WindowMinimizeActionDirective, "button[kendoWindowMinimizeAction]", ["kendoWindowMinimizeAction"], { "window": { "alias": "window"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Represents the close action directive of the Window component.
+ *
+ * ```html
+ * <button kendoWindowCloseAction>Close</button>
+ * ```
+ */
+declare class WindowCloseActionDirective extends Button {
+    /**
+     * @hidden
+     */
+    window: any;
+    /**
+     * @hidden
+     */
+    xIcon: SVGIcon;
+    buttonType: string;
+    buttonClass: boolean;
+    constructor(el: ElementRef, renderer: Renderer2, _service: DragResizeService, localization: LocalizationService, ngZone: NgZone);
+    /**
+     * @hidden
+     */
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowCloseActionDirective, [null, null, { optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WindowCloseActionDirective, "button[kendoWindowCloseAction]", ["kendoWindowCloseAction"], { "window": { "alias": "window"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Represents the restore action directive of the Window component.
+ *
+ * ```html
+ * <button kendoWindowRestoreAction>Restore</button>
+ * ```
+ */
+declare class WindowRestoreActionDirective extends Button {
+    /**
+     * @hidden
+     */
+    window: any;
+    /**
+     * @hidden
+     */
+    windowRestoreIcon: SVGIcon;
+    buttonType: string;
+    buttonClass: boolean;
+    constructor(el: ElementRef, renderer: Renderer2, _service: DragResizeService, localization: LocalizationService, ngZone: NgZone);
+    /**
+     * @hidden
+     */
+    onClick(): void;
+    get visible(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowRestoreActionDirective, [null, null, { optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WindowRestoreActionDirective, "button[kendoWindowRestoreAction]", ["kendoWindowRestoreAction"], { "window": { "alias": "window"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Indicates that the **Close** button of a Window opened through `WindowService` is clicked.
+ *
+ */
+declare class WindowCloseResult {
+}
+
+/**
+ * Holds references to the Window instance. Controls Windows opened through `WindowService`. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/windowservice#open))
+ */
+declare class WindowRef {
+    /**
+     * Represents a reference to the Window instance.
+     */
+    window: ComponentRef<WindowComponent>;
+    /**
+     * Represents a reference to the child component of the Window. Available when you open the Window with [component content](https://www.telerik.com/kendo-angular-ui/components/dialogs/window/service#rendering-the-content-area).
+     */
+    content: ComponentRef<any>;
+    /**
+     * Allows you to close the Window by using code. When called with no arguments, the `result` Observable is of type `WindowCloseResult`. When called with an argument, the `result` Observable holds the provided value.
+     */
+    close: Function;
+    /**
+     * Emits events when the Window is closed through the `Esc` key, the **Close** button of the title bar, or by calling the `close` method. When the Window is closed with the title bar button, `Esc`, or by calling `close` with no arguments, the result is of type [`WindowCloseResult`](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/windowcloseresult). When `close` is called with an argument, the result is the passed argument.
+     */
+    result: Observable<WindowCloseResult>;
+}
+
+/**
+ * Represents the settings for the Window actions when you open a Window through `WindowService`. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/windowservice#open))
+ */
+declare class WindowSettings {
+    /**
+     * Use the `preventClose` predicate to check if closing the Window should be prevented. Applies to clicking the **Close** button, pressing **Esc**, or calling the `close` method. Return `true` to prevent closing. If the **Close** button or **Esc** is used, a [`WindowCloseResult`](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/windowcloseresult) instance is passed.
+     * @param {any} ev The event argument.
+     * @param {WindowRef} [windowRef] - The window reference, provided only when you create the window using a component.
+     * @returns Returns `true` to prevent closing the window.
+     */
+    preventClose?: (ev: any, windowRef?: WindowRef) => boolean;
+    /**
+     * Sets the Window `title`.
+     */
+    title?: string;
+    /**
+     * Defines the Window `content`.
+     */
+    content?: string | TemplateRef<any> | Function;
+    /**
+     * Defines the content of the title bar.
+     */
+    titleBarContent?: TemplateRef<any>;
+    /**
+     * Sets the text of the labels shown in the Window. Use for localization.
+     */
+    messages?: WindowMessages;
+    /**
+     * Set to `true` to persist the Window content in the DOM when minimized.
+     */
+    keepContent?: boolean;
+    /**
+     * Sets the width of the Window in pixels.
+     */
+    width?: number;
+    /**
+     * Sets the minimum width of the Window in pixels.
+     */
+    minWidth?: number;
+    /**
+     * Sets the height of the Window in pixels.
+     */
+    height?: number;
+    /**
+     * Sets the minimum height of the Window in pixels.
+     */
+    minHeight?: number;
+    /**
+     * Sets the left offset of the Window in pixels.
+     */
+    left?: number;
+    /**
+     * Sets the top offset of the Window in pixels.
+     */
+    top?: number;
+    /**
+     * Specifies is the Window is draggable.
+     */
+    draggable?: boolean;
+    /**
+     * Sets custom CSS classes for the Window wrapper element. Accepts any value supported by [`ngClass`](link:site.data.urls.angular['ngclassapi']).
+     */
+    cssClass?: any;
+    /**
+     * Sets HTML attributes for the Window wrapper element. Accepts string key-value pairs.
+     *
+     * @remarks
+     * This option is related to accessibility.
+     */
+    htmlAttributes?: {
+        [key: string]: string;
+    };
+    /**
+     * Specifies if the Window is resizable.
+     */
+    resizable?: boolean;
+    /**
+     * Sets the initial state of the Window.
+     */
+    state?: WindowState;
+    /**
+     * Defines the container where the Window is inserted. This changes the place in the page hierarchy where the Window appears.
+     */
+    appendTo?: ViewContainerRef;
+    /**
+     * Sets the query selector for the element to focus automatically.
+     */
+    autoFocusedElement?: string;
+}
+
+/**
+ * @hidden
+ */
+declare class WindowContainerService {
+    private static container;
+    set container(container: ViewContainerRef);
+    get container(): ViewContainerRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowContainerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WindowContainerService>;
+}
+
+/**
+ * Provides methods for opening Windows dynamically.
+ *
+ * Use this service to open a Window component and manage its lifecycle. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/window/service))
+ */
+declare class WindowService {
+    private containerService;
+    constructor(containerService: WindowContainerService);
+    /**
+     * Opens a Window component with the specified settings.
+     *
+     * @param settings The settings that configure the Window.
+     * @returns A `WindowRef` instance for controlling the Window.
+     *
+     * @example
+     * ```ts
+     * const window = windowService.open({
+     *   title: 'My window',
+     *   content: 'My content!'
+     * });
+     * ```
+     */
+    open(settings: WindowSettings): WindowRef;
+    private applyOptions;
+    private contentFrom;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WindowService>;
+}
+
+/**
+ * Represents an insertion point for Dialogs created through the Dialog service.
+ * The created Dialogs mount after this element. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/dialogservice#open))
+ *
+ * @example
+ * ```html
+ * <div kendoDialogContainer></div>
+ * ```
+ */
+declare class DialogContainerDirective {
+    constructor(container: ViewContainerRef, service: DialogContainerService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogContainerDirective, "[kendoDialogContainer]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class Messages extends ComponentMessages {
+    /**
+     * Sets the title for the **Close** button.
+     */
+    closeTitle: string;
+    /**
+     * Sets the title for the **Restore** button.
+     */
+    restoreTitle: string;
+    /**
+     * Sets the title for the **Maximize** button.
+     */
+    maximizeTitle: string;
+    /**
+     * Sets the title for the **Minimize** button.
+     */
+    minimizeTitle: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Messages, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Messages, "kendo-dialog-messages-base", never, { "closeTitle": { "alias": "closeTitle"; "required": false; }; "restoreTitle": { "alias": "restoreTitle"; "required": false; }; "maximizeTitle": { "alias": "maximizeTitle"; "required": false; }; "minimizeTitle": { "alias": "minimizeTitle"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a component for customizing the messages in Dialog and Window components.
+ *
+ * Use the `CustomMessagesComponent` to override default messages with custom text. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/globalization#internationalization)).
+ *
+ * @example
+ * ```typescript
+ * import { CustomMessagesComponent } from './custom-messages.component';
+ *
+ * @Component({
+ *   selector: 'my-dialog',
+ *   template: `
+ *     <kendo-dialog>
+ *       <kendo-dialog-messages
+ *         [closeTitle]="'Close dialog'"
+ *         [restoreTitle]="'Restore dialog'"
+ *         [maximizeTitle]="'Maximize dialog'"
+ *         [minimizeTitle]="'Minimize dialog'">
+ *       </kendo-dialog-messages>
+ *     </kendo-dialog>
+ *   `
+ * })
+ * export class MyDialogComponent {}
+ * ```
+ */
+declare class CustomMessagesComponent extends Messages {
+    protected service: LocalizationService;
+    constructor(service: LocalizationService);
+    protected get override(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomMessagesComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomMessagesComponent, "kendo-dialog-messages, kendo-window-messages", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the [NgModule](link:site.data.urls.angular['ngmoduleapi']) definition for the Dialog component.
+ *
+ * Use the `DialogModule` to include all Dialog components and directives in your application.
+ *
+ * @example
+ * ```typescript
+ * import { NgModule } from '@angular/core';
+ * import { BrowserModule } from '@angular/platform-browser';
+ * import { DialogModule } from '@progress/kendo-angular-dialog';
+ * import { AppComponent } from './app.component';
+ *
+ * @NgModule({
+ *     bootstrap:    [AppComponent],
+ *     declarations: [AppComponent],
+ *     imports:      [BrowserModule, DialogModule]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class DialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogModule, never, [typeof DialogComponent, typeof DialogTitleBarComponent, typeof DialogContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent], [typeof DialogComponent, typeof DialogTitleBarComponent, typeof DialogContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DialogModule>;
+}
+
+/**
+ * Represents an insertion point for Windows created through the Window service.
+ * The created Windows mount after this element. ([See example.](https://www.telerik.com/kendo-angular-ui/components/dialogs/api/windowservice#open))
+ *
+ * @example
+ * ```html
+ * <div kendoWindowContainer></div>
+ * ```
+ */
+declare class WindowContainerDirective {
+    constructor(container: ViewContainerRef, service: WindowContainerService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WindowContainerDirective, "[kendoWindowContainer]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the [NgModule](link:site.data.urls.angular['ngmoduleapi']) definition for the Window component.
+ *
+ * Use the `WindowModule` to include all Window components and directives in your application.
+ *
+ * @example
+ * ```typescript
+ * import { NgModule } from '@angular/core';
+ * import { BrowserModule } from '@angular/platform-browser';
+ * import { WindowModule } from '@progress/kendo-angular-window';
+ * import { AppComponent } from './app.component';
+ *
+ * @NgModule({
+ *     bootstrap:    [AppComponent],
+ *     declarations: [AppComponent],
+ *     imports:      [BrowserModule, WindowModule]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class WindowModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<WindowModule, never, [typeof WindowComponent, typeof WindowCloseActionDirective, typeof WindowMinimizeActionDirective, typeof WindowMaximizeActionDirective, typeof WindowRestoreActionDirective, typeof WindowTitleBarComponent, typeof WindowContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent], [typeof WindowComponent, typeof WindowCloseActionDirective, typeof WindowMinimizeActionDirective, typeof WindowMaximizeActionDirective, typeof WindowRestoreActionDirective, typeof WindowTitleBarComponent, typeof WindowContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<WindowModule>;
+}
+
+/**
+ * Represents the [NgModule](link:site.data.urls.angular['ngmoduleapi']) definition for the Dialogs components.
+ *
+ * Use the `DialogsModule` to include all Dialog and Window components and services in your application.
+ *
+ * @example
+ * ```typescript
+ * import { DialogsModule } from '@progress/kendo-angular-dialog';
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ * import { NgModule } from '@angular/core';
+ * import { AppComponent } from './app.component';
+ *
+ * @NgModule({
+ *     declarations: [AppComponent],
+ *     imports:      [BrowserModule, DialogsModule],
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ *
+ * ```
+ */
+declare class DialogsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogsModule, never, [typeof DialogComponent, typeof DialogTitleBarComponent, typeof DialogContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent, typeof WindowComponent, typeof WindowCloseActionDirective, typeof WindowMinimizeActionDirective, typeof WindowMaximizeActionDirective, typeof WindowRestoreActionDirective, typeof WindowTitleBarComponent, typeof WindowContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent], [typeof DialogComponent, typeof DialogTitleBarComponent, typeof DialogContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent, typeof WindowComponent, typeof WindowCloseActionDirective, typeof WindowMinimizeActionDirective, typeof WindowMaximizeActionDirective, typeof WindowRestoreActionDirective, typeof WindowTitleBarComponent, typeof WindowContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DialogsModule>;
+}
+
+/**
+ * @hidden
+ */
+declare class LocalizedMessagesDirective extends Messages {
+    protected service: LocalizationService;
+    constructor(service: LocalizationService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizedMessagesDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LocalizedMessagesDirective, "    [kendoDialogLocalizedMessages],    [kendoWindowLocalizedMessages],    [kendoDialogTitleBarLocalizedMessages]  ", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the utility array that that contains all `Dialog`-related components and directives.
+ *
+ * Use `KENDO_DIALOG` to import all Dialog components and directives at once.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { KENDO_DIALOG } from '@progress/kendo-angular-dialog';
+ *
+ * @Component({
+ *   selector: 'my-dialog-app',
+ *   standalone: true,
+ *   imports: [KENDO_DIALOG],
+ *   template: `...`
+ * })
+ * export class DialogAppComponent {}
+ * ```
+ */
+declare const KENDO_DIALOG: readonly [typeof DialogComponent, typeof DialogTitleBarComponent, typeof DialogContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent];
+/**
+ * Represents the utility array that contains all `Window`-related components and directives.
+ *
+ * Use `KENDO_WINDOW` to import all Window components and directives at once.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { KENDO_WINDOW } from '@progress/kendo-angular-dialog';
+ *
+ * @Component({
+ *   selector: 'my-window-app',
+ *   standalone: true,
+ *   imports: [KENDO_WINDOW],
+ *   template: `...`
+ * })
+ * export class WindowAppComponent {}
+ * ```
+ */
+declare const KENDO_WINDOW: readonly [typeof WindowComponent, typeof WindowCloseActionDirective, typeof WindowMinimizeActionDirective, typeof WindowMaximizeActionDirective, typeof WindowRestoreActionDirective, typeof WindowTitleBarComponent, typeof WindowContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent];
+/**
+ * Represents the utility array that contains all `@progress/kendo-angular-dialog`-related components and directives.
+ *
+ * Use `KENDO_DIALOGS` to import all Dialog and Window components and directives at once.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { KENDO_DIALOGS } from '@progress/kendo-angular-dialog';
+ *
+ * @Component({
+ *   selector: 'my-app',
+ *   standalone: true,
+ *   imports: [KENDO_DIALOGS],
+ *   template: `...`
+ * })
+ * export class AppComponent {}
+ * ```
+ */
+declare const KENDO_DIALOGS: readonly [typeof DialogComponent, typeof DialogTitleBarComponent, typeof DialogContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent, typeof WindowComponent, typeof WindowCloseActionDirective, typeof WindowMinimizeActionDirective, typeof WindowMaximizeActionDirective, typeof WindowRestoreActionDirective, typeof WindowTitleBarComponent, typeof WindowContainerDirective, typeof DialogActionsComponent, typeof CustomMessagesComponent];
+
+export { CustomMessagesComponent, DialogAction, DialogActionsComponent, DialogCloseResult, DialogComponent, DialogContainerDirective, DialogContainerService, DialogContentBase, DialogModule, DialogRef, DialogService, DialogSettings, DialogTitleBarComponent, DialogsModule, DragResizeService, KENDO_DIALOG, KENDO_DIALOGS, KENDO_WINDOW, LocalizedMessagesDirective, Messages, NavigationService, PreventableEvent, WindowCloseActionDirective, WindowCloseResult, WindowComponent, WindowContainerDirective, WindowContainerService, WindowMaximizeActionDirective, WindowMinimizeActionDirective, WindowModule, WindowRef, WindowRestoreActionDirective, WindowService, WindowSettings, WindowTitleBarComponent };
+export type { ActionsLayout, AnimationDirection, DialogActionDivider, DialogAnimation, DialogAnimationType, DialogResult, WindowDimensionSetting, WindowState };