
if(typeof window !== 'undefined') {	
	if (!window['Smart']) {
		window['Smart'] = { RenderMode: 'manual' };
	}
	else {
		window['Smart'].RenderMode = 'manual';
	}
}
import './../source/modules/smart.window';

import * as i0 from '@angular/core';
import { EventEmitter, Directive, Output, Input, NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';

class BaseElement {
    constructor(ref) {
        this.onCreate = new EventEmitter();
        this.onReady = new EventEmitter();
        this.onAttach = new EventEmitter();
        this.onDetach = new EventEmitter();
        const that = this;
        this.nativeElement = ref.nativeElement;
        that.nativeElement.onAttached = () => {
            that.onAttach.emit(that.nativeElement);
        };
        that.nativeElement.onDetached = () => {
            that.onDetach.emit(that.nativeElement);
        };
    }
    addEventListener(type, listener, options = false) {
        this.nativeElement.addEventListener(type, listener, options);
    }
    removeEventListener(type, listener, options = false) {
        this.nativeElement.removeEventListener(type, listener, options);
    }
    dispatchEvent(event) {
        return this.nativeElement.dispatchEvent(event);
    }
    blur() {
        this.nativeElement.blur();
    }
    click() {
        this.nativeElement.click();
    }
    focus(options) {
        this.nativeElement.focus(options);
    }
    /** @description Sets or gets the license.  */
    get license() {
        return this.nativeElement ? this.nativeElement.license : undefined;
    }
    set license(value) {
        this.nativeElement ? this.nativeElement.license = value : undefined;
    }
    /** @description Sets or gets the language. Used in conjunction with the property messages.  */
    get locale() {
        return this.nativeElement ? this.nativeElement.locale : undefined;
    }
    set locale(value) {
        this.nativeElement ? this.nativeElement.locale = value : undefined;
    }
    /** @description Callback used to customize the format of the messages that are returned from the Localization Module. */
    get localizeFormatFunction() {
        return this.nativeElement ? this.nativeElement.localizeFormatFunction : undefined;
    }
    set localizeFormatFunction(value) {
        this.nativeElement ? this.nativeElement.localizeFormatFunction = value : undefined;
    }
    /** @description Sets or gets an object specifying strings used in the widget that can be localized. Used in conjunction with the property locale.  */
    get messages() {
        return this.nativeElement ? this.nativeElement.messages : undefined;
    }
    set messages(value) {
        this.nativeElement ? this.nativeElement.messages = value : undefined;
    }
    /** @description Sets or gets the value indicating whether the element is aligned to support locales using right-to-left fonts. */
    get rightToLeft() {
        return this.nativeElement ? this.nativeElement.rightToLeft : undefined;
    }
    set rightToLeft(value) {
        this.nativeElement ? this.nativeElement.rightToLeft = value : undefined;
    }
    /** @description Determines the theme. Theme defines the look of the element */
    get theme() {
        return this.nativeElement ? this.nativeElement.theme : undefined;
    }
    set theme(value) {
        this.nativeElement ? this.nativeElement.theme = value : undefined;
    }
}
BaseElement.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: BaseElement, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
BaseElement.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.6", type: BaseElement, inputs: { license: "license", locale: "locale", localizeFormatFunction: "localizeFormatFunction", messages: "messages", rightToLeft: "rightToLeft", theme: "theme" }, outputs: { onCreate: "onCreate", onReady: "onReady", onAttach: "onAttach", onDetach: "onDetach" }, ngImport: i0 });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: BaseElement, decorators: [{
            type: Directive
        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { onCreate: [{
                type: Output
            }], onReady: [{
                type: Output
            }], onAttach: [{
                type: Output
            }], onDetach: [{
                type: Output
            }], license: [{
                type: Input
            }], locale: [{
                type: Input
            }], localizeFormatFunction: [{
                type: Input
            }], messages: [{
                type: Input
            }], rightToLeft: [{
                type: Input
            }], theme: [{
                type: Input
            }] } });
let Smart;
if (typeof window !== "undefined") {
    Smart = window.Smart;
}

class WindowComponent extends BaseElement {
    constructor(ref) {
        super(ref);
        this.eventHandlers = [];
        /** @description This event is triggered immediately before the window begins its opening process, allowing developers to perform any preparatory actions or modifications prior to the window becoming visible to the user.
        *  @param event. The custom event. 	*/
        this.onOpening = new EventEmitter();
        /** @description This event is triggered when the window becomes visible to the user—specifically, when it is opened or brought into view.
        *  @param event. The custom event. 	*/
        this.onOpen = new EventEmitter();
        /** @description This event is triggered immediately before the window begins the closing process, allowing developers to execute custom logic or prompt the user for confirmation before the window is fully closed.
        *  @param event. The custom event. 	*/
        this.onClosing = new EventEmitter();
        /** @description This event is triggered when the window is closed or becomes hidden, such as when the user closes the browser tab, navigates away, or minimizes the window, causing it to no longer be visible to the user.
        *  @param event. The custom event. 	*/
        this.onClose = new EventEmitter();
        /** @description This event is triggered whenever the application window is minimized or collapsed by the user. It allows you to execute custom logic in response to the window being hidden from view.
        *  @param event. The custom event. 	*/
        this.onCollapse = new EventEmitter();
        /** @description This event is triggered when the user finishes dragging the window, signaling the completion of the drag-and-drop operation. It occurs after the mouse button is released and the window movement has stopped.
        *  @param event. The custom event. 	*/
        this.onDragEnd = new EventEmitter();
        /** @description This event is triggered when the user initiates a window drag operation, indicating that the dragging of the window has begun. It fires as soon as the user starts moving the window, typically by clicking and holding the window's title bar.
        *  @param event. The custom event. 	*/
        this.onDragStart = new EventEmitter();
        /** @description This event is triggered whenever the window is resized to a larger size, indicating that the user has expanded the window either by dragging its edges or by maximizing it.
        *  @param event. The custom event. 	*/
        this.onExpand = new EventEmitter();
        /** @description This event is triggered whenever the application window transitions into a maximized state. It fires immediately after the window expands to fill the available screen space, allowing developers to implement custom logic in response to the window being maximized by the user or programmatically.
        *  @param event. The custom event. 	*/
        this.onMaximize = new EventEmitter();
        /** @description This event is triggered whenever the application window is minimized by the user. It occurs immediately after the minimize action takes place, allowing developers to execute custom logic—such as pausing background processes, saving state, or updating the UI—in response to the window being minimized.
        *  @param event. The custom event. 	*/
        this.onMinimize = new EventEmitter();
        /** @description This event is triggered when the user completes resizing the browser window, specifically after the resizing action has finished and the window size is no longer changing.
        *  @param event. The custom event. 	*/
        this.onResizeEnd = new EventEmitter();
        /** @description This event is triggered when the user initiates a window resize action, such as clicking and dragging the window’s edge or corner to change its dimensions. It marks the beginning of the window resizing process, allowing you to execute scripts or handle UI updates as soon as resizing starts.
        *  @param event. The custom event. 	*/
        this.onResizeStart = new EventEmitter();
        /** @description This event is triggered when the window is returned to its original size and position after being maximized, effectively restoring it to the state it was in prior to maximization.
        *  @param event. The custom event. 	*/
        this.onRestore = new EventEmitter();
        this.nativeElement = ref.nativeElement;
    }
    /** @description Creates the component on demand.
     * @param properties An optional object of properties, which will be added to the template binded ones.
     */
    createComponent(properties = {}) {
        this.nativeElement = document.createElement('smart-window');
        for (let propertyName in properties) {
            this.nativeElement[propertyName] = properties[propertyName];
        }
        return this.nativeElement;
    }
    /** @description Determines whether the 'Add New' tab within the Tabs element is currently visible to the user.  Note: This property is only relevant when used with the TabsWindow component; it does not apply to other components. */
    get addNewTab() {
        return this.nativeElement ? this.nativeElement.addNewTab : undefined;
    }
    set addNewTab(value) {
        this.nativeElement ? this.nativeElement.addNewTab = value : undefined;
    }
    /** @description Sets or retrieves the current animation mode. When this property is set to 'none', all animations are disabled. If set to any other supported value, animations will be enabled and behave according to the specified mode. */
    get animation() {
        return this.nativeElement ? this.nativeElement.animation : undefined;
    }
    set animation(value) {
        this.nativeElement ? this.nativeElement.animation = value : undefined;
    }
    /** @description Controls the automatic capitalization behavior for user input as it is entered or edited. This setting specifies whether characters are auto-capitalized (e.g., sentences, words, or all characters) in the input field. Note: This property is only relevant when used with the MultilinePromptWindow component. */
    get autoCapitalize() {
        return this.nativeElement ? this.nativeElement.autoCapitalize : undefined;
    }
    set autoCapitalize(value) {
        this.nativeElement ? this.nativeElement.autoCapitalize = value : undefined;
    }
    /** @description Specifies whether the element should automatically expand its height to accommodate vertically overflowing input.  Note: This setting only applies to MultilinePromptWindow components. */
    get autoExpand() {
        return this.nativeElement ? this.nativeElement.autoExpand : undefined;
    }
    set autoExpand(value) {
        this.nativeElement ? this.nativeElement.autoExpand = value : undefined;
    }
    /** @description Specifies the text displayed on the 'Cancel' button within the Prompt Window. This label informs users which button will dismiss or close the prompt without taking any action. */
    get cancelLabel() {
        return this.nativeElement ? this.nativeElement.cancelLabel : undefined;
    }
    set cancelLabel(value) {
        this.nativeElement ? this.nativeElement.cancelLabel = value : undefined;
    }
    /** @description Specifies the text that appears on the 'Complete' button within the Progress Window, allowing customization of the button label to better suit user interface requirements. */
    get completeLabel() {
        return this.nativeElement ? this.nativeElement.completeLabel : undefined;
    }
    set completeLabel(value) {
        this.nativeElement ? this.nativeElement.completeLabel = value : undefined;
    }
    /** @description Specifies the text displayed on the 'Confirm' button within the Prompt Window, allowing customization of the button label to suit your application's context. */
    get confirmLabel() {
        return this.nativeElement ? this.nativeElement.confirmLabel : undefined;
    }
    set confirmLabel(value) {
        this.nativeElement ? this.nativeElement.confirmLabel = value : undefined;
    }
    /** @description Indicates whether the window is currently collapsed. When set to true, only the window's header is displayed while the content area is hidden. If false, both the header and the full content of the window are visible. */
    get collapsed() {
        return this.nativeElement ? this.nativeElement.collapsed : undefined;
    }
    set collapsed(value) {
        this.nativeElement ? this.nativeElement.collapsed = value : undefined;
    }
    /** @description When a modal window is opened, this property specifies whether clicking on the overlay (mask) outside the modal will close the window. Set it to true to allow users to dismiss the modal by clicking the mask, or false to require an explicit action (such as clicking a close button) to close the modal. */
    get closeOnMaskClick() {
        return this.nativeElement ? this.nativeElement.closeOnMaskClick : undefined;
    }
    set closeOnMaskClick(value) {
        this.nativeElement ? this.nativeElement.closeOnMaskClick = value : undefined;
    }
    /** @description Specifies the data source to be loaded into the TabsWindow component. This property is relevant exclusively for the TabsWindow and will not affect other components. */
    get dataSource() {
        return this.nativeElement ? this.nativeElement.dataSource : undefined;
    }
    set dataSource(value) {
        this.nativeElement ? this.nativeElement.dataSource = value : undefined;
    }
    /** @description Controls whether the window is active and visible to the user. When enabled, the window is operational and can be interacted with; when disabled, the window is hidden or inactive, and user interactions are ignored. */
    get disabled() {
        return this.nativeElement ? this.nativeElement.disabled : undefined;
    }
    set disabled(value) {
        this.nativeElement ? this.nativeElement.disabled = value : undefined;
    }
    /** @description Controls whether the window snapping feature is active. When enabled, users can automatically align and resize windows by dragging them to the edges or corners of the screen. Disabling this feature prevents windows from snapping into place during movement. */
    get disableSnap() {
        return this.nativeElement ? this.nativeElement.disableSnap : undefined;
    }
    set disableSnap(value) {
        this.nativeElement ? this.nativeElement.disableSnap = value : undefined;
    }
    /** @description By default, pressing the 'Escape' key will automatically close the window. To prevent the window from closing when 'Escape' is pressed, set this property to true. */
    get disableEscape() {
        return this.nativeElement ? this.nativeElement.disableEscape : undefined;
    }
    set disableEscape(value) {
        this.nativeElement ? this.nativeElement.disableEscape = value : undefined;
    }
    /** @description By default, the window handles certain keyboard inputs such as the arrow keys ('ArrowUp', 'ArrowDown', etc.), 'Escape', and similar keys for scrolling or navigation actions. Set this property to true to disable the window’s default keyboard handling, allowing you to manage these key events manually within your application. */
    get disableKeyboard() {
        return this.nativeElement ? this.nativeElement.disableKeyboard : undefined;
    }
    set disableKeyboard(value) {
        this.nativeElement ? this.nativeElement.disableKeyboard = value : undefined;
    }
    /** @description Specifies the visual presentation of characters entered within the input field. For example, this setting can control whether characters are shown as plain text or masked (such as for password fields). This option applies specifically to the Prompt Window component. */
    get displayMode() {
        return this.nativeElement ? this.nativeElement.displayMode : undefined;
    }
    set displayMode(value) {
        this.nativeElement ? this.nativeElement.displayMode = value : undefined;
    }
    /** @description ''Applicable to TabsWindow components when they are docked within a DockingLayout Custom Element.This property specifies the valid drop locations for the window—and its tab items—inside the DockingLayout. The property accepts an array of positional values, allowing you to define multiple allowable drop zones.Details:  Positions prefixed with 'layout-' apply to each individual tab item (child element) of the TabsWindow being dragged. These determine where tab items can be dropped within the overall layout, outside their original container.  Other position values (without the 'layout-' prefix) indicate allowed drop positions directly within the hovered target TabsWindow, specifying where the whole window or its tabs can be placed relative to the target window.Notes:  This property is used exclusively by jqxDockingLayout custom elements.  It controls the possible drop targets—both at the window and tab levels—within the DockingLayout environment.Allowed Values:  The array values specify the permitted drop positions. Refer to the documentation for a complete list of supported position strings. */
    get dropPosition() {
        return this.nativeElement ? this.nativeElement.dropPosition : undefined;
    }
    set dropPosition(value) {
        this.nativeElement ? this.nativeElement.dropPosition = value : undefined;
    }
    /** @description A callback function that specifies how to format the label displayed on the Progress Bar. This function allows customization of the label's content or appearance based on the current progress value.  Note: This property is only applicable to the ProgressWindow component. */
    get formatFunction() {
        return this.nativeElement ? this.nativeElement.formatFunction : undefined;
    }
    set formatFunction(value) {
        this.nativeElement ? this.nativeElement.formatFunction = value : undefined;
    }
    /** @description Specifies the exact placement or alignment of the footer section within the window element, such as positioning it at the bottom, fixed, absolute, or relative to other content. This property controls where the footer appears in relation to the window’s layout. */
    get footerPosition() {
        return this.nativeElement ? this.nativeElement.footerPosition : undefined;
    }
    set footerPosition(value) {
        this.nativeElement ? this.nativeElement.footerPosition = value : undefined;
    }
    /** @description Specifies the custom template used to render the footer section of the Dialog window. If footerTemplate is set to null (the default), the Dialog will not display a footer section. You can provide a template string or a function to customize the appearance and content of the Dialog’s footer. */
    get footerTemplate() {
        return this.nativeElement ? this.nativeElement.footerTemplate : undefined;
    }
    set footerTemplate(value) {
        this.nativeElement ? this.nativeElement.footerTemplate = value : undefined;
    }
    /** @description Specifies which buttons will be displayed in the header section, allowing you to control the visibility of header actions for users. */
    get headerButtons() {
        return this.nativeElement ? this.nativeElement.headerButtons : undefined;
    }
    set headerButtons(value) {
        this.nativeElement ? this.nativeElement.headerButtons = value : undefined;
    }
    /** @description Specifies the custom template to be used for rendering the header section of the dialog window. If headerTemplate is set to null (the default value), the dialog will display its standard header layout. By providing a template, you can fully customize the appearance and content of the dialog's header area. */
    get headerTemplate() {
        return this.nativeElement ? this.nativeElement.headerTemplate : undefined;
    }
    set headerTemplate(value) {
        this.nativeElement ? this.nativeElement.headerTemplate = value : undefined;
    }
    /** @description Specifies the exact placement of the header section within the window element, such as top, bottom, left, or right. This setting controls where the header appears relative to the content of the window. */
    get headerPosition() {
        return this.nativeElement ? this.nativeElement.headerPosition : undefined;
    }
    set headerPosition(value) {
        this.nativeElement ? this.nativeElement.headerPosition = value : undefined;
    }
    /** @description Displays supplementary helper text beneath the text box, providing users with additional guidance or context. This hint appears only when the text box is focused (i.e., the user is actively typing or has selected the field).  Note: This property is specifically applicable to the Prompt Window component. */
    get hint() {
        return this.nativeElement ? this.nativeElement.hint : undefined;
    }
    set hint(value) {
        this.nativeElement ? this.nativeElement.hint = value : undefined;
    }
    /** @description Sets the Progress bar value to the indeterminate state ('null'), activating its loading animation to indicate ongoing progress without a defined endpoint.  Note: This property is only applicable when used within a ProgressWindow component. */
    get indeterminate() {
        return this.nativeElement ? this.nativeElement.indeterminate : undefined;
    }
    set indeterminate(value) {
        this.nativeElement ? this.nativeElement.indeterminate = value : undefined;
    }
    /** @description Specifies the direction in which the Progress Bar fills (e.g., left-to-right, right-to-left, top-to-bottom, or bottom-to-top).  Note: This property is only applicable when used within a ProgressWindow component. */
    get inverted() {
        return this.nativeElement ? this.nativeElement.inverted : undefined;
    }
    set inverted(value) {
        this.nativeElement ? this.nativeElement.inverted = value : undefined;
    }
    /** @description Specifies the text displayed as the window title in the header section, typically shown at the top of the application window or dialog box. */
    get label() {
        return this.nativeElement ? this.nativeElement.label : undefined;
    }
    set label(value) {
        this.nativeElement ? this.nativeElement.label = value : undefined;
    }
    /** @description When enabled, the resizing operation updates the element’s size in real time as the user drags its edges, providing immediate visual feedback. By default, this feature is disabled; instead, a highlighter appears around the edges of the window during resizing to indicate the prospective new size, while the element itself resizes only once the operation is complete. */
    get liveResize() {
        return this.nativeElement ? this.nativeElement.liveResize : undefined;
    }
    set liveResize(value) {
        this.nativeElement ? this.nativeElement.liveResize = value : undefined;
    }
    /** @description Note: This property is relevant only for TabsWindow elements that are utilized within a DockingLayout custom element.This property is exclusively used by jqxDockingLayout to specify ownership of a TabsWindow. It determines which jqxDockingLayout instance the window is associated with. If a TabsWindow is removed from its parent DockingLayout element, this property continues to reference the original docking layout to which it belonged.The property accepts either:  A string representing the id of a jqxDockingLayout present on the page.  An instance of a jqxDockingLayout object.This allows for flexible identification of the owning layout, either by ID or by direct reference to the layout instance. */
    get layout() {
        return this.nativeElement ? this.nativeElement.layout : undefined;
    }
    set layout(value) {
        this.nativeElement ? this.nativeElement.layout = value : undefined;
    }
    /** @description Gets or sets the unlockKey, a unique code required to activate or unlock access to the product’s full features or licensed functionality. */
    get unlockKey() {
        return this.nativeElement ? this.nativeElement.unlockKey : undefined;
    }
    set unlockKey(value) {
        this.nativeElement ? this.nativeElement.unlockKey = value : undefined;
    }
    /** @description Specifies the language to be used for displaying messages. This property can be set or retrieved, and works in conjunction with the messages property to determine which set of localized messages is shown to the user. Changing the language updates the displayed messages accordingly. */
    get locale() {
        return this.nativeElement ? this.nativeElement.locale : undefined;
    }
    set locale(value) {
        this.nativeElement ? this.nativeElement.locale = value : undefined;
    }
    /** @description Note: This property is only applicable to a TabsWindow when it is docked within a DockingLayout custom element. When enabled, it controls whether the TabsWindow can be resized by the user. If set to true, users will be able to adjust the size of the TabsWindow within the DockingLayout; if set to false, resizing will be disabled and the TabsWindow will have a fixed size. */
    get locked() {
        return this.nativeElement ? this.nativeElement.locked : undefined;
    }
    set locked(value) {
        this.nativeElement ? this.nativeElement.locked = value : undefined;
    }
    /** @description Callback function used within the localization module, typically invoked when a localization event occurs (e.g., language change, resource load). This callback handles tasks such as updating UI elements or retrieving localized content based on the current language settings. */
    get localizeFormatFunction() {
        return this.nativeElement ? this.nativeElement.localizeFormatFunction : undefined;
    }
    set localizeFormatFunction(value) {
        this.nativeElement ? this.nativeElement.localizeFormatFunction = value : undefined;
    }
    /** @description Indicates whether the window is currently maximized. When set to true, the window expands to fill the entire available viewport, covering all other interface elements and leaving no visible borders or title bars. If false, the window retains its previous size and position. This property can be used to programmatically check or control the window’s maximized state within the application. */
    get maximized() {
        return this.nativeElement ? this.nativeElement.maximized : undefined;
    }
    set maximized(value) {
        this.nativeElement ? this.nativeElement.maximized = value : undefined;
    }
    /** @description Defines or retrieves an object containing localized strings used throughout the widget’s user interface. This property allows developers to customize the widget’s displayed text for different languages and regions. It is typically used together with the locale property to ensure that the widget adapts its content based on the selected language or regional settings. */
    get messages() {
        return this.nativeElement ? this.nativeElement.messages : undefined;
    }
    set messages(value) {
        this.nativeElement ? this.nativeElement.messages = value : undefined;
    }
    /** @description Specifies whether the window should function as a modal dialog. When set to true, the window captures user focus and prevents interaction with any other elements on the page until it is closed. This ensures that the user must address or dismiss the modal window before returning to the rest of the content. */
    get modal() {
        return this.nativeElement ? this.nativeElement.modal : undefined;
    }
    set modal(value) {
        this.nativeElement ? this.nativeElement.modal = value : undefined;
    }
    /** @description For use with TabsWindow when docked within a DockingLayout custom element:  Specifies the maximum size that the TabsWindow component can occupy when it is docked.  For the ProgressWindow component:  Defines the maximum value for the progress bar, allowing users to set the upper limit of the ProgressBar's range. */
    get max() {
        return this.nativeElement ? this.nativeElement.max : undefined;
    }
    set max(value) {
        this.nativeElement ? this.nativeElement.max = value : undefined;
    }
    /** @description Applicable to TabsWindow when docked inside a DockingLayout custom element. Specifies the minimum allowed size for the item within the layout, ensuring it does not shrink below this value during resizing operations.Also applies to ProgressWindow, where it lets the user set the minimum value for the ProgressBar, defining the lowest possible progress state that can be represented. */
    get min() {
        return this.nativeElement ? this.nativeElement.min : undefined;
    }
    set min(value) {
        this.nativeElement ? this.nativeElement.min = value : undefined;
    }
    /** @description Indicates whether the window is currently minimized. When set to true, the window is reduced to an icon or compact form and positioned (docked) in the bottom left corner of the viewport. If false, the window remains in its normal, active state. */
    get minimized() {
        return this.nativeElement ? this.nativeElement.minimized : undefined;
    }
    set minimized(value) {
        this.nativeElement ? this.nativeElement.minimized = value : undefined;
    }
    /** @description Specifies or retrieves the maximum number of characters a user is allowed to enter into the input field. This property applies to both Prompt and MultilinePrompt windows. If set, the input will be limited to the defined character count, preventing users from entering more characters than specified. */
    get maxLength() {
        return this.nativeElement ? this.nativeElement.maxLength : undefined;
    }
    set maxLength(value) {
        this.nativeElement ? this.nativeElement.maxLength = value : undefined;
    }
    /** @description Defines the minimum number of characters a user must enter before the autocomplete feature is activated. This property can be both set (to specify the desired threshold) and retrieved (to check the current threshold).  Note: This setting is only applicable to Prompt and MultilinePrompt windows. */
    get minLength() {
        return this.nativeElement ? this.nativeElement.minLength : undefined;
    }
    set minLength(value) {
        this.nativeElement ? this.nativeElement.minLength = value : undefined;
    }
    /** @description Indicates whether the window is currently visible to the user. Returns true if the window is displayed on the screen and can be interacted with, and false if it is hidden or minimized. */
    get opened() {
        return this.nativeElement ? this.nativeElement.opened : undefined;
    }
    set opened(value) {
        this.nativeElement ? this.nativeElement.opened = value : undefined;
    }
    /** @description Indicates whether the window is pinned. A pinned window cannot be moved (dragged) by the user, but it can still be resized. When set to true, this property disables window dragging while allowing resizing operations. */
    get pinned() {
        return this.nativeElement ? this.nativeElement.pinned : undefined;
    }
    set pinned(value) {
        this.nativeElement ? this.nativeElement.pinned = value : undefined;
    }
    /** @description Specifies the placeholder text that appears inside the input field before the user enters a value.  Note: This option is only applicable to the Prompt Window component. */
    get placeholder() {
        return this.nativeElement ? this.nativeElement.placeholder : undefined;
    }
    set placeholder(value) {
        this.nativeElement ? this.nativeElement.placeholder = value : undefined;
    }
    /** @description Specifies the text label displayed above or alongside the input field within the PromptWindow component. This label helps users understand what information is expected in the input field. */
    get promptLabel() {
        return this.nativeElement ? this.nativeElement.promptLabel : undefined;
    }
    set promptLabel(value) {
        this.nativeElement ? this.nativeElement.promptLabel = value : undefined;
    }
    /** @description If the element has the "readonly" attribute, users cannot modify its value; the field will display data in a non-editable state, though users can still select and copy its contents. This differs from a "disabled" element, as a "readonly" field remains focusable and included in form submissions. */
    get readonly() {
        return this.nativeElement ? this.nativeElement.readonly : undefined;
    }
    set readonly(value) {
        this.nativeElement ? this.nativeElement.readonly = value : undefined;
    }
    /** @description When this option is enabled, a resize handle appears in the bottom-right corner of the window. Users can initiate the resizing operation exclusively by dragging this indicator; resizing from any other window edge or corner is disabled. */
    get resizeIndicator() {
        return this.nativeElement ? this.nativeElement.resizeIndicator : undefined;
    }
    set resizeIndicator(value) {
        this.nativeElement ? this.nativeElement.resizeIndicator = value : undefined;
    }
    /** @description Specifies how the window can be resized by the user.Available resizing modes:  none – Disables all window resizing; the window size is fixed.  vertical – Allows the window to be resized only vertically (top and bottom edges).  horizontal – Allows the window to be resized only horizontally (left and right edges).  both – Enables both horizontal and vertical resizing; the window can be resized in any direction.  top – The window can only be resized by dragging the top edge.  bottom – The window can only be resized by dragging the bottom edge.  left – The window can only be resized by dragging the left edge.  right – The window can only be resized by dragging the right edge.Choose the desired mode to control which edges of the window users can drag to resize, or to prevent resizing entirely. */
    get resizeMode() {
        return this.nativeElement ? this.nativeElement.resizeMode : undefined;
    }
    set resizeMode(value) {
        this.nativeElement ? this.nativeElement.resizeMode = value : undefined;
    }
    /** @description Gets or sets a value that determines whether the element’s alignment is configured to support right-to-left (RTL) languages and text direction, such as Arabic or Hebrew. Use this property to ensure proper display and alignment for locales that require RTL font and layout support. */
    get rightToLeft() {
        return this.nativeElement ? this.nativeElement.rightToLeft : undefined;
    }
    set rightToLeft(value) {
        this.nativeElement ? this.nativeElement.rightToLeft = value : undefined;
    }
    /** @description Indicates that the input field is required and must be filled out by the user before the form can be submitted. If left empty, the form submission will be blocked, prompting the user to complete this field.  'Note:' This setting is applicable to the Prompt Window. */
    get required() {
        return this.nativeElement ? this.nativeElement.required : undefined;
    }
    set required(value) {
        this.nativeElement ? this.nativeElement.required = value : undefined;
    }
    /** @description Defines the error message displayed when the required attribute is enabled and the user submits the input field without providing a value. This setting only applies to the Prompt Window interface. */
    get requiredMessage() {
        return this.nativeElement ? this.nativeElement.requiredMessage : undefined;
    }
    set requiredMessage(value) {
        this.nativeElement ? this.nativeElement.requiredMessage = value : undefined;
    }
    /** @description Specifies whether the input field's content should be automatically highlighted (selected) when the field gains focus.  Note: This setting applies specifically to the Prompt Window component. */
    get selectAllOnFocus() {
        return this.nativeElement ? this.nativeElement.selectAllOnFocus : undefined;
    }
    set selectAllOnFocus(value) {
        this.nativeElement ? this.nativeElement.selectAllOnFocus = value : undefined;
    }
    /** @description Specifies or retrieves the currently selected tab within the component. This property applies exclusively to the TabsWindow component. */
    get selectedIndex() {
        return this.nativeElement ? this.nativeElement.selectedIndex : undefined;
    }
    set selectedIndex(value) {
        this.nativeElement ? this.nativeElement.selectedIndex = value : undefined;
    }
    /** @description Specifies how the user is allowed to navigate between different tabs within the interface. This property is relevant only when using the TabsWindow component. */
    get selectionMode() {
        return this.nativeElement ? this.nativeElement.selectionMode : undefined;
    }
    set selectionMode(value) {
        this.nativeElement ? this.nativeElement.selectionMode = value : undefined;
    }
    /** @description Specifies the zero-based index position of the last character included in the current text selection.  Note: This property is relevant only for use within MultilinePromptWindow components. */
    get selectionEnd() {
        return this.nativeElement ? this.nativeElement.selectionEnd : undefined;
    }
    set selectionEnd(value) {
        this.nativeElement ? this.nativeElement.selectionEnd = value : undefined;
    }
    /** @description Specifies the zero-based index of the first character in the currently selected text within the prompt window. This property is only applicable when using the MultilinePromptWindow component. */
    get selectionStart() {
        return this.nativeElement ? this.nativeElement.selectionStart : undefined;
    }
    set selectionStart(value) {
        this.nativeElement ? this.nativeElement.selectionStart = value : undefined;
    }
    /** @description Controls the visibility of the label displayed on the Progress Bar.  Note: This setting is only applicable when used within the Progress Window component. */
    get showProgressValue() {
        return this.nativeElement ? this.nativeElement.showProgressValue : undefined;
    }
    set showProgressValue(value) {
        this.nativeElement ? this.nativeElement.showProgressValue = value : undefined;
    }
    /** @description A getter that retrieves all sibling LayoutPanel instances—those sharing the same immediate parent—when a LayoutPanel item is docked within a DockingLayout. The returned siblings are also DockingLayout items (specifically, other LayoutPanels).  This property is only available for TabsWindow components that are docked inside a DockingLayout. */
    get siblings() {
        return this.nativeElement ? this.nativeElement.siblings : undefined;
    }
    set siblings(value) {
        this.nativeElement ? this.nativeElement.siblings = value : undefined;
    }
    /** @description Relevant when a TabsWindow component is nested within a DockingLayout custom element. This property specifies the size (width or height, depending on layout orientation) allocated to the TabsWindow within the docking layout, allowing developers to control how much space the window occupies relative to other docked components. */
    get size() {
        return this.nativeElement ? this.nativeElement.size : undefined;
    }
    set size(value) {
        this.nativeElement ? this.nativeElement.size = value : undefined;
    }
    /** @description Indicates whether spelling and grammar checking should be enabled for the element. This property determines if the content entered within the element will be reviewed for spelling and grammatical errors. Note: This option is only relevant for the MultilinePromptWindow component. */
    get spellCheck() {
        return this.nativeElement ? this.nativeElement.spellCheck : undefined;
    }
    set spellCheck(value) {
        this.nativeElement ? this.nativeElement.spellCheck = value : undefined;
    }
    /** @description Determines whether close buttons are shown on each tab within the Tab Strip of the TabsWindow. You can use this property to enable or disable the visibility of close buttons on tabs, allowing users to close individual tabs directly from the Tab Strip.  Note: This property is only applicable to the TabsWindow component. */
    get tabCloseButtons() {
        return this.nativeElement ? this.nativeElement.tabCloseButtons : undefined;
    }
    set tabCloseButtons(value) {
        this.nativeElement ? this.nativeElement.tabCloseButtons = value : undefined;
    }
    /** @description Specifies when the close button is visible—either only when a tab is selected or always visible on all tabs.  Note: This property applies exclusively to the TabsWindow component. */
    get tabCloseButtonMode() {
        return this.nativeElement ? this.nativeElement.tabCloseButtonMode : undefined;
    }
    set tabCloseButtonMode(value) {
        this.nativeElement ? this.nativeElement.tabCloseButtonMode = value : undefined;
    }
    /** @description Specifies how the scroll buttons for tabs are displayed or behave. This option is only relevant when the tabLayout property is set to 'scroll', allowing tabs to be scrolled horizontally. Note: This property applies exclusively to the TabsWindow component. */
    get tabOverflow() {
        return this.nativeElement ? this.nativeElement.tabOverflow : undefined;
    }
    set tabOverflow(value) {
        this.nativeElement ? this.nativeElement.tabOverflow = value : undefined;
    }
    /** @description Determines the position of the Tab Strip within the TabsWindow.  Note: This property applies exclusively to the TabsWindow component. */
    get tabPosition() {
        return this.nativeElement ? this.nativeElement.tabPosition : undefined;
    }
    set tabPosition(value) {
        this.nativeElement ? this.nativeElement.tabPosition = value : undefined;
    }
    /** @description Defines or retrieves the position of the scroll buttons located within the tab header of a TabsWindow component. This setting is exclusively applicable to TabsWindow instances and allows you to control where the scroll buttons appear (for example, at the start, end, or both ends of the tab header). */
    get tabScrollButtonsPosition() {
        return this.nativeElement ? this.nativeElement.tabScrollButtonsPosition : undefined;
    }
    set tabScrollButtonsPosition(value) {
        this.nativeElement ? this.nativeElement.tabScrollButtonsPosition = value : undefined;
    }
    /** @description Defines or retrieves the orientation of the text displayed in the tab labels within the TabsWindow component. This property determines whether the tab text is laid out horizontally or vertically. Note: This property is exclusively applicable to the TabsWindow component and has no effect on other components. */
    get tabTextOrientation() {
        return this.nativeElement ? this.nativeElement.tabTextOrientation : undefined;
    }
    set tabTextOrientation(value) {
        this.nativeElement ? this.nativeElement.tabTextOrientation = value : undefined;
    }
    /** @description Specifies the visual theme to be applied. The theme controls the appearance, including colors, fonts, and styling, of the element to ensure a consistent look and feel across the user interface. */
    get theme() {
        return this.nativeElement ? this.nativeElement.theme : undefined;
    }
    set theme(value) {
        this.nativeElement ? this.nativeElement.theme = value : undefined;
    }
    /** @description If this property is set to true, the element will be excluded from keyboard navigation and cannot receive focus either programmatically or via user interaction. This ensures that users will be unable to focus on the element using methods such as the Tab key or calling focus() in JavaScript. */
    get unfocusable() {
        return this.nativeElement ? this.nativeElement.unfocusable : undefined;
    }
    set unfocusable(value) {
        this.nativeElement ? this.nativeElement.unfocusable = value : undefined;
    }
    /** @description Specifies the current value displayed within the TextBox or ProgressBar component inside a Dialog, Prompt, or Progress Window. This value can represent user input (for TextBox) or progress status (for ProgressBar) and is used to dynamically update the UI element's content or state. */
    get value() {
        return this.nativeElement ? this.nativeElement.value : undefined;
    }
    set value(value) {
        this.nativeElement ? this.nativeElement.value = value : undefined;
    }
    /** @description Specifies the actual parent element of the target element. The window's sizing and movement are restricted to the boundaries of this parent element, meaning the window can only be resized or repositioned within the visible area of the designated parent. */
    get windowParent() {
        return this.nativeElement ? this.nativeElement.windowParent : undefined;
    }
    set windowParent(value) {
        this.nativeElement ? this.nativeElement.windowParent = value : undefined;
    }
    /** @description Specifies the text-wrapping behavior for the input field.  Note: This property is only relevant when used with the MultilinePromptWindow component. */
    get wrap() {
        return this.nativeElement ? this.nativeElement.wrap : undefined;
    }
    set wrap(value) {
        this.nativeElement ? this.nativeElement.wrap = value : undefined;
    }
    /** @description Appends a new tab item to the end of the existing list of tab items within the specified parent element. This operation updates the parent element's tab item collection, ensuring the new tab appears as the last item in the tab navigation.
    * @param {Node} node. A TabItem element that should be added to the rest of the items as the last item.
    * @returns {Node}
  */
    async appendChild(node) {
        const getResultOnRender = () => {
            return new Promise(resolve => {
                this.nativeElement.whenRendered(() => {
                    const result = this.nativeElement.appendChild(node);
                    resolve(result);
                });
            });
        };
        const result = await getResultOnRender();
        return result;
    }
    appendChildSync(node) {
        if (this.nativeElement.isRendered) {
            return this.nativeElement.appendChild(node);
        }
        return null;
    }
    /** @description Sets the window to the highest z-order level, bringing it to the foreground and ensuring it is visible and accessible for user interaction above all other open windows.
    */
    bringToFront() {
        if (this.nativeElement.isRendered) {
            this.nativeElement.bringToFront();
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.bringToFront();
            });
        }
    }
    /** @description Removes all existing content from the window, effectively resetting the window’s display area to an empty state. This operation clears any text, images, or elements currently visible within the window.
    */
    clear() {
        if (this.nativeElement.isRendered) {
            this.nativeElement.clear();
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.clear();
            });
        }
    }
    /** @description Closes the currently active window in the application, terminating its user interface and releasing any associated resources. If there are unsaved changes or prompts, the user may be asked to confirm before the window is closed.
    */
    close() {
        if (this.nativeElement.isRendered) {
            this.nativeElement.close();
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.close();
            });
        }
    }
    /** @description Minimizes the window, reducing it to a smaller icon or hidden state, without closing the application.
    * @returns {HTMLElement}
  */
    async collapse() {
        const getResultOnRender = () => {
            return new Promise(resolve => {
                this.nativeElement.whenRendered(() => {
                    const result = this.nativeElement.collapse();
                    resolve(result);
                });
            });
        };
        const result = await getResultOnRender();
        return result;
    }
    collapseSync() {
        if (this.nativeElement.isRendered) {
            return this.nativeElement.collapse();
        }
        return null;
    }
    /** @description Ensures the specified tab item is brought into view by automatically scrolling the tab bar as needed. This functionality is exclusive to the TabsWindow component.
    * @param {number} index. The index of the tab to scroll to.
    */
    ensureVisible(index) {
        if (this.nativeElement.isRendered) {
            this.nativeElement.ensureVisible(index);
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.ensureVisible(index);
            });
        }
    }
    /** @description Restores the window to its full size and visibility after it has been collapsed or minimized, allowing users to view and interact with its contents again.
    * @returns {any[]}
  */
    async expand() {
        const getResultOnRender = () => {
            return new Promise(resolve => {
                this.nativeElement.whenRendered(() => {
                    const result = this.nativeElement.expand();
                    resolve(result);
                });
            });
        };
        const result = await getResultOnRender();
        return result;
    }
    expandSync() {
        if (this.nativeElement.isRendered) {
            return this.nativeElement.expand();
        }
        return null;
    }
    /** @description Inserts a new tab along with its corresponding content section into the user interface. This function is specifically designed for use within the TabsWindow component and will not operate outside of this context.
    * @param {number} index. The index to insert a new tab at.
    * @param {any} details. An Object with the fields "label", "labelSize", "content" and "group".
    */
    insert(index, details) {
        if (this.nativeElement.isRendered) {
            this.nativeElement.insert(index, details);
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.insert(index, details);
            });
        }
    }
    /** @description Inserts the specified "smart-tab-item" node directly before the reference "smart-tab-item" node within the tab collection. This operation is only applicable when manipulating tab items inside a TabsWindow component.
    * @param {Node} newNode. The "smart-tab-item" node to insert.
    * @param {Node | null} referenceNode?. The "smart-tab-item" node before which newNode is inserted.
    * @returns {Node}
  */
    async insertBefore(newNode, referenceNode) {
        const getResultOnRender = () => {
            return new Promise(resolve => {
                this.nativeElement.whenRendered(() => {
                    const result = this.nativeElement.insertBefore(newNode, referenceNode);
                    resolve(result);
                });
            });
        };
        const result = await getResultOnRender();
        return result;
    }
    insertBeforeSync(newNode, referenceNode) {
        if (this.nativeElement.isRendered) {
            return this.nativeElement.insertBefore(newNode, referenceNode);
        }
        return null;
    }
    /** @description Revised Description:"Sets the window's position on the screen by moving it to specified X and Y coordinates, effectively relocating the window to a new location."
    * @param {string | number} left. Left position. For example: '100px'.
    * @param {string | number} top. Top position. For example: '100px'.
    */
    move(left, top) {
        if (this.nativeElement.isRendered) {
            this.nativeElement.move(left, top);
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.move(left, top);
            });
        }
    }
    /** @description Expands the window to occupy the entire available viewing area, ensuring it fills all usable screen space without overlapping system taskbars or menus.
    */
    maximize() {
        if (this.nativeElement.isRendered) {
            this.nativeElement.maximize();
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.maximize();
            });
        }
    }
    /** @description Reduces the window to the taskbar or dock, temporarily hiding it from view without closing the application.
    */
    minimize() {
        if (this.nativeElement.isRendered) {
            this.nativeElement.minimize();
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.minimize();
            });
        }
    }
    /** @description Opens a new browser window or tab with the specified URL or content, allowing additional web pages or resources to be displayed alongside the current page.
    */
    open() {
        if (this.nativeElement.isRendered) {
            this.nativeElement.open();
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.open();
            });
        }
    }
    /** @description Prevents the window from being moved by locking its position. Disables the ability to drag or reposition the window, ensuring it remains fixed in place.
    */
    pin() {
        if (this.nativeElement.isRendered) {
            this.nativeElement.pin();
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.pin();
            });
        }
    }
    /** @description Removes a tab along with its corresponding content section from the interface. This function is designed to work exclusively within the TabsWindow component.
    * @param {number} index. The index of the tab to remove.
    */
    removeAt(index) {
        if (this.nativeElement.isRendered) {
            this.nativeElement.removeAt(index);
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.removeAt(index);
            });
        }
    }
    /** @description Removes a child node with the "smart-tab-item" tag from the parent container.  Note: This operation is only supported within the TabsWindow component; attempting to use it elsewhere will have no effect.
    * @param {Node} node. The "smart-tab-item" node to remove.
    * @returns {Node}
  */
    async removeChild(node) {
        const getResultOnRender = () => {
            return new Promise(resolve => {
                this.nativeElement.whenRendered(() => {
                    const result = this.nativeElement.removeChild(node);
                    resolve(result);
                });
            });
        };
        const result = await getResultOnRender();
        return result;
    }
    removeChildSync(node) {
        if (this.nativeElement.isRendered) {
            return this.nativeElement.removeChild(node);
        }
        return null;
    }
    /** @description Restores the window to its previous dimensions and position before it was maximized or minimized, returning it to the exact size and location it had prior to those actions.
    */
    restore() {
        if (this.nativeElement.isRendered) {
            this.nativeElement.restore();
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.restore();
            });
        }
    }
    /** @description Selects the specified tab within the interface. This action applies exclusively to elements of type TabsWindow.
    * @param {number} index. The index of the tab to select.
    */
    select(index) {
        if (this.nativeElement.isRendered) {
            this.nativeElement.select(index);
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.select(index);
            });
        }
    }
    /** @description Removes the pinned (fixed) state from the window, allowing the user to freely move or drag the window to a different position on the screen.
    */
    unpin() {
        if (this.nativeElement.isRendered) {
            this.nativeElement.unpin();
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.unpin();
            });
        }
    }
    /** @description Updates the text displayed in the header label to reflect new information or changes, ensuring that the header accurately represents the current content or context of the section.
    * @param {string} label. The new label of the Header.
    */
    updateLabel(label) {
        if (this.nativeElement.isRendered) {
            this.nativeElement.updateLabel(label);
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.updateLabel(label);
            });
        }
    }
    /** @description Replaces the existing content with new or modified information, ensuring that the displayed data reflects the latest updates or changes.
    * @param {string | HTMLElement} content. The new content of the window.
    */
    updateContent(content) {
        if (this.nativeElement.isRendered) {
            this.nativeElement.updateContent(content);
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.updateContent(content);
            });
        }
    }
    /** @description Updates an individual tab within a TabsWindow component and modifies its corresponding content section. This operation exclusively applies to elements of the TabsWindow type. Use this function to change tab labels, update active states, or refresh the content associated with a specific tab within the TabsWindow interface.
    * @param {number} index. The index of the tab to update.
    * @param {string} label. The new label of the tab. The value can be the id of an HTMLTemplateElement
    * @param {string | HTMLElement} content. The new content of the tab.
    */
    update(index, label, content) {
        if (this.nativeElement.isRendered) {
            this.nativeElement.update(index, label, content);
        }
        else {
            this.nativeElement.whenRendered(() => {
                this.nativeElement.update(index, label, content);
            });
        }
    }
    get isRendered() {
        return this.nativeElement ? this.nativeElement.isRendered : false;
    }
    ngOnInit() {
    }
    ngAfterViewInit() {
        const that = this;
        that.onCreate.emit(that.nativeElement);
        if (Smart)
            Smart.Render();
        this.nativeElement.classList.add('smart-angular');
        if (this.nativeElement.whenRendered)
            this.nativeElement.whenRendered(() => { that.onReady.emit(that.nativeElement); });
        this.listen();
    }
    ngOnDestroy() {
        this.unlisten();
    }
    ngOnChanges(changes) {
        if (this.nativeElement && this.nativeElement.isRendered) {
            for (const propName in changes) {
                if (changes.hasOwnProperty(propName)) {
                    this.nativeElement[propName] = changes[propName].currentValue;
                }
            }
        }
    }
    /** @description Add event listeners. */
    listen() {
        const that = this;
        that.eventHandlers['openingHandler'] = (event) => { that.onOpening.emit(event); };
        that.nativeElement.addEventListener('opening', that.eventHandlers['openingHandler']);
        that.eventHandlers['openHandler'] = (event) => { that.onOpen.emit(event); };
        that.nativeElement.addEventListener('open', that.eventHandlers['openHandler']);
        that.eventHandlers['closingHandler'] = (event) => { that.onClosing.emit(event); };
        that.nativeElement.addEventListener('closing', that.eventHandlers['closingHandler']);
        that.eventHandlers['closeHandler'] = (event) => { that.onClose.emit(event); };
        that.nativeElement.addEventListener('close', that.eventHandlers['closeHandler']);
        that.eventHandlers['collapseHandler'] = (event) => { that.onCollapse.emit(event); };
        that.nativeElement.addEventListener('collapse', that.eventHandlers['collapseHandler']);
        that.eventHandlers['dragEndHandler'] = (event) => { that.onDragEnd.emit(event); };
        that.nativeElement.addEventListener('dragEnd', that.eventHandlers['dragEndHandler']);
        that.eventHandlers['dragStartHandler'] = (event) => { that.onDragStart.emit(event); };
        that.nativeElement.addEventListener('dragStart', that.eventHandlers['dragStartHandler']);
        that.eventHandlers['expandHandler'] = (event) => { that.onExpand.emit(event); };
        that.nativeElement.addEventListener('expand', that.eventHandlers['expandHandler']);
        that.eventHandlers['maximizeHandler'] = (event) => { that.onMaximize.emit(event); };
        that.nativeElement.addEventListener('maximize', that.eventHandlers['maximizeHandler']);
        that.eventHandlers['minimizeHandler'] = (event) => { that.onMinimize.emit(event); };
        that.nativeElement.addEventListener('minimize', that.eventHandlers['minimizeHandler']);
        that.eventHandlers['resizeEndHandler'] = (event) => { that.onResizeEnd.emit(event); };
        that.nativeElement.addEventListener('resizeEnd', that.eventHandlers['resizeEndHandler']);
        that.eventHandlers['resizeStartHandler'] = (event) => { that.onResizeStart.emit(event); };
        that.nativeElement.addEventListener('resizeStart', that.eventHandlers['resizeStartHandler']);
        that.eventHandlers['restoreHandler'] = (event) => { that.onRestore.emit(event); };
        that.nativeElement.addEventListener('restore', that.eventHandlers['restoreHandler']);
    }
    /** @description Remove event listeners. */
    unlisten() {
        const that = this;
        if (that.eventHandlers['openingHandler']) {
            that.nativeElement.removeEventListener('opening', that.eventHandlers['openingHandler']);
        }
        if (that.eventHandlers['openHandler']) {
            that.nativeElement.removeEventListener('open', that.eventHandlers['openHandler']);
        }
        if (that.eventHandlers['closingHandler']) {
            that.nativeElement.removeEventListener('closing', that.eventHandlers['closingHandler']);
        }
        if (that.eventHandlers['closeHandler']) {
            that.nativeElement.removeEventListener('close', that.eventHandlers['closeHandler']);
        }
        if (that.eventHandlers['collapseHandler']) {
            that.nativeElement.removeEventListener('collapse', that.eventHandlers['collapseHandler']);
        }
        if (that.eventHandlers['dragEndHandler']) {
            that.nativeElement.removeEventListener('dragEnd', that.eventHandlers['dragEndHandler']);
        }
        if (that.eventHandlers['dragStartHandler']) {
            that.nativeElement.removeEventListener('dragStart', that.eventHandlers['dragStartHandler']);
        }
        if (that.eventHandlers['expandHandler']) {
            that.nativeElement.removeEventListener('expand', that.eventHandlers['expandHandler']);
        }
        if (that.eventHandlers['maximizeHandler']) {
            that.nativeElement.removeEventListener('maximize', that.eventHandlers['maximizeHandler']);
        }
        if (that.eventHandlers['minimizeHandler']) {
            that.nativeElement.removeEventListener('minimize', that.eventHandlers['minimizeHandler']);
        }
        if (that.eventHandlers['resizeEndHandler']) {
            that.nativeElement.removeEventListener('resizeEnd', that.eventHandlers['resizeEndHandler']);
        }
        if (that.eventHandlers['resizeStartHandler']) {
            that.nativeElement.removeEventListener('resizeStart', that.eventHandlers['resizeStartHandler']);
        }
        if (that.eventHandlers['restoreHandler']) {
            that.nativeElement.removeEventListener('restore', that.eventHandlers['restoreHandler']);
        }
    }
}
WindowComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: WindowComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
WindowComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.6", type: WindowComponent, selector: "smart-window, [smart-window], smart-tabs-window, smart-prompt-window, smart-multiline-prompt-window, smart-dialog-window,  smart-alert-window, smart-progress-window, smart-wait-window", inputs: { addNewTab: "addNewTab", animation: "animation", autoCapitalize: "autoCapitalize", autoExpand: "autoExpand", cancelLabel: "cancelLabel", completeLabel: "completeLabel", confirmLabel: "confirmLabel", collapsed: "collapsed", closeOnMaskClick: "closeOnMaskClick", dataSource: "dataSource", disabled: "disabled", disableSnap: "disableSnap", disableEscape: "disableEscape", disableKeyboard: "disableKeyboard", displayMode: "displayMode", dropPosition: "dropPosition", formatFunction: "formatFunction", footerPosition: "footerPosition", footerTemplate: "footerTemplate", headerButtons: "headerButtons", headerTemplate: "headerTemplate", headerPosition: "headerPosition", hint: "hint", indeterminate: "indeterminate", inverted: "inverted", label: "label", liveResize: "liveResize", layout: "layout", unlockKey: "unlockKey", locale: "locale", locked: "locked", localizeFormatFunction: "localizeFormatFunction", maximized: "maximized", messages: "messages", modal: "modal", max: "max", min: "min", minimized: "minimized", maxLength: "maxLength", minLength: "minLength", opened: "opened", pinned: "pinned", placeholder: "placeholder", promptLabel: "promptLabel", readonly: "readonly", resizeIndicator: "resizeIndicator", resizeMode: "resizeMode", rightToLeft: "rightToLeft", required: "required", requiredMessage: "requiredMessage", selectAllOnFocus: "selectAllOnFocus", selectedIndex: "selectedIndex", selectionMode: "selectionMode", selectionEnd: "selectionEnd", selectionStart: "selectionStart", showProgressValue: "showProgressValue", siblings: "siblings", size: "size", spellCheck: "spellCheck", tabCloseButtons: "tabCloseButtons", tabCloseButtonMode: "tabCloseButtonMode", tabOverflow: "tabOverflow", tabPosition: "tabPosition", tabScrollButtonsPosition: "tabScrollButtonsPosition", tabTextOrientation: "tabTextOrientation", theme: "theme", unfocusable: "unfocusable", value: "value", windowParent: "windowParent", wrap: "wrap" }, outputs: { onOpening: "onOpening", onOpen: "onOpen", onClosing: "onClosing", onClose: "onClose", onCollapse: "onCollapse", onDragEnd: "onDragEnd", onDragStart: "onDragStart", onExpand: "onExpand", onMaximize: "onMaximize", onMinimize: "onMinimize", onResizeEnd: "onResizeEnd", onResizeStart: "onResizeStart", onRestore: "onRestore" }, exportAs: ["smart-window"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: WindowComponent, decorators: [{
            type: Directive,
            args: [{
                    exportAs: 'smart-window', selector: 'smart-window, [smart-window], smart-tabs-window, smart-prompt-window, smart-multiline-prompt-window, smart-dialog-window,  smart-alert-window, smart-progress-window, smart-wait-window'
                }]
        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { addNewTab: [{
                type: Input
            }], animation: [{
                type: Input
            }], autoCapitalize: [{
                type: Input
            }], autoExpand: [{
                type: Input
            }], cancelLabel: [{
                type: Input
            }], completeLabel: [{
                type: Input
            }], confirmLabel: [{
                type: Input
            }], collapsed: [{
                type: Input
            }], closeOnMaskClick: [{
                type: Input
            }], dataSource: [{
                type: Input
            }], disabled: [{
                type: Input
            }], disableSnap: [{
                type: Input
            }], disableEscape: [{
                type: Input
            }], disableKeyboard: [{
                type: Input
            }], displayMode: [{
                type: Input
            }], dropPosition: [{
                type: Input
            }], formatFunction: [{
                type: Input
            }], footerPosition: [{
                type: Input
            }], footerTemplate: [{
                type: Input
            }], headerButtons: [{
                type: Input
            }], headerTemplate: [{
                type: Input
            }], headerPosition: [{
                type: Input
            }], hint: [{
                type: Input
            }], indeterminate: [{
                type: Input
            }], inverted: [{
                type: Input
            }], label: [{
                type: Input
            }], liveResize: [{
                type: Input
            }], layout: [{
                type: Input
            }], unlockKey: [{
                type: Input
            }], locale: [{
                type: Input
            }], locked: [{
                type: Input
            }], localizeFormatFunction: [{
                type: Input
            }], maximized: [{
                type: Input
            }], messages: [{
                type: Input
            }], modal: [{
                type: Input
            }], max: [{
                type: Input
            }], min: [{
                type: Input
            }], minimized: [{
                type: Input
            }], maxLength: [{
                type: Input
            }], minLength: [{
                type: Input
            }], opened: [{
                type: Input
            }], pinned: [{
                type: Input
            }], placeholder: [{
                type: Input
            }], promptLabel: [{
                type: Input
            }], readonly: [{
                type: Input
            }], resizeIndicator: [{
                type: Input
            }], resizeMode: [{
                type: Input
            }], rightToLeft: [{
                type: Input
            }], required: [{
                type: Input
            }], requiredMessage: [{
                type: Input
            }], selectAllOnFocus: [{
                type: Input
            }], selectedIndex: [{
                type: Input
            }], selectionMode: [{
                type: Input
            }], selectionEnd: [{
                type: Input
            }], selectionStart: [{
                type: Input
            }], showProgressValue: [{
                type: Input
            }], siblings: [{
                type: Input
            }], size: [{
                type: Input
            }], spellCheck: [{
                type: Input
            }], tabCloseButtons: [{
                type: Input
            }], tabCloseButtonMode: [{
                type: Input
            }], tabOverflow: [{
                type: Input
            }], tabPosition: [{
                type: Input
            }], tabScrollButtonsPosition: [{
                type: Input
            }], tabTextOrientation: [{
                type: Input
            }], theme: [{
                type: Input
            }], unfocusable: [{
                type: Input
            }], value: [{
                type: Input
            }], windowParent: [{
                type: Input
            }], wrap: [{
                type: Input
            }], onOpening: [{
                type: Output
            }], onOpen: [{
                type: Output
            }], onClosing: [{
                type: Output
            }], onClose: [{
                type: Output
            }], onCollapse: [{
                type: Output
            }], onDragEnd: [{
                type: Output
            }], onDragStart: [{
                type: Output
            }], onExpand: [{
                type: Output
            }], onMaximize: [{
                type: Output
            }], onMinimize: [{
                type: Output
            }], onResizeEnd: [{
                type: Output
            }], onResizeStart: [{
                type: Output
            }], onRestore: [{
                type: Output
            }] } });

class WindowModule {
}
WindowModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: WindowModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
WindowModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: WindowModule, declarations: [WindowComponent], exports: [WindowComponent] });
WindowModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: WindowModule });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: WindowModule, decorators: [{
            type: NgModule,
            args: [{
                    declarations: [WindowComponent],
                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
                    exports: [WindowComponent]
                }]
        }] });

/**
 * Generated bundle index. Do not edit.
 */

export { Smart, WindowComponent, WindowModule };
//# sourceMappingURL=smart-webcomponents-angular-window.mjs.map
