@smart-webcomponents-angular/window 22.0.3 → 24.0.16

package/fesm2015/smart-webcomponents-angular-window.mjs

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