@smart-webcomponents-angular/window 11.0.1 → 13.0.1

package/esm2020/window/smart.window.mjs

@@ -0,0 +1,1051 @@
+import { Directive, Input, Output, EventEmitter } from '@angular/core';
+import { BaseElement, Smart } from './smart.element';
+import * as i0 from "@angular/core";
+export { Smart } from './smart.element';
+export class WindowComponent extends BaseElement {
+    constructor(ref) {
+        super(ref);
+        this.eventHandlers = [];
+        /** @description This event is triggered just before the window starts opening.
+        *  @param event. The custom event. 	*/
+        this.onOpening = new EventEmitter();
+        /** @description This event is triggered when the window is opened( visible ).
+        *  @param event. The custom event. 	*/
+        this.onOpen = new EventEmitter();
+        /** @description This event is triggered just before the window starts closing.
+        *  @param event. The custom event. 	*/
+        this.onClosing = new EventEmitter();
+        /** @description This event is triggered when the window is closed( hidden )
+        *  @param event. The custom event. 	*/
+        this.onClose = new EventEmitter();
+        /** @description This event is triggered when the window is collapsed.
+        *  @param event. The custom event. 	*/
+        this.onCollapse = new EventEmitter();
+        /** @description This event is triggered when window's dragging is ended.
+        *  @param event. The custom event. 	*/
+        this.onDragEnd = new EventEmitter();
+        /** @description This event is triggered when window's dragging is started.
+        *  @param event. The custom event. 	*/
+        this.onDragStart = new EventEmitter();
+        /** @description This event is triggered when the window is expanded.
+        *  @param event. The custom event. 	*/
+        this.onExpand = new EventEmitter();
+        /** @description This event is triggered when the window is maximized.
+        *  @param event. The custom event. 	*/
+        this.onMaximize = new EventEmitter();
+        /** @description This event is triggered when the window is minimized.
+        *  @param event. The custom event. 	*/
+        this.onMinimize = new EventEmitter();
+        /** @description This event is triggered when window's resizing is ended.
+        *  @param event. The custom event. 	*/
+        this.onResizeEnd = new EventEmitter();
+        /** @description This event is triggered when window's resizing is started.
+        *  @param event. The custom event. 	*/
+        this.onResizeStart = new EventEmitter();
+        /** @description This event is triggered when the window is restored to it's previous state before 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 if 'Add New' Tab inside the Tabs element is visible. Applicable only to TabsWindow */
+    get addNewTab() {
+        return this.nativeElement ? this.nativeElement.addNewTab : undefined;
+    }
+    set addNewTab(value) {
+        this.nativeElement ? this.nativeElement.addNewTab = value : undefined;
+    }
+    /** @description Sets or gets the animation mode. Animation is disabled when the property is set to 'none' */
+    get animation() {
+        return this.nativeElement ? this.nativeElement.animation : undefined;
+    }
+    set animation(value) {
+        this.nativeElement ? this.nativeElement.animation = value : undefined;
+    }
+    /** @description Determines whether and how the value should be automatically capitalized as it is entered/edited by the user. Applicable only to MultilinePromptWindow. */
+    get autoCapitalize() {
+        return this.nativeElement ? this.nativeElement.autoCapitalize : undefined;
+    }
+    set autoCapitalize(value) {
+        this.nativeElement ? this.nativeElement.autoCapitalize = value : undefined;
+    }
+    /** @description Determines whether element will auto expand when the input overflows vertically. Applicable only to MultilinePromptWindow. */
+    get autoExpand() {
+        return this.nativeElement ? this.nativeElement.autoExpand : undefined;
+    }
+    set autoExpand(value) {
+        this.nativeElement ? this.nativeElement.autoExpand = value : undefined;
+    }
+    /** @description Determines the label for the 'cancel' button inside the Prompt Window. */
+    get cancelLabel() {
+        return this.nativeElement ? this.nativeElement.cancelLabel : undefined;
+    }
+    set cancelLabel(value) {
+        this.nativeElement ? this.nativeElement.cancelLabel = value : undefined;
+    }
+    /** @description Determines the label for the 'Complete' button insinde the Progress Window. */
+    get completeLabel() {
+        return this.nativeElement ? this.nativeElement.completeLabel : undefined;
+    }
+    set completeLabel(value) {
+        this.nativeElement ? this.nativeElement.completeLabel = value : undefined;
+    }
+    /** @description Determines the label for the 'Confirm' button insinde the Prompt Window. */
+    get confirmLabel() {
+        return this.nativeElement ? this.nativeElement.confirmLabel : undefined;
+    }
+    set confirmLabel(value) {
+        this.nativeElement ? this.nativeElement.confirmLabel = value : undefined;
+    }
+    /** @description Determines if the window is collapsed or not. When collapsed the only the header of the window is 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, thid property determines if clicking on the mask closes the window or not. */
+    get closeOnMaskClick() {
+        return this.nativeElement ? this.nativeElement.closeOnMaskClick : undefined;
+    }
+    set closeOnMaskClick(value) {
+        this.nativeElement ? this.nativeElement.closeOnMaskClick = value : undefined;
+    }
+    /** @description Determines the data source that will be loaded to the TabsWindow. Applicable only to TabsWindow. */
+    get dataSource() {
+        return this.nativeElement ? this.nativeElement.dataSource : undefined;
+    }
+    set dataSource(value) {
+        this.nativeElement ? this.nativeElement.dataSource = value : undefined;
+    }
+    /** @description Enables or disables the window. */
+    get disabled() {
+        return this.nativeElement ? this.nativeElement.disabled : undefined;
+    }
+    set disabled(value) {
+        this.nativeElement ? this.nativeElement.disabled = value : undefined;
+    }
+    /** @description Enables or disables the window snapping feature. */
+    get disableSnap() {
+        return this.nativeElement ? this.nativeElement.disableSnap : undefined;
+    }
+    set disableSnap(value) {
+        this.nativeElement ? this.nativeElement.disableSnap = value : undefined;
+    }
+    /** @description Determines how the characters are displayed inside the input. Applicable to Prompt Window. */
+    get displayMode() {
+        return this.nativeElement ? this.nativeElement.displayMode : undefined;
+    }
+    set displayMode(value) {
+        this.nativeElement ? this.nativeElement.displayMode = value : undefined;
+    }
+    /** @description Applicable to TabsWindow when docked inside a DockingLayout Custom Element.  Determines where the window(it's tab items as well) can be dropped inside the DockingLayout.  The property is an array that accepts multiple positions. Note: Positions with prefix 'layout-' are applied to the Tab item children of the TabsWidnow owner that is being dragged. The rest of the positions indicate the allowed drop position inside the hovered target(TabsWindow). Used only by jqxDockingLayout custom elements. Determines the possible drop position inside the DockingLayout. The following values are allowed. */
+    get dropPosition() {
+        return this.nativeElement ? this.nativeElement.dropPosition : undefined;
+    }
+    set dropPosition(value) {
+        this.nativeElement ? this.nativeElement.dropPosition = value : undefined;
+    }
+    /** @description A callback function defining the new format for the label of the Progress Bar. Applicable only to ProgressWindow. */
+    get formatFunction() {
+        return this.nativeElement ? this.nativeElement.formatFunction : undefined;
+    }
+    set formatFunction(value) {
+        this.nativeElement ? this.nativeElement.formatFunction = value : undefined;
+    }
+    /** @description Determines the position of the footer of the window element. */
+    get footerPosition() {
+        return this.nativeElement ? this.nativeElement.footerPosition : undefined;
+    }
+    set footerPosition(value) {
+        this.nativeElement ? this.nativeElement.footerPosition = value : undefined;
+    }
+    /** @description Determines the template for the Dialog section of the window. By default footerTemplate is null. */
+    get footerTemplate() {
+        return this.nativeElement ? this.nativeElement.footerTemplate : undefined;
+    }
+    set footerTemplate(value) {
+        this.nativeElement ? this.nativeElement.footerTemplate = value : undefined;
+    }
+    /** @description Set's the buttons that will be visible in the header section. */
+    get headerButtons() {
+        return this.nativeElement ? this.nativeElement.headerButtons : undefined;
+    }
+    set headerButtons(value) {
+        this.nativeElement ? this.nativeElement.headerButtons = value : undefined;
+    }
+    /** @description Determines the template for the Dialog section of the window. By default headerTemplate is null. */
+    get headerTemplate() {
+        return this.nativeElement ? this.nativeElement.headerTemplate : undefined;
+    }
+    set headerTemplate(value) {
+        this.nativeElement ? this.nativeElement.headerTemplate = value : undefined;
+    }
+    /** @description Determines the position of the header of the window element. */
+    get headerPosition() {
+        return this.nativeElement ? this.nativeElement.headerPosition : undefined;
+    }
+    set headerPosition(value) {
+        this.nativeElement ? this.nativeElement.headerPosition = value : undefined;
+    }
+    /** @description Sets additional helper text below the text box. The hint is visible only when the text box is focued. Applicable to Prompt Window. */
+    get hint() {
+        return this.nativeElement ? this.nativeElement.hint : undefined;
+    }
+    set hint(value) {
+        this.nativeElement ? this.nativeElement.hint = value : undefined;
+    }
+    /** @description Sets the value of the Progress bar to indeterminate state(null) and starts the animation. Applicable only to ProgressWindow. */
+    get indeterminate() {
+        return this.nativeElement ? this.nativeElement.indeterminate : undefined;
+    }
+    set indeterminate(value) {
+        this.nativeElement ? this.nativeElement.indeterminate = value : undefined;
+    }
+    /** @description Sets the filling direction of the Progress Bar. Applicable only to ProgressWindow. */
+    get inverted() {
+        return this.nativeElement ? this.nativeElement.inverted : undefined;
+    }
+    set inverted(value) {
+        this.nativeElement ? this.nativeElement.inverted = value : undefined;
+    }
+    /** @description The label of the window that appears in the header area. */
+    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 happens live. By default it's not enabled and during resizing a highlighter around the edges of the window appears to outline  the current size of the element. */
+    get liveResize() {
+        return this.nativeElement ? this.nativeElement.liveResize : undefined;
+    }
+    set liveResize(value) {
+        this.nativeElement ? this.nativeElement.liveResize = value : undefined;
+    }
+    /** @description Applicable only to TabsWindow when used with a DockingLayout custom element.Used only by jqxDockingLayout. Determines the owner jqxDockingLayout  that the window belongs to. When the tabsWindow has been removed from a DockingLayout element, the property is used to indicate that it belongs to that particular Dockinglayout. Accepts a string, representing the ID of a jqxDockingLayout on the page, or an instance of jqxDokcingLayout. */
+    get layout() {
+        return this.nativeElement ? this.nativeElement.layout : undefined;
+    }
+    set layout(value) {
+        this.nativeElement ? this.nativeElement.layout = 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 Applicable only to TabsWindow when docked inside a DockingLayout Custom Element.Determines of the item can be resized or not. */
+    get locked() {
+        return this.nativeElement ? this.nativeElement.locked : undefined;
+    }
+    set locked(value) {
+        this.nativeElement ? this.nativeElement.locked = value : undefined;
+    }
+    /** @description Callback, related to localization module.  */
+    get localizeFormatFunction() {
+        return this.nativeElement ? this.nativeElement.localizeFormatFunction : undefined;
+    }
+    set localizeFormatFunction(value) {
+        this.nativeElement ? this.nativeElement.localizeFormatFunction = value : undefined;
+    }
+    /** @description Determines if the window is maximized or not. When maximized the window covers the whole viewport. */
+    get maximized() {
+        return this.nativeElement ? this.nativeElement.maximized : undefined;
+    }
+    set maximized(value) {
+        this.nativeElement ? this.nativeElement.maximized = 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 Determines if the window is modal or not. If true the user can only interact with the window and nothing else on the page. */
+    get modal() {
+        return this.nativeElement ? this.nativeElement.modal : undefined;
+    }
+    set modal(value) {
+        this.nativeElement ? this.nativeElement.modal = value : undefined;
+    }
+    /** @description Applicable to TabsWindow when docked inside a DockingLayout Custom Element. Determines the max size of the item. Applicable to Progress Window by allowing the user to specify the maximum of the ProgressBar. */
+    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 DockingLayout Custom Element. Determines the min size of the item. Applicable to Progress Window by allowing the user to specify the minimu of the ProgressBar. */
+    get min() {
+        return this.nativeElement ? this.nativeElement.min : undefined;
+    }
+    set min(value) {
+        this.nativeElement ? this.nativeElement.min = value : undefined;
+    }
+    /** @description Determines if the window is minimized or not. When minimized the window is docked at the bottom left corner of the viewport. */
+    get minimized() {
+        return this.nativeElement ? this.nativeElement.minimized : undefined;
+    }
+    set minimized(value) {
+        this.nativeElement ? this.nativeElement.minimized = value : undefined;
+    }
+    /** @description Sets or gets the maximum number of characters that the user can enter. Applicable to Prompt/MultilinePrompt Window. */
+    get maxLength() {
+        return this.nativeElement ? this.nativeElement.maxLength : undefined;
+    }
+    set maxLength(value) {
+        this.nativeElement ? this.nativeElement.maxLength = value : undefined;
+    }
+    /** @description Sets or gets the minimum number of characters that the user have to enter to trigger the auto complete functionality. Applicable to Prompt/MultilinePrompt Window. */
+    get minLength() {
+        return this.nativeElement ? this.nativeElement.minLength : undefined;
+    }
+    set minLength(value) {
+        this.nativeElement ? this.nativeElement.minLength = value : undefined;
+    }
+    /** @description Determines if the window is visible or not. */
+    get opened() {
+        return this.nativeElement ? this.nativeElement.opened : undefined;
+    }
+    set opened(value) {
+        this.nativeElement ? this.nativeElement.opened = value : undefined;
+    }
+    /** @description Determines if the window is pinned or not. Pinned window is a window that can't be dragged but can be resized. */
+    get pinned() {
+        return this.nativeElement ? this.nativeElement.pinned : undefined;
+    }
+    set pinned(value) {
+        this.nativeElement ? this.nativeElement.pinned = value : undefined;
+    }
+    /** @description Determines the input's placeholder. Applicable to Prompt Window. */
+    get placeholder() {
+        return this.nativeElement ? this.nativeElement.placeholder : undefined;
+    }
+    set placeholder(value) {
+        this.nativeElement ? this.nativeElement.placeholder = value : undefined;
+    }
+    /** @description Determines the label for the Input insinde the PromptWindow. */
+    get promptLabel() {
+        return this.nativeElement ? this.nativeElement.promptLabel : undefined;
+    }
+    set promptLabel(value) {
+        this.nativeElement ? this.nativeElement.promptLabel = value : undefined;
+    }
+    /** @description If the element is readonly, users cannot interact with it. */
+    get readonly() {
+        return this.nativeElement ? this.nativeElement.readonly : undefined;
+    }
+    set readonly(value) {
+        this.nativeElement ? this.nativeElement.readonly = value : undefined;
+    }
+    /** @description When applied a resize indicator is displayed in the bottom right corner of the window and resizing operation can be initiated only from its position. */
+    get resizeIndicator() {
+        return this.nativeElement ? this.nativeElement.resizeIndicator : undefined;
+    }
+    set resizeIndicator(value) {
+        this.nativeElement ? this.nativeElement.resizeIndicator = value : undefined;
+    }
+    /** @description Determines the resizing mode of the window.  Several modes are available:   none - resizing is disabled.  vertical - vertical resizing is allowed.  horizontal - horizontal resizing is allowed. both - horizontal and vertical resizing is allowed. top - the window can only be resized from the top side. bottom - the window is resizable only from the bottom side. left - the window can be resized only from the left side. right - the window can be resized only from the right side.  */
+    get resizeMode() {
+        return this.nativeElement ? this.nativeElement.resizeMode : undefined;
+    }
+    set resizeMode(value) {
+        this.nativeElement ? this.nativeElement.resizeMode = 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 Specifies that the user must fill the input before submitting a form with the text box.Applicable to Prompt Window. */
+    get required() {
+        return this.nativeElement ? this.nativeElement.required : undefined;
+    }
+    set required(value) {
+        this.nativeElement ? this.nativeElement.required = value : undefined;
+    }
+    /** @description Specifies the message that will appear if required is set and no value is provided in the input. Applicable to Prompt Window. */
+    get requiredMessage() {
+        return this.nativeElement ? this.nativeElement.requiredMessage : undefined;
+    }
+    set requiredMessage(value) {
+        this.nativeElement ? this.nativeElement.requiredMessage = value : undefined;
+    }
+    /** @description Determines whether the content of the input will be selected on focus or not. Applicable to Prompt Window. */
+    get selectAllOnFocus() {
+        return this.nativeElement ? this.nativeElement.selectAllOnFocus : undefined;
+    }
+    set selectAllOnFocus(value) {
+        this.nativeElement ? this.nativeElement.selectAllOnFocus = value : undefined;
+    }
+    /** @description Sets or gets which tab is selected. Applicable only to TabsWindow. */
+    get selectedIndex() {
+        return this.nativeElement ? this.nativeElement.selectedIndex : undefined;
+    }
+    set selectedIndex(value) {
+        this.nativeElement ? this.nativeElement.selectedIndex = value : undefined;
+    }
+    /** @description Determines the way the user can switch between tabs. Applicable only to TabsWindow. */
+    get selectionMode() {
+        return this.nativeElement ? this.nativeElement.selectionMode : undefined;
+    }
+    set selectionMode(value) {
+        this.nativeElement ? this.nativeElement.selectionMode = value : undefined;
+    }
+    /** @description Indicates the index of the last character in the current selection. Applicable only to MultilinePromptWindow. */
+    get selectionEnd() {
+        return this.nativeElement ? this.nativeElement.selectionEnd : undefined;
+    }
+    set selectionEnd(value) {
+        this.nativeElement ? this.nativeElement.selectionEnd = value : undefined;
+    }
+    /** @description Indicates the index to the first character in the current selection. Applicable only to MultilinePromptWindow. */
+    get selectionStart() {
+        return this.nativeElement ? this.nativeElement.selectionStart : undefined;
+    }
+    set selectionStart(value) {
+        this.nativeElement ? this.nativeElement.selectionStart = value : undefined;
+    }
+    /** @description Enables/Disabled the label for the Progress Bar. Applicable only to Progress Window. */
+    get showProgressValue() {
+        return this.nativeElement ? this.nativeElement.showProgressValue : undefined;
+    }
+    set showProgressValue(value) {
+        this.nativeElement ? this.nativeElement.showProgressValue = value : undefined;
+    }
+    /** @description A getter that returns the siblings (that share the same parent) of a LayoutPanel item that is docked inside a DockingLayout. The siblings are also DockingLayout items ( LayoutPanels).Applicable only to TabsWindow when docked inside a DockingLayout. */
+    get siblings() {
+        return this.nativeElement ? this.nativeElement.siblings : undefined;
+    }
+    set siblings(value) {
+        this.nativeElement ? this.nativeElement.siblings = value : undefined;
+    }
+    /** @description Applicable to TabsWindow when nested inside a DockingLayout Custom Element. Determines the size of the item. */
+    get size() {
+        return this.nativeElement ? this.nativeElement.size : undefined;
+    }
+    set size(value) {
+        this.nativeElement ? this.nativeElement.size = value : undefined;
+    }
+    /** @description Specifies whether the element is to have its spelling and grammar checked or not. Applicable only to MultilinePromptWindow. */
+    get spellCheck() {
+        return this.nativeElement ? this.nativeElement.spellCheck : undefined;
+    }
+    set spellCheck(value) {
+        this.nativeElement ? this.nativeElement.spellCheck = value : undefined;
+    }
+    /** @description Sets or gets whether close buttons are displayed inside the Tab Strip of the TabsWindow. Applicable only to TabsWindow. */
+    get tabCloseButtons() {
+        return this.nativeElement ? this.nativeElement.tabCloseButtons : undefined;
+    }
+    set tabCloseButtons(value) {
+        this.nativeElement ? this.nativeElement.tabCloseButtons = value : undefined;
+    }
+    /** @description Determines if the close button is visible on select or always. Applicable only to TabsWindow. */
+    get tabCloseButtonMode() {
+        return this.nativeElement ? this.nativeElement.tabCloseButtonMode : undefined;
+    }
+    set tabCloseButtonMode(value) {
+        this.nativeElement ? this.nativeElement.tabCloseButtonMode = value : undefined;
+    }
+    /** @description Sets or gets the Tabs scroll buttons behavior. Applicable only when tabLayout is 'scroll'. Applicable only to TabsWindow. */
+    get tabOverflow() {
+        return this.nativeElement ? this.nativeElement.tabOverflow : undefined;
+    }
+    set tabOverflow(value) {
+        this.nativeElement ? this.nativeElement.tabOverflow = value : undefined;
+    }
+    /** @description Detetmines Tab Strip is positioned of the TabsWindow. Applicable only to TabsWindow. */
+    get tabPosition() {
+        return this.nativeElement ? this.nativeElement.tabPosition : undefined;
+    }
+    set tabPosition(value) {
+        this.nativeElement ? this.nativeElement.tabPosition = value : undefined;
+    }
+    /** @description Sets or gets the position of the scroll buttons inside the Tab header of the TabsWindow. Applicable only to TabsWindow. */
+    get tabScrollButtonsPosition() {
+        return this.nativeElement ? this.nativeElement.tabScrollButtonsPosition : undefined;
+    }
+    set tabScrollButtonsPosition(value) {
+        this.nativeElement ? this.nativeElement.tabScrollButtonsPosition = value : undefined;
+    }
+    /** @description Sets or gets the orientation of the text in the tabs labels of the TabsWindow. Applicable only to TabsWindow. */
+    get tabTextOrientation() {
+        return this.nativeElement ? this.nativeElement.tabTextOrientation : undefined;
+    }
+    set tabTextOrientation(value) {
+        this.nativeElement ? this.nativeElement.tabTextOrientation = 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;
+    }
+    /** @description If is set to true, the element cannot be focused. */
+    get unfocusable() {
+        return this.nativeElement ? this.nativeElement.unfocusable : undefined;
+    }
+    set unfocusable(value) {
+        this.nativeElement ? this.nativeElement.unfocusable = value : undefined;
+    }
+    /** @description Determines the value of the TextBox/ProgressBar inside the Dialog/Prompt/Progress Window */
+    get value() {
+        return this.nativeElement ? this.nativeElement.value : undefined;
+    }
+    set value(value) {
+        this.nativeElement ? this.nativeElement.value = value : undefined;
+    }
+    /** @description Determines the actual parent of the element. The window can size and move only in the area of that element. */
+    get windowParent() {
+        return this.nativeElement ? this.nativeElement.windowParent : undefined;
+    }
+    set windowParent(value) {
+        this.nativeElement ? this.nativeElement.windowParent = value : undefined;
+    }
+    /** @description Indicates how the input wraps text. Applicable only to MultilinePromptWindow. */
+    get wrap() {
+        return this.nativeElement ? this.nativeElement.wrap : undefined;
+    }
+    set wrap(value) {
+        this.nativeElement ? this.nativeElement.wrap = value : undefined;
+    }
+    /** @description Appends a tabitem to the end of the list of tab items inside element.
+    * @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;
+    }
+    /** @description Sets the window to the top level so the user can interact with it.
+    */
+    bringToFront() {
+        if (this.nativeElement.isRendered) {
+            this.nativeElement.bringToFront();
+        }
+        else {
+            this.nativeElement.whenRendered(() => {
+                this.nativeElement.bringToFront();
+            });
+        }
+    }
+    /** @description Clears the content of the Window.
+    */
+    clear() {
+        if (this.nativeElement.isRendered) {
+            this.nativeElement.clear();
+        }
+        else {
+            this.nativeElement.whenRendered(() => {
+                this.nativeElement.clear();
+            });
+        }
+    }
+    /** @description Closes the window.
+    */
+    close() {
+        if (this.nativeElement.isRendered) {
+            this.nativeElement.close();
+        }
+        else {
+            this.nativeElement.whenRendered(() => {
+                this.nativeElement.close();
+            });
+        }
+    }
+    /** @description Collapses the window.
+    * @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;
+    }
+    /** @description Makes sure a tab item is visible by scrolling to it. Applicable only to TabsWindow.
+    * @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 Expands the window after being collapsed.
+    * @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;
+    }
+    /** @description Inserts a new tab and an associated content section. Applicable only to TabsWindow.
+    * @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 before the reference "smart-tab-item" node. Applicable only to TabsWindow.
+    * @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;
+    }
+    /** @description Removes a tab and its associated content section. Applicable only to TabsWindow.
+    * @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 "smart-tab-item" node. Applicable only to TabsWindow.
+    * @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;
+    }
+    /** @description Maximizes the window to fill the area.
+    */
+    maximize() {
+        if (this.nativeElement.isRendered) {
+            this.nativeElement.maximize();
+        }
+        else {
+            this.nativeElement.whenRendered(() => {
+                this.nativeElement.maximize();
+            });
+        }
+    }
+    /** @description Minimizes the window.
+    */
+    minimize() {
+        if (this.nativeElement.isRendered) {
+            this.nativeElement.minimize();
+        }
+        else {
+            this.nativeElement.whenRendered(() => {
+                this.nativeElement.minimize();
+            });
+        }
+    }
+    /** @description Opens the window
+    */
+    open() {
+        if (this.nativeElement.isRendered) {
+            this.nativeElement.open();
+        }
+        else {
+            this.nativeElement.whenRendered(() => {
+                this.nativeElement.open();
+            });
+        }
+    }
+    /** @description Pins the window. Disables window dragging.
+    */
+    pin() {
+        if (this.nativeElement.isRendered) {
+            this.nativeElement.pin();
+        }
+        else {
+            this.nativeElement.whenRendered(() => {
+                this.nativeElement.pin();
+            });
+        }
+    }
+    /** @description Restores the window to it's previous size before maximization/minimization.
+    */
+    restore() {
+        if (this.nativeElement.isRendered) {
+            this.nativeElement.restore();
+        }
+        else {
+            this.nativeElement.whenRendered(() => {
+                this.nativeElement.restore();
+            });
+        }
+    }
+    /** @description Selects a tab.  Applicalbe only to TabsWindow elements.
+    * @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 Unpins the window. Enables window dragging.
+    */
+    unpin() {
+        if (this.nativeElement.isRendered) {
+            this.nativeElement.unpin();
+        }
+        else {
+            this.nativeElement.whenRendered(() => {
+                this.nativeElement.unpin();
+            });
+        }
+    }
+    /** @description Updates a tab and its associated content section.  Applicalbe only to TabsWindow elements.
+    * @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);
+        Smart.Render();
+        this.nativeElement.classList.add('smart-angular');
+        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.2", ngImport: i0, type: WindowComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+WindowComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.2", type: WindowComponent, selector: "smart-window, [smart-window], smart-tabs-window, smart-prompt-window, smart-multilineprompt-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", 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", 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" }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: WindowComponent, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'smart-window, [smart-window], smart-tabs-window, smart-prompt-window, smart-multilineprompt-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
+            }], 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
+            }], 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
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart.window.js","sourceRoot":"","sources":["../../../window/src/smart.window.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,SAAS,EAA6B,KAAK,EAA+C,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC1J,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;;AAErD,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAQxC,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAC/C,YAAY,GAAuB;QAClC,KAAK,CAAC,GAAG,CAAC,CAAC;QAIJ,kBAAa,GAAU,EAAE,CAAC;QAwmBlC;8CACsC;QAC5B,cAAS,GAA8B,IAAI,YAAY,EAAE,CAAC;QAEpE;8CACsC;QAC5B,WAAM,GAA8B,IAAI,YAAY,EAAE,CAAC;QAEjE;8CACsC;QAC5B,cAAS,GAA8B,IAAI,YAAY,EAAE,CAAC;QAEpE;8CACsC;QAC5B,YAAO,GAA8B,IAAI,YAAY,EAAE,CAAC;QAElE;8CACsC;QAC5B,eAAU,GAA8B,IAAI,YAAY,EAAE,CAAC;QAErE;8CACsC;QAC5B,cAAS,GAA8B,IAAI,YAAY,EAAE,CAAC;QAEpE;8CACsC;QAC5B,gBAAW,GAA8B,IAAI,YAAY,EAAE,CAAC;QAEtE;8CACsC;QAC5B,aAAQ,GAA8B,IAAI,YAAY,EAAE,CAAC;QAEnE;8CACsC;QAC5B,eAAU,GAA8B,IAAI,YAAY,EAAE,CAAC;QAErE;8CACsC;QAC5B,eAAU,GAA8B,IAAI,YAAY,EAAE,CAAC;QAErE;8CACsC;QAC5B,gBAAW,GAA8B,IAAI,YAAY,EAAE,CAAC;QAEtE;8CACsC;QAC5B,kBAAa,GAA8B,IAAI,YAAY,EAAE,CAAC;QAExE;8CACsC;QAC5B,cAAS,GAA8B,IAAI,YAAY,EAAE,CAAC;QA7pBnE,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC,aAAuB,CAAC;IAClD,CAAC;IAKD;;OAEG;IACI,eAAe,CAAC,UAAU,GAAG,EAAE;QAClC,IAAI,CAAC,aAAa,GAAW,QAAQ,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;QACvE,KAAK,IAAI,YAAY,IAAI,UAAU,EAAE;YACnC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;SAC7D;QACD,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;IACD,iHAAiH;IACjH,IACI,SAAS;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IACD,IAAI,SAAS,CAAC,KAAc;QAC3B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IAED,6GAA6G;IAC7G,IACI,SAAS;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IACD,IAAI,SAAS,CAAC,KAAgB;QAC7B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IAED,2KAA2K;IAC3K,IACI,cAAc;QACjB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IACD,IAAI,cAAc,CAAC,KAA2B;QAC7C,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,CAAC;IAED,8IAA8I;IAC9I,IACI,UAAU;QACb,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IACD,IAAI,UAAU,CAAC,KAAc;QAC5B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IAED,0FAA0F;IAC1F,IACI,WAAW;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IACD,IAAI,WAAW,CAAC,KAAa;QAC5B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IAED,+FAA+F;IAC/F,IACI,aAAa;QAChB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1E,CAAC;IACD,IAAI,aAAa,CAAC,KAAa;QAC9B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IAED,4FAA4F;IAC5F,IACI,YAAY;QACf,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IACD,IAAI,YAAY,CAAC,KAAa;QAC7B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1E,CAAC;IAED,8HAA8H;IAC9H,IACI,SAAS;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IACD,IAAI,SAAS,CAAC,KAAc;QAC3B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IAED,6HAA6H;IAC7H,IACI,gBAAgB;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7E,CAAC;IACD,IAAI,gBAAgB,CAAC,KAAc;QAClC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,gBAAgB,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9E,CAAC;IAED,oHAAoH;IACpH,IACI,UAAU;QACb,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IACD,IAAI,UAAU,CAAC,KAAyC;QACvD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IAED,mDAAmD;IACnD,IACI,QAAQ;QACX,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IACrE,CAAC;IACD,IAAI,QAAQ,CAAC,KAAc;QAC1B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IAED,oEAAoE;IACpE,IACI,WAAW;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IACD,IAAI,WAAW,CAAC,KAAc;QAC7B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IAED,8GAA8G;IAC9G,IACI,WAAW;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IACD,IAAI,WAAW,CAAC,KAAwB;QACvC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IAED,umBAAumB;IACvmB,IACI,YAAY;QACf,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IACD,IAAI,YAAY,CAAC,KAAyB;QACzC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1E,CAAC;IAED,qIAAqI;IACrI,IACI,cAAc;QACjB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IACD,IAAI,cAAc,CAAC,KAAU;QAC5B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,CAAC;IAED,gFAAgF;IAChF,IACI,cAAc;QACjB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IACD,IAAI,cAAc,CAAC,KAA2B;QAC7C,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,CAAC;IAED,oHAAoH;IACpH,IACI,cAAc;QACjB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IACD,IAAI,cAAc,CAAC,KAAU;QAC5B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,CAAC;IAED,iFAAiF;IACjF,IACI,aAAa;QAChB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1E,CAAC;IACD,IAAI,aAAa,CAAC,KAAe;QAChC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IAED,oHAAoH;IACpH,IACI,cAAc;QACjB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IACD,IAAI,cAAc,CAAC,KAAU;QAC5B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,CAAC;IAED,gFAAgF;IAChF,IACI,cAAc;QACjB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IACD,IAAI,cAAc,CAAC,KAAkB;QACpC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,CAAC;IAED,sJAAsJ;IACtJ,IACI,IAAI;QACP,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,CAAC;IACD,IAAI,IAAI,CAAC,KAAU;QAClB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IAED,gJAAgJ;IAChJ,IACI,aAAa;QAChB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1E,CAAC;IACD,IAAI,aAAa,CAAC,KAAc;QAC/B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IAED,sGAAsG;IACtG,IACI,QAAQ;QACX,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IACrE,CAAC;IACD,IAAI,QAAQ,CAAC,KAAc;QAC1B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IAED,4EAA4E;IAC5E,IACI,KAAK;QACR,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IACD,IAAI,KAAK,CAAC,KAAa;QACtB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,CAAC;IAED,uNAAuN;IACvN,IACI,UAAU;QACb,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IACD,IAAI,UAAU,CAAC,KAAc;QAC5B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IAED,ocAAoc;IACpc,IACI,MAAM;QACT,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,CAAC;IACD,IAAI,MAAM,CAAC,KAAU;QACpB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACpE,CAAC;IAED,+FAA+F;IAC/F,IACI,MAAM;QACT,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,CAAC;IACD,IAAI,MAAM,CAAC,KAAa;QACvB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACpE,CAAC;IAED,iJAAiJ;IACjJ,IACI,MAAM;QACT,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,CAAC;IACD,IAAI,MAAM,CAAC,KAAc;QACxB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACpE,CAAC;IAED,8DAA8D;IAC9D,IACI,sBAAsB;QACzB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,sBAAsB,CAAC,CAAC,CAAC,SAAS,CAAC;IACnF,CAAC;IACD,IAAI,sBAAsB,CAAC,KAAU;QACpC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,sBAAsB,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACpF,CAAC;IAED,sHAAsH;IACtH,IACI,SAAS;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IACD,IAAI,SAAS,CAAC,KAAc;QAC3B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IAED,sJAAsJ;IACtJ,IACI,QAAQ;QACX,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IACrE,CAAC;IACD,IAAI,QAAQ,CAAC,KAAU;QACtB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IAED,8IAA8I;IAC9I,IACI,KAAK;QACR,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IACD,IAAI,KAAK,CAAC,KAAc;QACvB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,CAAC;IAED,kOAAkO;IAClO,IACI,GAAG;QACN,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;IAChE,CAAC;IACD,IAAI,GAAG,CAAC,KAA6B;QACpC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,CAAC;IAED,+NAA+N;IAC/N,IACI,GAAG;QACN,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;IAChE,CAAC;IACD,IAAI,GAAG,CAAC,KAA6B;QACpC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,CAAC;IAED,gJAAgJ;IAChJ,IACI,SAAS;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IACD,IAAI,SAAS,CAAC,KAAc;QAC3B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IAED,uIAAuI;IACvI,IACI,SAAS;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IACD,IAAI,SAAS,CAAC,KAAa;QAC1B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IAED,sLAAsL;IACtL,IACI,SAAS;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IACD,IAAI,SAAS,CAAC,KAAa;QAC1B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IAED,+DAA+D;IAC/D,IACI,MAAM;QACT,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,CAAC;IACD,IAAI,MAAM,CAAC,KAAc;QACxB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACpE,CAAC;IAED,kIAAkI;IAClI,IACI,MAAM;QACT,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,CAAC;IACD,IAAI,MAAM,CAAC,KAAc;QACxB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACpE,CAAC;IAED,oFAAoF;IACpF,IACI,WAAW;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IACD,IAAI,WAAW,CAAC,KAAa;QAC5B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IAED,gFAAgF;IAChF,IACI,WAAW;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IACD,IAAI,WAAW,CAAC,KAAa;QAC5B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IAED,8EAA8E;IAC9E,IACI,QAAQ;QACX,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IACrE,CAAC;IACD,IAAI,QAAQ,CAAC,KAAc;QAC1B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IAED,yKAAyK;IACzK,IACI,eAAe;QAClB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,CAAC;IACD,IAAI,eAAe,CAAC,KAAc;QACjC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,eAAe,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7E,CAAC;IAED,mfAAmf;IACnf,IACI,UAAU;QACb,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IACD,IAAI,UAAU,CAAC,KAAuB;QACrC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IAED,kIAAkI;IAClI,IACI,WAAW;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IACD,IAAI,WAAW,CAAC,KAAc;QAC7B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IAED,uIAAuI;IACvI,IACI,QAAQ;QACX,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IACrE,CAAC;IACD,IAAI,QAAQ,CAAC,KAAc;QAC1B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IAED,iJAAiJ;IACjJ,IACI,eAAe;QAClB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,CAAC;IACD,IAAI,eAAe,CAAC,KAAa;QAChC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,eAAe,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7E,CAAC;IAED,8HAA8H;IAC9H,IACI,gBAAgB;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7E,CAAC;IACD,IAAI,gBAAgB,CAAC,KAAc;QAClC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,gBAAgB,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9E,CAAC;IAED,sFAAsF;IACtF,IACI,aAAa;QAChB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1E,CAAC;IACD,IAAI,aAAa,CAAC,KAAoB;QACrC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IAED,uGAAuG;IACvG,IACI,aAAa;QAChB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1E,CAAC;IACD,IAAI,aAAa,CAAC,KAAuB;QACxC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IAED,iIAAiI;IACjI,IACI,YAAY;QACf,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IACD,IAAI,YAAY,CAAC,KAAa;QAC7B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1E,CAAC;IAED,kIAAkI;IAClI,IACI,cAAc;QACjB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC;IAC3E,CAAC;IACD,IAAI,cAAc,CAAC,KAAa;QAC/B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,CAAC;IAED,wGAAwG;IACxG,IACI,iBAAiB;QACpB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9E,CAAC;IACD,IAAI,iBAAiB,CAAC,KAAc;QACnC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,iBAAiB,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC/E,CAAC;IAED,4QAA4Q;IAC5Q,IACI,QAAQ;QACX,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IACrE,CAAC;IACD,IAAI,QAAQ,CAAC,KAAU;QACtB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;IAED,gIAAgI;IAChI,IACI,IAAI;QACP,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,CAAC;IACD,IAAI,IAAI,CAAC,KAAa;QACrB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IAED,+IAA+I;IAC/I,IACI,UAAU;QACb,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;IACvE,CAAC;IACD,IAAI,UAAU,CAAC,KAAc;QAC5B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IAED,2IAA2I;IAC3I,IACI,eAAe;QAClB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5E,CAAC;IACD,IAAI,eAAe,CAAC,KAAc;QACjC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,eAAe,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7E,CAAC;IAED,iHAAiH;IACjH,IACI,kBAAkB;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC;IAC/E,CAAC;IACD,IAAI,kBAAkB,CAAC,KAA+B;QACrD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,kBAAkB,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAChF,CAAC;IAED,6IAA6I;IAC7I,IACI,WAAW;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IACD,IAAI,WAAW,CAAC,KAAe;QAC9B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IAED,wGAAwG;IACxG,IACI,WAAW;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IACD,IAAI,WAAW,CAAC,KAAkB;QACjC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IAED,2IAA2I;IAC3I,IACI,wBAAwB;QAC3B,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,wBAAwB,CAAC,CAAC,CAAC,SAAS,CAAC;IACrF,CAAC;IACD,IAAI,wBAAwB,CAAC,KAAqB;QACjD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,wBAAwB,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACtF,CAAC;IAED,iIAAiI;IACjI,IACI,kBAAkB;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC;IAC/E,CAAC;IACD,IAAI,kBAAkB,CAAC,KAAkB;QACxC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,kBAAkB,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAChF,CAAC;IAED,+EAA+E;IAC/E,IACI,KAAK;QACR,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IACD,IAAI,KAAK,CAAC,KAAa;QACtB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,CAAC;IAED,qEAAqE;IACrE,IACI,WAAW;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,CAAC;IACD,IAAI,WAAW,CAAC,KAAc;QAC7B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IAED,4GAA4G;IAC5G,IACI,KAAK;QACR,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IACD,IAAI,KAAK,CAAC,KAAsB;QAC/B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACnE,CAAC;IAED,+HAA+H;IAC/H,IACI,YAAY;QACf,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,CAAC;IACD,IAAI,YAAY,CAAC,KAAU;QAC1B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1E,CAAC;IAED,iGAAiG;IACjG,IACI,IAAI;QACP,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IACjE,CAAC;IACD,IAAI,IAAI,CAAC,KAAiB;QACzB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IAsDD;;;IAGG;IACI,KAAK,CAAC,WAAW,CAAC,IAAI;QAC5B,MAAM,iBAAiB,GAAG,GAAG,EAAE;YACrB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;gBACzB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;oBACjC,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;oBACpD,OAAO,CAAC,MAAM,CAAC,CAAA;gBACnB,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;QACP,CAAC,CAAC;QACF,MAAM,MAAM,GAAG,MAAM,iBAAiB,EAAE,CAAC;QAEzC,OAAO,MAAM,CAAC;IAClB,CAAC;IAEJ;MACE;IACQ,YAAY;QACf,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;SACrC;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;YACtC,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;MACE;IACQ,KAAK;QACR,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;SAC9B;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YAC/B,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;MACE;IACQ,KAAK;QACR,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;SAC9B;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YAC/B,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;;IAEG;IACI,KAAK,CAAC,QAAQ;QACpB,MAAM,iBAAiB,GAAG,GAAG,EAAE;YACrB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;gBACzB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;oBACjC,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;oBAC7C,OAAO,CAAC,MAAM,CAAC,CAAA;gBACnB,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;QACP,CAAC,CAAC;QACF,MAAM,MAAM,GAAG,MAAM,iBAAiB,EAAE,CAAC;QAEzC,OAAO,MAAM,CAAC;IAClB,CAAC;IAEJ;;MAEE;IACQ,aAAa,CAAC,KAAa;QAC9B,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;SAC3C;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YAC5C,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;;IAEG;IACI,KAAK,CAAC,MAAM;QAClB,MAAM,iBAAiB,GAAG,GAAG,EAAE;YACrB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;gBACzB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;oBACjC,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;oBAC3C,OAAO,CAAC,MAAM,CAAC,CAAA;gBACnB,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;QACP,CAAC,CAAC;QACF,MAAM,MAAM,GAAG,MAAM,iBAAiB,EAAE,CAAC;QAEzC,OAAO,MAAM,CAAC;IAClB,CAAC;IAEJ;;;MAGE;IACQ,MAAM,CAAC,KAAa,EAAE,OAAY;QACrC,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;SAC7C;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YAC9C,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;;;;IAIG;IACI,KAAK,CAAC,YAAY,CAAC,OAAO,EAAE,aAAc;QAChD,MAAM,iBAAiB,GAAG,GAAG,EAAE;YACrB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;gBACzB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;oBACjC,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;oBACvE,OAAO,CAAC,MAAM,CAAC,CAAA;gBACnB,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;QACP,CAAC,CAAC;QACF,MAAM,MAAM,GAAG,MAAM,iBAAiB,EAAE,CAAC;QAEzC,OAAO,MAAM,CAAC;IAClB,CAAC;IAEJ;;MAEE;IACQ,QAAQ,CAAC,KAAa;QACzB,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;SACtC;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACvC,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;;;IAGG;IACI,KAAK,CAAC,WAAW,CAAC,IAAI;QAC5B,MAAM,iBAAiB,GAAG,GAAG,EAAE;YACrB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;gBACzB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;oBACjC,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;oBACpD,OAAO,CAAC,MAAM,CAAC,CAAA;gBACnB,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;QACP,CAAC,CAAC;QACF,MAAM,MAAM,GAAG,MAAM,iBAAiB,EAAE,CAAC;QAEzC,OAAO,MAAM,CAAC;IAClB,CAAC;IAEJ;MACE;IACQ,QAAQ;QACX,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;SACjC;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAClC,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;MACE;IACQ,QAAQ;QACX,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;SACjC;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAClC,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;MACE;IACQ,IAAI;QACP,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;SAC7B;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;YAC9B,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;MACE;IACQ,GAAG;QACN,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;SAC5B;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;YAC7B,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;MACE;IACQ,OAAO;QACV,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;SAChC;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;YACjC,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;;MAEE;IACQ,MAAM,CAAC,KAAa;QACvB,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;SACpC;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACrC,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;MACE;IACQ,KAAK;QACR,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;SAC9B;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YAC/B,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAEJ;;;;MAIE;IACQ,MAAM,CAAC,KAAa,EAAE,KAAa,EAAE,OAA6B;QACrE,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YAC/B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;SACpD;aAED;YACI,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE;gBACjC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;YACrD,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAGJ,IAAI,UAAU;QACb,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC;IACnE,CAAC;IAED,QAAQ;IACR,CAAC;IAEE,eAAe;QACb,MAAM,IAAI,GAAG,IAAI,CAAC;QAElB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAE3C,KAAK,CAAC,MAAM,EAAE,CAAC;QAEf,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAElD,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClF,IAAI,CAAC,MAAM,EAAE,CAAC;IACf,CAAC;IAED,WAAW;QACV,IAAI,CAAC,QAAQ,EAAE,CAAC;IACjB,CAAC;IAED,WAAW,CAAC,OAAsB;QACjC,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE;YACxD,KAAK,MAAM,QAAQ,IAAI,OAAO,EAAE;gBAC/B,IAAI,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;oBACrC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,YAAY,CAAC;iBAC9D;aACD;SACD;IACF,CAAC;IAED,wCAAwC;IAChC,MAAM;QACP,MAAM,IAAI,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAC9F,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAErF,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QACxF,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC;QAE/E,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAC9F,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAErF,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAC1F,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC;QAEjF,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAChG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC;QAEvF,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAC9F,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAErF,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAClG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC;QAEzF,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAC5F,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC;QAEnF,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAChG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC;QAEvF,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAChG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC;QAEvF,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAClG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC;QAEzF,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QACtG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC,CAAC;QAE7F,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAkB,EAAE,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAC9F,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAEtF,CAAC;IAED,2CAA2C;IACnC,QAAQ;QACT,MAAM,IAAI,GAAG,IAAI,CAAC;QACxB,IAAI,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,EAAE;YACzC,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC;SACxF;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,EAAE;YACtC,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC;SAClF;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,EAAE;YACzC,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC;SACxF;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,EAAE;YACvC,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC;SACpF;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,EAAE;YAC1C,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC;SAC1F;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,EAAE;YACzC,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC;SACxF;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,EAAE;YAC3C,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC;SAC5F;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,EAAE;YACxC,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC;SACtF;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,EAAE;YAC1C,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC;SAC1F;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,EAAE;YAC1C,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC;SAC1F;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,EAAE;YAC3C,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC;SAC5F;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,EAAE;YAC7C,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC,CAAC;SAChG;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,EAAE;YACzC,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC;SACxF;IAEF,CAAC;;4GA7kCW,eAAe;gGAAf,eAAe;2FAAf,eAAe;kBAJ3B,SAAS;mBAAC;oBACV,QAAQ,EAAE,wLAAwL;iBAClM;iGAuBI,SAAS;sBADZ,KAAK;gBAUF,SAAS;sBADZ,KAAK;gBAUF,cAAc;sBADjB,KAAK;gBAUF,UAAU;sBADb,KAAK;gBAUF,WAAW;sBADd,KAAK;gBAUF,aAAa;sBADhB,KAAK;gBAUF,YAAY;sBADf,KAAK;gBAUF,SAAS;sBADZ,KAAK;gBAUF,gBAAgB;sBADnB,KAAK;gBAUF,UAAU;sBADb,KAAK;gBAUF,QAAQ;sBADX,KAAK;gBAUF,WAAW;sBADd,KAAK;gBAUF,WAAW;sBADd,KAAK;gBAUF,YAAY;sBADf,KAAK;gBAUF,cAAc;sBADjB,KAAK;gBAUF,cAAc;sBADjB,KAAK;gBAUF,cAAc;sBADjB,KAAK;gBAUF,aAAa;sBADhB,KAAK;gBAUF,cAAc;sBADjB,KAAK;gBAUF,cAAc;sBADjB,KAAK;gBAUF,IAAI;sBADP,KAAK;gBAUF,aAAa;sBADhB,KAAK;gBAUF,QAAQ;sBADX,KAAK;gBAUF,KAAK;sBADR,KAAK;gBAUF,UAAU;sBADb,KAAK;gBAUF,MAAM;sBADT,KAAK;gBAUF,MAAM;sBADT,KAAK;gBAUF,MAAM;sBADT,KAAK;gBAUF,sBAAsB;sBADzB,KAAK;gBAUF,SAAS;sBADZ,KAAK;gBAUF,QAAQ;sBADX,KAAK;gBAUF,KAAK;sBADR,KAAK;gBAUF,GAAG;sBADN,KAAK;gBAUF,GAAG;sBADN,KAAK;gBAUF,SAAS;sBADZ,KAAK;gBAUF,SAAS;sBADZ,KAAK;gBAUF,SAAS;sBADZ,KAAK;gBAUF,MAAM;sBADT,KAAK;gBAUF,MAAM;sBADT,KAAK;gBAUF,WAAW;sBADd,KAAK;gBAUF,WAAW;sBADd,KAAK;gBAUF,QAAQ;sBADX,KAAK;gBAUF,eAAe;sBADlB,KAAK;gBAUF,UAAU;sBADb,KAAK;gBAUF,WAAW;sBADd,KAAK;gBAUF,QAAQ;sBADX,KAAK;gBAUF,eAAe;sBADlB,KAAK;gBAUF,gBAAgB;sBADnB,KAAK;gBAUF,aAAa;sBADhB,KAAK;gBAUF,aAAa;sBADhB,KAAK;gBAUF,YAAY;sBADf,KAAK;gBAUF,cAAc;sBADjB,KAAK;gBAUF,iBAAiB;sBADpB,KAAK;gBAUF,QAAQ;sBADX,KAAK;gBAUF,IAAI;sBADP,KAAK;gBAUF,UAAU;sBADb,KAAK;gBAUF,eAAe;sBADlB,KAAK;gBAUF,kBAAkB;sBADrB,KAAK;gBAUF,WAAW;sBADd,KAAK;gBAUF,WAAW;sBADd,KAAK;gBAUF,wBAAwB;sBAD3B,KAAK;gBAUF,kBAAkB;sBADrB,KAAK;gBAUF,KAAK;sBADR,KAAK;gBAUF,WAAW;sBADd,KAAK;gBAUF,KAAK;sBADR,KAAK;gBAUF,YAAY;sBADf,KAAK;gBAUF,IAAI;sBADP,KAAK;gBAUI,SAAS;sBAAlB,MAAM;gBAIG,MAAM;sBAAf,MAAM;gBAIG,SAAS;sBAAlB,MAAM;gBAIG,OAAO;sBAAhB,MAAM;gBAIG,UAAU;sBAAnB,MAAM;gBAIG,SAAS;sBAAlB,MAAM;gBAIG,WAAW;sBAApB,MAAM;gBAIG,QAAQ;sBAAjB,MAAM;gBAIG,UAAU;sBAAnB,MAAM;gBAIG,UAAU;sBAAnB,MAAM;gBAIG,WAAW;sBAApB,MAAM;gBAIG,aAAa;sBAAtB,MAAM;gBAIG,SAAS;sBAAlB,MAAM","sourcesContent":["import { Window } from './../index';\nimport { Animation, WindowAutoCapitalize, WindowDisplayMode, WindowDropPosition, WindowFooterPosition, TabPosition, WindowResizeMode, TabSelectionMode, WindowTabCloseButtonMode, Overflow, LayoutPosition, Orientation, WindowWrap, ElementRenderMode} from './../index';\nimport { Component, Directive, AfterViewInit, ElementRef, Input, OnInit, OnChanges, OnDestroy, SimpleChanges, Output, EventEmitter } from '@angular/core';\nimport { BaseElement, Smart } from './smart.element';\nexport { Animation, WindowAutoCapitalize, WindowDisplayMode, WindowDropPosition, WindowFooterPosition, TabPosition, WindowResizeMode, TabSelectionMode, WindowTabCloseButtonMode, Overflow, LayoutPosition, Orientation, WindowWrap, ElementRenderMode} from './../index';\nexport { Smart } from './smart.element';\nexport { Window } from './../index';\n\n\n@Directive({\n\tselector: 'smart-window, [smart-window], smart-tabs-window, smart-prompt-window, smart-multilineprompt-window, smart-dialog-window,  smart-alert-window, smart-progress-window, smart-wait-window'\n})\n\nexport class WindowComponent extends BaseElement implements OnInit, AfterViewInit, OnDestroy, OnChanges {\n\tconstructor(ref: ElementRef<Window>) {\n\t\tsuper(ref);\n\t\tthis.nativeElement = ref.nativeElement as Window;\n\t}\n\n\tprivate eventHandlers: any[] = [];\n\n\tpublic nativeElement: Window;\n\t/** @description Creates the component on demand.\n\t * @param properties An optional object of properties, which will be added to the template binded ones.\n\t */\n\tpublic createComponent(properties = {}): any {\n    \tthis.nativeElement = <Window>document.createElement('smart-window');\n\t\tfor (let propertyName in properties) { \n \t\t\tthis.nativeElement[propertyName] = properties[propertyName];\n\t\t}\n\t\treturn this.nativeElement;\n\t}\n\t/** @description Determines if 'Add New' Tab inside the Tabs element is visible. Applicable only to TabsWindow */\n\t@Input()\n\tget addNewTab(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.addNewTab : undefined;\n\t}\n\tset addNewTab(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.addNewTab = value : undefined;\n\t}\n\n\t/** @description Sets or gets the animation mode. Animation is disabled when the property is set to 'none' */\n\t@Input()\n\tget animation(): Animation {\n\t\treturn this.nativeElement ? this.nativeElement.animation : undefined;\n\t}\n\tset animation(value: Animation) {\n\t\tthis.nativeElement ? this.nativeElement.animation = value : undefined;\n\t}\n\n\t/** @description Determines whether and how the value should be automatically capitalized as it is entered/edited by the user. Applicable only to MultilinePromptWindow. */\n\t@Input()\n\tget autoCapitalize(): WindowAutoCapitalize {\n\t\treturn this.nativeElement ? this.nativeElement.autoCapitalize : undefined;\n\t}\n\tset autoCapitalize(value: WindowAutoCapitalize) {\n\t\tthis.nativeElement ? this.nativeElement.autoCapitalize = value : undefined;\n\t}\n\n\t/** @description Determines whether element will auto expand when the input overflows vertically. Applicable only to MultilinePromptWindow. */\n\t@Input()\n\tget autoExpand(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.autoExpand : undefined;\n\t}\n\tset autoExpand(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.autoExpand = value : undefined;\n\t}\n\n\t/** @description Determines the label for the 'cancel' button inside the Prompt Window. */\n\t@Input()\n\tget cancelLabel(): string {\n\t\treturn this.nativeElement ? this.nativeElement.cancelLabel : undefined;\n\t}\n\tset cancelLabel(value: string) {\n\t\tthis.nativeElement ? this.nativeElement.cancelLabel = value : undefined;\n\t}\n\n\t/** @description Determines the label for the 'Complete' button insinde the Progress Window. */\n\t@Input()\n\tget completeLabel(): string {\n\t\treturn this.nativeElement ? this.nativeElement.completeLabel : undefined;\n\t}\n\tset completeLabel(value: string) {\n\t\tthis.nativeElement ? this.nativeElement.completeLabel = value : undefined;\n\t}\n\n\t/** @description Determines the label for the 'Confirm' button insinde the Prompt Window. */\n\t@Input()\n\tget confirmLabel(): string {\n\t\treturn this.nativeElement ? this.nativeElement.confirmLabel : undefined;\n\t}\n\tset confirmLabel(value: string) {\n\t\tthis.nativeElement ? this.nativeElement.confirmLabel = value : undefined;\n\t}\n\n\t/** @description Determines if the window is collapsed or not. When collapsed the only the header of the window is visible. */\n\t@Input()\n\tget collapsed(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.collapsed : undefined;\n\t}\n\tset collapsed(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.collapsed = value : undefined;\n\t}\n\n\t/** @description When a modal window is opened, thid property determines if clicking on the mask closes the window or not. */\n\t@Input()\n\tget closeOnMaskClick(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.closeOnMaskClick : undefined;\n\t}\n\tset closeOnMaskClick(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.closeOnMaskClick = value : undefined;\n\t}\n\n\t/** @description Determines the data source that will be loaded to the TabsWindow. Applicable only to TabsWindow. */\n\t@Input()\n\tget dataSource(): {label: string, content: string}[] {\n\t\treturn this.nativeElement ? this.nativeElement.dataSource : undefined;\n\t}\n\tset dataSource(value: {label: string, content: string}[]) {\n\t\tthis.nativeElement ? this.nativeElement.dataSource = value : undefined;\n\t}\n\n\t/** @description Enables or disables the window. */\n\t@Input()\n\tget disabled(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.disabled : undefined;\n\t}\n\tset disabled(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.disabled = value : undefined;\n\t}\n\n\t/** @description Enables or disables the window snapping feature. */\n\t@Input()\n\tget disableSnap(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.disableSnap : undefined;\n\t}\n\tset disableSnap(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.disableSnap = value : undefined;\n\t}\n\n\t/** @description Determines how the characters are displayed inside the input. Applicable to Prompt Window. */\n\t@Input()\n\tget displayMode(): WindowDisplayMode {\n\t\treturn this.nativeElement ? this.nativeElement.displayMode : undefined;\n\t}\n\tset displayMode(value: WindowDisplayMode) {\n\t\tthis.nativeElement ? this.nativeElement.displayMode = value : undefined;\n\t}\n\n\t/** @description Applicable to TabsWindow when docked inside a DockingLayout Custom Element.  Determines where the window(it's tab items as well) can be dropped inside the DockingLayout.  The property is an array that accepts multiple positions. Note: Positions with prefix 'layout-' are applied to the Tab item children of the TabsWidnow owner that is being dragged. The rest of the positions indicate the allowed drop position inside the hovered target(TabsWindow). Used only by jqxDockingLayout custom elements. Determines the possible drop position inside the DockingLayout. The following values are allowed. */\n\t@Input()\n\tget dropPosition(): WindowDropPosition {\n\t\treturn this.nativeElement ? this.nativeElement.dropPosition : undefined;\n\t}\n\tset dropPosition(value: WindowDropPosition) {\n\t\tthis.nativeElement ? this.nativeElement.dropPosition = value : undefined;\n\t}\n\n\t/** @description A callback function defining the new format for the label of the Progress Bar. Applicable only to ProgressWindow. */\n\t@Input()\n\tget formatFunction(): any {\n\t\treturn this.nativeElement ? this.nativeElement.formatFunction : undefined;\n\t}\n\tset formatFunction(value: any) {\n\t\tthis.nativeElement ? this.nativeElement.formatFunction = value : undefined;\n\t}\n\n\t/** @description Determines the position of the footer of the window element. */\n\t@Input()\n\tget footerPosition(): WindowFooterPosition {\n\t\treturn this.nativeElement ? this.nativeElement.footerPosition : undefined;\n\t}\n\tset footerPosition(value: WindowFooterPosition) {\n\t\tthis.nativeElement ? this.nativeElement.footerPosition = value : undefined;\n\t}\n\n\t/** @description Determines the template for the Dialog section of the window. By default footerTemplate is null. */\n\t@Input()\n\tget footerTemplate(): any {\n\t\treturn this.nativeElement ? this.nativeElement.footerTemplate : undefined;\n\t}\n\tset footerTemplate(value: any) {\n\t\tthis.nativeElement ? this.nativeElement.footerTemplate = value : undefined;\n\t}\n\n\t/** @description Set's the buttons that will be visible in the header section. */\n\t@Input()\n\tget headerButtons(): string[] {\n\t\treturn this.nativeElement ? this.nativeElement.headerButtons : undefined;\n\t}\n\tset headerButtons(value: string[]) {\n\t\tthis.nativeElement ? this.nativeElement.headerButtons = value : undefined;\n\t}\n\n\t/** @description Determines the template for the Dialog section of the window. By default headerTemplate is null. */\n\t@Input()\n\tget headerTemplate(): any {\n\t\treturn this.nativeElement ? this.nativeElement.headerTemplate : undefined;\n\t}\n\tset headerTemplate(value: any) {\n\t\tthis.nativeElement ? this.nativeElement.headerTemplate = value : undefined;\n\t}\n\n\t/** @description Determines the position of the header of the window element. */\n\t@Input()\n\tget headerPosition(): TabPosition {\n\t\treturn this.nativeElement ? this.nativeElement.headerPosition : undefined;\n\t}\n\tset headerPosition(value: TabPosition) {\n\t\tthis.nativeElement ? this.nativeElement.headerPosition = value : undefined;\n\t}\n\n\t/** @description Sets additional helper text below the text box. The hint is visible only when the text box is focued. Applicable to Prompt Window. */\n\t@Input()\n\tget hint(): any {\n\t\treturn this.nativeElement ? this.nativeElement.hint : undefined;\n\t}\n\tset hint(value: any) {\n\t\tthis.nativeElement ? this.nativeElement.hint = value : undefined;\n\t}\n\n\t/** @description Sets the value of the Progress bar to indeterminate state(null) and starts the animation. Applicable only to ProgressWindow. */\n\t@Input()\n\tget indeterminate(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.indeterminate : undefined;\n\t}\n\tset indeterminate(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.indeterminate = value : undefined;\n\t}\n\n\t/** @description Sets the filling direction of the Progress Bar. Applicable only to ProgressWindow. */\n\t@Input()\n\tget inverted(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.inverted : undefined;\n\t}\n\tset inverted(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.inverted = value : undefined;\n\t}\n\n\t/** @description The label of the window that appears in the header area. */\n\t@Input()\n\tget label(): string {\n\t\treturn this.nativeElement ? this.nativeElement.label : undefined;\n\t}\n\tset label(value: string) {\n\t\tthis.nativeElement ? this.nativeElement.label = value : undefined;\n\t}\n\n\t/** @description When enabled the resizing operation happens live. By default it's not enabled and during resizing a highlighter around the edges of the window appears to outline  the current size of the element. */\n\t@Input()\n\tget liveResize(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.liveResize : undefined;\n\t}\n\tset liveResize(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.liveResize = value : undefined;\n\t}\n\n\t/** @description Applicable only to TabsWindow when used with a DockingLayout custom element.Used only by jqxDockingLayout. Determines the owner jqxDockingLayout  that the window belongs to. When the tabsWindow has been removed from a DockingLayout element, the property is used to indicate that it belongs to that particular Dockinglayout. Accepts a string, representing the ID of a jqxDockingLayout on the page, or an instance of jqxDokcingLayout. */\n\t@Input()\n\tget layout(): any {\n\t\treturn this.nativeElement ? this.nativeElement.layout : undefined;\n\t}\n\tset layout(value: any) {\n\t\tthis.nativeElement ? this.nativeElement.layout = value : undefined;\n\t}\n\n\t/** @description Sets or gets the language. Used in conjunction with the property messages.  */\n\t@Input()\n\tget locale(): string {\n\t\treturn this.nativeElement ? this.nativeElement.locale : undefined;\n\t}\n\tset locale(value: string) {\n\t\tthis.nativeElement ? this.nativeElement.locale = value : undefined;\n\t}\n\n\t/** @description Applicable only to TabsWindow when docked inside a DockingLayout Custom Element.Determines of the item can be resized or not. */\n\t@Input()\n\tget locked(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.locked : undefined;\n\t}\n\tset locked(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.locked = value : undefined;\n\t}\n\n\t/** @description Callback, related to localization module.  */\n\t@Input()\n\tget localizeFormatFunction(): any {\n\t\treturn this.nativeElement ? this.nativeElement.localizeFormatFunction : undefined;\n\t}\n\tset localizeFormatFunction(value: any) {\n\t\tthis.nativeElement ? this.nativeElement.localizeFormatFunction = value : undefined;\n\t}\n\n\t/** @description Determines if the window is maximized or not. When maximized the window covers the whole viewport. */\n\t@Input()\n\tget maximized(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.maximized : undefined;\n\t}\n\tset maximized(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.maximized = value : undefined;\n\t}\n\n\t/** @description Sets or gets an object specifying strings used in the widget that can be localized. Used in conjunction with the property locale.  */\n\t@Input()\n\tget messages(): any {\n\t\treturn this.nativeElement ? this.nativeElement.messages : undefined;\n\t}\n\tset messages(value: any) {\n\t\tthis.nativeElement ? this.nativeElement.messages = value : undefined;\n\t}\n\n\t/** @description Determines if the window is modal or not. If true the user can only interact with the window and nothing else on the page. */\n\t@Input()\n\tget modal(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.modal : undefined;\n\t}\n\tset modal(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.modal = value : undefined;\n\t}\n\n\t/** @description Applicable to TabsWindow when docked inside a DockingLayout Custom Element. Determines the max size of the item. Applicable to Progress Window by allowing the user to specify the maximum of the ProgressBar. */\n\t@Input()\n\tget max(): string | number | null {\n\t\treturn this.nativeElement ? this.nativeElement.max : undefined;\n\t}\n\tset max(value: string | number | null) {\n\t\tthis.nativeElement ? this.nativeElement.max = value : undefined;\n\t}\n\n\t/** @description Applicable to TabsWindow when docked inside DockingLayout Custom Element. Determines the min size of the item. Applicable to Progress Window by allowing the user to specify the minimu of the ProgressBar. */\n\t@Input()\n\tget min(): string | number | null {\n\t\treturn this.nativeElement ? this.nativeElement.min : undefined;\n\t}\n\tset min(value: string | number | null) {\n\t\tthis.nativeElement ? this.nativeElement.min = value : undefined;\n\t}\n\n\t/** @description Determines if the window is minimized or not. When minimized the window is docked at the bottom left corner of the viewport. */\n\t@Input()\n\tget minimized(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.minimized : undefined;\n\t}\n\tset minimized(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.minimized = value : undefined;\n\t}\n\n\t/** @description Sets or gets the maximum number of characters that the user can enter. Applicable to Prompt/MultilinePrompt Window. */\n\t@Input()\n\tget maxLength(): number {\n\t\treturn this.nativeElement ? this.nativeElement.maxLength : undefined;\n\t}\n\tset maxLength(value: number) {\n\t\tthis.nativeElement ? this.nativeElement.maxLength = value : undefined;\n\t}\n\n\t/** @description Sets or gets the minimum number of characters that the user have to enter to trigger the auto complete functionality. Applicable to Prompt/MultilinePrompt Window. */\n\t@Input()\n\tget minLength(): number {\n\t\treturn this.nativeElement ? this.nativeElement.minLength : undefined;\n\t}\n\tset minLength(value: number) {\n\t\tthis.nativeElement ? this.nativeElement.minLength = value : undefined;\n\t}\n\n\t/** @description Determines if the window is visible or not. */\n\t@Input()\n\tget opened(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.opened : undefined;\n\t}\n\tset opened(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.opened = value : undefined;\n\t}\n\n\t/** @description Determines if the window is pinned or not. Pinned window is a window that can't be dragged but can be resized. */\n\t@Input()\n\tget pinned(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.pinned : undefined;\n\t}\n\tset pinned(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.pinned = value : undefined;\n\t}\n\n\t/** @description Determines the input's placeholder. Applicable to Prompt Window. */\n\t@Input()\n\tget placeholder(): string {\n\t\treturn this.nativeElement ? this.nativeElement.placeholder : undefined;\n\t}\n\tset placeholder(value: string) {\n\t\tthis.nativeElement ? this.nativeElement.placeholder = value : undefined;\n\t}\n\n\t/** @description Determines the label for the Input insinde the PromptWindow. */\n\t@Input()\n\tget promptLabel(): string {\n\t\treturn this.nativeElement ? this.nativeElement.promptLabel : undefined;\n\t}\n\tset promptLabel(value: string) {\n\t\tthis.nativeElement ? this.nativeElement.promptLabel = value : undefined;\n\t}\n\n\t/** @description If the element is readonly, users cannot interact with it. */\n\t@Input()\n\tget readonly(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.readonly : undefined;\n\t}\n\tset readonly(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.readonly = value : undefined;\n\t}\n\n\t/** @description When applied a resize indicator is displayed in the bottom right corner of the window and resizing operation can be initiated only from its position. */\n\t@Input()\n\tget resizeIndicator(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.resizeIndicator : undefined;\n\t}\n\tset resizeIndicator(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.resizeIndicator = value : undefined;\n\t}\n\n\t/** @description Determines the resizing mode of the window.  Several modes are available:   none - resizing is disabled.  vertical - vertical resizing is allowed.  horizontal - horizontal resizing is allowed. both - horizontal and vertical resizing is allowed. top - the window can only be resized from the top side. bottom - the window is resizable only from the bottom side. left - the window can be resized only from the left side. right - the window can be resized only from the right side.  */\n\t@Input()\n\tget resizeMode(): WindowResizeMode {\n\t\treturn this.nativeElement ? this.nativeElement.resizeMode : undefined;\n\t}\n\tset resizeMode(value: WindowResizeMode) {\n\t\tthis.nativeElement ? this.nativeElement.resizeMode = value : undefined;\n\t}\n\n\t/** @description Sets or gets the value indicating whether the element is aligned to support locales using right-to-left fonts. */\n\t@Input()\n\tget rightToLeft(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.rightToLeft : undefined;\n\t}\n\tset rightToLeft(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.rightToLeft = value : undefined;\n\t}\n\n\t/** @description Specifies that the user must fill the input before submitting a form with the text box.Applicable to Prompt Window. */\n\t@Input()\n\tget required(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.required : undefined;\n\t}\n\tset required(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.required = value : undefined;\n\t}\n\n\t/** @description Specifies the message that will appear if required is set and no value is provided in the input. Applicable to Prompt Window. */\n\t@Input()\n\tget requiredMessage(): string {\n\t\treturn this.nativeElement ? this.nativeElement.requiredMessage : undefined;\n\t}\n\tset requiredMessage(value: string) {\n\t\tthis.nativeElement ? this.nativeElement.requiredMessage = value : undefined;\n\t}\n\n\t/** @description Determines whether the content of the input will be selected on focus or not. Applicable to Prompt Window. */\n\t@Input()\n\tget selectAllOnFocus(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.selectAllOnFocus : undefined;\n\t}\n\tset selectAllOnFocus(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.selectAllOnFocus = value : undefined;\n\t}\n\n\t/** @description Sets or gets which tab is selected. Applicable only to TabsWindow. */\n\t@Input()\n\tget selectedIndex(): number | null {\n\t\treturn this.nativeElement ? this.nativeElement.selectedIndex : undefined;\n\t}\n\tset selectedIndex(value: number | null) {\n\t\tthis.nativeElement ? this.nativeElement.selectedIndex = value : undefined;\n\t}\n\n\t/** @description Determines the way the user can switch between tabs. Applicable only to TabsWindow. */\n\t@Input()\n\tget selectionMode(): TabSelectionMode {\n\t\treturn this.nativeElement ? this.nativeElement.selectionMode : undefined;\n\t}\n\tset selectionMode(value: TabSelectionMode) {\n\t\tthis.nativeElement ? this.nativeElement.selectionMode = value : undefined;\n\t}\n\n\t/** @description Indicates the index of the last character in the current selection. Applicable only to MultilinePromptWindow. */\n\t@Input()\n\tget selectionEnd(): number {\n\t\treturn this.nativeElement ? this.nativeElement.selectionEnd : undefined;\n\t}\n\tset selectionEnd(value: number) {\n\t\tthis.nativeElement ? this.nativeElement.selectionEnd = value : undefined;\n\t}\n\n\t/** @description Indicates the index to the first character in the current selection. Applicable only to MultilinePromptWindow. */\n\t@Input()\n\tget selectionStart(): number {\n\t\treturn this.nativeElement ? this.nativeElement.selectionStart : undefined;\n\t}\n\tset selectionStart(value: number) {\n\t\tthis.nativeElement ? this.nativeElement.selectionStart = value : undefined;\n\t}\n\n\t/** @description Enables/Disabled the label for the Progress Bar. Applicable only to Progress Window. */\n\t@Input()\n\tget showProgressValue(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.showProgressValue : undefined;\n\t}\n\tset showProgressValue(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.showProgressValue = value : undefined;\n\t}\n\n\t/** @description A getter that returns the siblings (that share the same parent) of a LayoutPanel item that is docked inside a DockingLayout. The siblings are also DockingLayout items ( LayoutPanels).Applicable only to TabsWindow when docked inside a DockingLayout. */\n\t@Input()\n\tget siblings(): any {\n\t\treturn this.nativeElement ? this.nativeElement.siblings : undefined;\n\t}\n\tset siblings(value: any) {\n\t\tthis.nativeElement ? this.nativeElement.siblings = value : undefined;\n\t}\n\n\t/** @description Applicable to TabsWindow when nested inside a DockingLayout Custom Element. Determines the size of the item. */\n\t@Input()\n\tget size(): string {\n\t\treturn this.nativeElement ? this.nativeElement.size : undefined;\n\t}\n\tset size(value: string) {\n\t\tthis.nativeElement ? this.nativeElement.size = value : undefined;\n\t}\n\n\t/** @description Specifies whether the element is to have its spelling and grammar checked or not. Applicable only to MultilinePromptWindow. */\n\t@Input()\n\tget spellCheck(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.spellCheck : undefined;\n\t}\n\tset spellCheck(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.spellCheck = value : undefined;\n\t}\n\n\t/** @description Sets or gets whether close buttons are displayed inside the Tab Strip of the TabsWindow. Applicable only to TabsWindow. */\n\t@Input()\n\tget tabCloseButtons(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.tabCloseButtons : undefined;\n\t}\n\tset tabCloseButtons(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.tabCloseButtons = value : undefined;\n\t}\n\n\t/** @description Determines if the close button is visible on select or always. Applicable only to TabsWindow. */\n\t@Input()\n\tget tabCloseButtonMode(): WindowTabCloseButtonMode {\n\t\treturn this.nativeElement ? this.nativeElement.tabCloseButtonMode : undefined;\n\t}\n\tset tabCloseButtonMode(value: WindowTabCloseButtonMode) {\n\t\tthis.nativeElement ? this.nativeElement.tabCloseButtonMode = value : undefined;\n\t}\n\n\t/** @description Sets or gets the Tabs scroll buttons behavior. Applicable only when tabLayout is 'scroll'. Applicable only to TabsWindow. */\n\t@Input()\n\tget tabOverflow(): Overflow {\n\t\treturn this.nativeElement ? this.nativeElement.tabOverflow : undefined;\n\t}\n\tset tabOverflow(value: Overflow) {\n\t\tthis.nativeElement ? this.nativeElement.tabOverflow = value : undefined;\n\t}\n\n\t/** @description Detetmines Tab Strip is positioned of the TabsWindow. Applicable only to TabsWindow. */\n\t@Input()\n\tget tabPosition(): TabPosition {\n\t\treturn this.nativeElement ? this.nativeElement.tabPosition : undefined;\n\t}\n\tset tabPosition(value: TabPosition) {\n\t\tthis.nativeElement ? this.nativeElement.tabPosition = value : undefined;\n\t}\n\n\t/** @description Sets or gets the position of the scroll buttons inside the Tab header of the TabsWindow. Applicable only to TabsWindow. */\n\t@Input()\n\tget tabScrollButtonsPosition(): LayoutPosition {\n\t\treturn this.nativeElement ? this.nativeElement.tabScrollButtonsPosition : undefined;\n\t}\n\tset tabScrollButtonsPosition(value: LayoutPosition) {\n\t\tthis.nativeElement ? this.nativeElement.tabScrollButtonsPosition = value : undefined;\n\t}\n\n\t/** @description Sets or gets the orientation of the text in the tabs labels of the TabsWindow. Applicable only to TabsWindow. */\n\t@Input()\n\tget tabTextOrientation(): Orientation {\n\t\treturn this.nativeElement ? this.nativeElement.tabTextOrientation : undefined;\n\t}\n\tset tabTextOrientation(value: Orientation) {\n\t\tthis.nativeElement ? this.nativeElement.tabTextOrientation = value : undefined;\n\t}\n\n\t/** @description Determines the theme. Theme defines the look of the element */\n\t@Input()\n\tget theme(): string {\n\t\treturn this.nativeElement ? this.nativeElement.theme : undefined;\n\t}\n\tset theme(value: string) {\n\t\tthis.nativeElement ? this.nativeElement.theme = value : undefined;\n\t}\n\n\t/** @description If is set to true, the element cannot be focused. */\n\t@Input()\n\tget unfocusable(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.unfocusable : undefined;\n\t}\n\tset unfocusable(value: boolean) {\n\t\tthis.nativeElement ? this.nativeElement.unfocusable = value : undefined;\n\t}\n\n\t/** @description Determines the value of the TextBox/ProgressBar inside the Dialog/Prompt/Progress Window */\n\t@Input()\n\tget value(): string | number {\n\t\treturn this.nativeElement ? this.nativeElement.value : undefined;\n\t}\n\tset value(value: string | number) {\n\t\tthis.nativeElement ? this.nativeElement.value = value : undefined;\n\t}\n\n\t/** @description Determines the actual parent of the element. The window can size and move only in the area of that element. */\n\t@Input()\n\tget windowParent(): any {\n\t\treturn this.nativeElement ? this.nativeElement.windowParent : undefined;\n\t}\n\tset windowParent(value: any) {\n\t\tthis.nativeElement ? this.nativeElement.windowParent = value : undefined;\n\t}\n\n\t/** @description Indicates how the input wraps text. Applicable only to MultilinePromptWindow. */\n\t@Input()\n\tget wrap(): WindowWrap {\n\t\treturn this.nativeElement ? this.nativeElement.wrap : undefined;\n\t}\n\tset wrap(value: WindowWrap) {\n\t\tthis.nativeElement ? this.nativeElement.wrap = value : undefined;\n\t}\n\n\t/** @description This event is triggered just before the window starts opening.\n\t*  @param event. The custom event. \t*/\n\t@Output() onOpening: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when the window is opened( visible ).\n\t*  @param event. The custom event. \t*/\n\t@Output() onOpen: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered just before the window starts closing.\n\t*  @param event. The custom event. \t*/\n\t@Output() onClosing: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when the window is closed( hidden )\n\t*  @param event. The custom event. \t*/\n\t@Output() onClose: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when the window is collapsed.\n\t*  @param event. The custom event. \t*/\n\t@Output() onCollapse: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when window's dragging is ended.\n\t*  @param event. The custom event. \t*/\n\t@Output() onDragEnd: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when window's dragging is started.\n\t*  @param event. The custom event. \t*/\n\t@Output() onDragStart: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when the window is expanded.\n\t*  @param event. The custom event. \t*/\n\t@Output() onExpand: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when the window is maximized.\n\t*  @param event. The custom event. \t*/\n\t@Output() onMaximize: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when the window is minimized.\n\t*  @param event. The custom event. \t*/\n\t@Output() onMinimize: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when window's resizing is ended.\n\t*  @param event. The custom event. \t*/\n\t@Output() onResizeEnd: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when window's resizing is started.\n\t*  @param event. The custom event. \t*/\n\t@Output() onResizeStart: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description This event is triggered when the window is restored to it's previous state before maximization.\n\t*  @param event. The custom event. \t*/\n\t@Output() onRestore: EventEmitter<CustomEvent> = new EventEmitter();\n\n\t/** @description Appends a tabitem to the end of the list of tab items inside element. \n\t* @param {Node} node. A TabItem element that should be added to the rest of the items as the last item.\n\t* @returns {Node}\n  */\n\tpublic async appendChild(node): Promise<any> {\n\t\tconst getResultOnRender = () => {\n            return new Promise(resolve => {\n                this.nativeElement.whenRendered(() => {\n                    const result = this.nativeElement.appendChild(node);\n                    resolve(result)\n                });\n            });\n        };\n        const result = await getResultOnRender();\n\n        return result;\n    }\n\n\t/** @description Sets the window to the top level so the user can interact with it. \n\t*/\n    public bringToFront(): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.bringToFront();\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.bringToFront();\n            });\n        }\n    }\n\n\t/** @description Clears the content of the Window. \n\t*/\n    public clear(): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.clear();\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.clear();\n            });\n        }\n    }\n\n\t/** @description Closes the window. \n\t*/\n    public close(): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.close();\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.close();\n            });\n        }\n    }\n\n\t/** @description Collapses the window. \n\t* @returns {HTMLElement}\n  */\n\tpublic async collapse(): Promise<any> {\n\t\tconst getResultOnRender = () => {\n            return new Promise(resolve => {\n                this.nativeElement.whenRendered(() => {\n                    const result = this.nativeElement.collapse();\n                    resolve(result)\n                });\n            });\n        };\n        const result = await getResultOnRender();\n\n        return result;\n    }\n\n\t/** @description Makes sure a tab item is visible by scrolling to it. Applicable only to TabsWindow. \n\t* @param {number} index. The index of the tab to scroll to.\n\t*/\n    public ensureVisible(index: number): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.ensureVisible(index);\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.ensureVisible(index);\n            });\n        }\n    }\n\n\t/** @description Expands the window after being collapsed. \n\t* @returns {any[]}\n  */\n\tpublic async expand(): Promise<any> {\n\t\tconst getResultOnRender = () => {\n            return new Promise(resolve => {\n                this.nativeElement.whenRendered(() => {\n                    const result = this.nativeElement.expand();\n                    resolve(result)\n                });\n            });\n        };\n        const result = await getResultOnRender();\n\n        return result;\n    }\n\n\t/** @description Inserts a new tab and an associated content section. Applicable only to TabsWindow. \n\t* @param {number} index. The index to insert a new tab at.\n\t* @param {any} details. An Object with the fields \"label\", \"labelSize\", \"content\" and \"group\".\n\t*/\n    public insert(index: number, details: any): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.insert(index, details);\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.insert(index, details);\n            });\n        }\n    }\n\n\t/** @description Inserts the specified \"smart-tab-item\" node before the reference \"smart-tab-item\" node. Applicable only to TabsWindow. \n\t* @param {Node} newNode. The \"smart-tab-item\" node to insert.\n\t* @param {Node | null} referenceNode?. The \"smart-tab-item\" node before which newNode is inserted.\n\t* @returns {Node}\n  */\n\tpublic async insertBefore(newNode, referenceNode?): Promise<any> {\n\t\tconst getResultOnRender = () => {\n            return new Promise(resolve => {\n                this.nativeElement.whenRendered(() => {\n                    const result = this.nativeElement.insertBefore(newNode, referenceNode);\n                    resolve(result)\n                });\n            });\n        };\n        const result = await getResultOnRender();\n\n        return result;\n    }\n\n\t/** @description Removes a tab and its associated content section. Applicable only to TabsWindow. \n\t* @param {number} index. The index of the tab to remove.\n\t*/\n    public removeAt(index: number): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.removeAt(index);\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.removeAt(index);\n            });\n        }\n    }\n\n\t/** @description Removes a child \"smart-tab-item\" node. Applicable only to TabsWindow. \n\t* @param {Node} node. The \"smart-tab-item\" node to remove.\n\t* @returns {Node}\n  */\n\tpublic async removeChild(node): Promise<any> {\n\t\tconst getResultOnRender = () => {\n            return new Promise(resolve => {\n                this.nativeElement.whenRendered(() => {\n                    const result = this.nativeElement.removeChild(node);\n                    resolve(result)\n                });\n            });\n        };\n        const result = await getResultOnRender();\n\n        return result;\n    }\n\n\t/** @description Maximizes the window to fill the area. \n\t*/\n    public maximize(): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.maximize();\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.maximize();\n            });\n        }\n    }\n\n\t/** @description Minimizes the window. \n\t*/\n    public minimize(): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.minimize();\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.minimize();\n            });\n        }\n    }\n\n\t/** @description Opens the window \n\t*/\n    public open(): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.open();\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.open();\n            });\n        }\n    }\n\n\t/** @description Pins the window. Disables window dragging. \n\t*/\n    public pin(): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.pin();\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.pin();\n            });\n        }\n    }\n\n\t/** @description Restores the window to it's previous size before maximization/minimization. \n\t*/\n    public restore(): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.restore();\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.restore();\n            });\n        }\n    }\n\n\t/** @description Selects a tab.  Applicalbe only to TabsWindow elements. \n\t* @param {number} index. The index of the tab to select.\n\t*/\n    public select(index: number): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.select(index);\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.select(index);\n            });\n        }\n    }\n\n\t/** @description Unpins the window. Enables window dragging. \n\t*/\n    public unpin(): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.unpin();\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.unpin();\n            });\n        }\n    }\n\n\t/** @description Updates a tab and its associated content section.  Applicalbe only to TabsWindow elements. \n\t* @param {number} index. The index of the tab to update.\n\t* @param {string} label. The new label of the tab. The value can be the id of an HTMLTemplateElement\n\t* @param {string | HTMLElement} content. The new content of the tab.\n\t*/\n    public update(index: number, label: string, content: string | HTMLElement): void {\n        if (this.nativeElement.isRendered) {\n            this.nativeElement.update(index, label, content);\n        }\n        else\n        {\n            this.nativeElement.whenRendered(() => {\n                this.nativeElement.update(index, label, content);\n            });\n        }\n    }\n\n\n\tget isRendered(): boolean {\n\t\treturn this.nativeElement ? this.nativeElement.isRendered : false;\n\t}\n\n\tngOnInit() {\n\t}\n\n    ngAfterViewInit() {\n      const that = this;\n\n      that.onCreate.emit(that.nativeElement);\n\n\t\tSmart.Render();\n\n\t\tthis.nativeElement.classList.add('smart-angular');\n\n\t\tthis.nativeElement.whenRendered(() => { that.onReady.emit(that.nativeElement); });\n\t\tthis.listen();\n\t}\n\n\tngOnDestroy() {\n\t\tthis.unlisten();\n\t}\n\n\tngOnChanges(changes: SimpleChanges) {\n\t\tif (this.nativeElement && this.nativeElement.isRendered) {\n\t\t\tfor (const propName in changes) {\n\t\t\t\tif (changes.hasOwnProperty(propName)) {\n\t\t\t\t\tthis.nativeElement[propName] = changes[propName].currentValue;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t/** @description Add event listeners. */\n\tprivate listen(): void {\n        const that = this;\n\t\tthat.eventHandlers['openingHandler'] = (event: CustomEvent) => { that.onOpening.emit(event); }\n\t\tthat.nativeElement.addEventListener('opening', that.eventHandlers['openingHandler']);\n\n\t\tthat.eventHandlers['openHandler'] = (event: CustomEvent) => { that.onOpen.emit(event); }\n\t\tthat.nativeElement.addEventListener('open', that.eventHandlers['openHandler']);\n\n\t\tthat.eventHandlers['closingHandler'] = (event: CustomEvent) => { that.onClosing.emit(event); }\n\t\tthat.nativeElement.addEventListener('closing', that.eventHandlers['closingHandler']);\n\n\t\tthat.eventHandlers['closeHandler'] = (event: CustomEvent) => { that.onClose.emit(event); }\n\t\tthat.nativeElement.addEventListener('close', that.eventHandlers['closeHandler']);\n\n\t\tthat.eventHandlers['collapseHandler'] = (event: CustomEvent) => { that.onCollapse.emit(event); }\n\t\tthat.nativeElement.addEventListener('collapse', that.eventHandlers['collapseHandler']);\n\n\t\tthat.eventHandlers['dragEndHandler'] = (event: CustomEvent) => { that.onDragEnd.emit(event); }\n\t\tthat.nativeElement.addEventListener('dragEnd', that.eventHandlers['dragEndHandler']);\n\n\t\tthat.eventHandlers['dragStartHandler'] = (event: CustomEvent) => { that.onDragStart.emit(event); }\n\t\tthat.nativeElement.addEventListener('dragStart', that.eventHandlers['dragStartHandler']);\n\n\t\tthat.eventHandlers['expandHandler'] = (event: CustomEvent) => { that.onExpand.emit(event); }\n\t\tthat.nativeElement.addEventListener('expand', that.eventHandlers['expandHandler']);\n\n\t\tthat.eventHandlers['maximizeHandler'] = (event: CustomEvent) => { that.onMaximize.emit(event); }\n\t\tthat.nativeElement.addEventListener('maximize', that.eventHandlers['maximizeHandler']);\n\n\t\tthat.eventHandlers['minimizeHandler'] = (event: CustomEvent) => { that.onMinimize.emit(event); }\n\t\tthat.nativeElement.addEventListener('minimize', that.eventHandlers['minimizeHandler']);\n\n\t\tthat.eventHandlers['resizeEndHandler'] = (event: CustomEvent) => { that.onResizeEnd.emit(event); }\n\t\tthat.nativeElement.addEventListener('resizeEnd', that.eventHandlers['resizeEndHandler']);\n\n\t\tthat.eventHandlers['resizeStartHandler'] = (event: CustomEvent) => { that.onResizeStart.emit(event); }\n\t\tthat.nativeElement.addEventListener('resizeStart', that.eventHandlers['resizeStartHandler']);\n\n\t\tthat.eventHandlers['restoreHandler'] = (event: CustomEvent) => { that.onRestore.emit(event); }\n\t\tthat.nativeElement.addEventListener('restore', that.eventHandlers['restoreHandler']);\n\n\t}\n\n\t/** @description Remove event listeners. */\n\tprivate unlisten(): void {\n        const that = this;\n\t\tif (that.eventHandlers['openingHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('opening', that.eventHandlers['openingHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['openHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('open', that.eventHandlers['openHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['closingHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('closing', that.eventHandlers['closingHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['closeHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('close', that.eventHandlers['closeHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['collapseHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('collapse', that.eventHandlers['collapseHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['dragEndHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('dragEnd', that.eventHandlers['dragEndHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['dragStartHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('dragStart', that.eventHandlers['dragStartHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['expandHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('expand', that.eventHandlers['expandHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['maximizeHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('maximize', that.eventHandlers['maximizeHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['minimizeHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('minimize', that.eventHandlers['minimizeHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['resizeEndHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('resizeEnd', that.eventHandlers['resizeEndHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['resizeStartHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('resizeStart', that.eventHandlers['resizeStartHandler']);\n\t\t}\n\n\t\tif (that.eventHandlers['restoreHandler']) {\n\t\t\tthat.nativeElement.removeEventListener('restore', that.eventHandlers['restoreHandler']);\n\t\t}\n\n\t}\n}\n"]}