swing-ui 0.1.25 → 1.0.3

package/types/classes/UIComponent.d.ts

@@ -0,0 +1,966 @@
+/**
+ * Base component class that other UI components extend. Not to be instantiated by itself.
+ * Most methods in this class are used by other classes that extend this class.
+ * @class
+ * @global
+ */
+export class UIComponent {
+    static "__#1@#controls_id": number;
+    static "__#1@#_freed_ids": any[];
+    static "__#1@#_components": any[];
+    /**
+     * This is used to be notified when the component loses all references to it, to notify SwingUI to destroy the component for garbage collection
+     * @private
+     */
+    private static "__#1@#refRegistry";
+    /**
+     * Makes one class implements methods, setters, and getters of another class.
+     * @param toClass
+     * @param fromClass
+     * @throws {Error} When one or more parameters are `null`.
+     * @internal
+     * @ignore
+     */
+    static implementClass(toClass: any, fromClass: any): void;
+    /**
+     * Removes references to UI component with provided ID. Make sure to destroy  all other references to the component to truly destroy it to free RAM.
+     *
+     * @internal
+     * @ignore
+     * @private
+     * @param {number} id - ID of a component to be destroyed
+     * @return {void} Doesn't return a value
+     */
+    private static destroy;
+    /**
+     * Get UI component by ID.
+     *
+     * @param {number} id - ID of requested component
+     * @return {any|undefined} Returns UI component or `undefined` if there is no valid component with specified ID.
+     */
+    static get(id: number): any | undefined;
+    /**
+     * Returns last visible non-PopUp Window or null if no Window component is not found.
+     *
+     * @internal
+     * @static
+     * @readonly
+     * @returns {Window|null} Returns Window component or null.
+     */
+    static readonly getVisibleWindow(): Window | null;
+    /**
+     * Not to be instantiated by itself. This call is extended dby other UI components.
+     *
+     * @param {string} type - Component type.
+     * @param {boolean} leaf - `true` if the UI component was not extended by a custom class.
+     * @param {...any} [data] - Additional component init data (used by some UI components).
+     * @internal
+     * @ignore
+     */
+    constructor(type: string, leaf: boolean, ...data?: any[]);
+    parent_id: null;
+    callback: {
+        onError: ((e: any) => any)[];
+        onRectangleUpdate: ((e: any) => void)[];
+    };
+    /**
+     * Locks methods from being overwritten or deleted.
+     * @param {Function} prototype_class
+     * @ignore
+     * @internal
+     */
+    finalize(..._classes: any[]): void;
+    /**
+     * @internal
+     * @ignore
+     */
+    isFinalized(methodName: any): boolean;
+    /**
+     * @internal
+     * @readonly
+     * @ignore
+     * @type {object}
+     */
+    readonly get prop(): object;
+    /**
+     * Returns a unique ID of the component. ID is reusable, so one component may have an ID of a previously destroyed component.
+     * @readonly
+     * @type {number}
+     */
+    readonly get id(): number;
+    /**
+     * Gets a parent container component. If this component wasn't added to any container component, then `null` is returned.
+     * @readonly
+     * @type {UIComponent|null}
+     */
+    readonly get parent(): UIComponent | null;
+    /**
+     * Gets a previous sibling component. If this component wasn't added to any container component, then `null` is returned.
+     * @readonly
+     * @type {UIComponent|null}
+     * @since 1.0.2
+     */
+    readonly get previousSibling(): UIComponent | null;
+    /**
+     * Gets a next sibling component. If this component wasn't added to any container component, then `null` is returned.
+     * @readonly
+     * @type {UIComponent|null}
+     * @since 1.0.2
+     */
+    readonly get nextSibling(): UIComponent | null;
+    /**
+     * Gets an array of sibling components.
+     * @readonly
+     * @type {UIComponent[]}
+     * @since 1.0.2
+     */
+    readonly get siblings(): UIComponent[];
+    /**
+     * Gets a Window component containing this component. Returns `null` if no Window contain this component.
+     * @readonly
+     * @type {Window|null}
+     */
+    readonly get window(): Window | null;
+    /**
+     *  Returns `true` if the component is a container (other components can be added to it), otherwise returns false.
+     *  @readonly
+     *  @type {boolean}
+     */
+    readonly get isContainer(): boolean;
+    /**
+     * Gets a position of this component relative to primary screen. Returns `null` if the component wasn't added to a container that is visible, or of this component is a Window and it was never visible.
+     *
+     * @readonly
+     * @type {Point|null}
+     * @see Point
+     * @see ui#screens
+     */
+    readonly get screenPosition(): Point | null;
+    /**
+     * Adds this component to a parent container component. An optional index specifies the Z-order position at which to insert the component. It calls {@link ComponentContainer#addChild}.
+     *
+     * @param {ComponentContainer} parent - The container component to which this component will be added.
+     * @param {number|object} [data_or_index] - An parameter to pass some extra data (such as Tab Name to add Panel to Tabs), or index at which to insert the child.
+     * @returns {this} Returns an instance of this component for chaining.
+     * @see ComponentContainer#addChild
+     * @example <h2>Adding a component at specified index</h2>
+     * let checkbox = new CheckBox("Enabled checkbox").addTo(panel, 5).position(10, 15); // adds to panel and positions at (10,15) coordinates
+     *
+     * @example <h2>Adding a component at specified index</h2>
+     * let panel = new Panel().addTo(tabs, {text: "Registration", enabled: true, tooltip: "Create new account", icon: "images/user.png"});
+     */
+    addTo(parent: ComponentContainer, ...args: any[]): this;
+    /**
+     * Removes this component from its parent.
+     *
+     * @param {boolean} [recursive] - Boolean indicates if all descendents of this child should also be removed.
+     * @returns {this} Returns this component for method chaining
+     * @example
+     * child.remove(); // Removes child from it's parent container
+     * child.remove(true); // Removes child component from it's parent and all its descendants recursively
+     */
+    remove(...args: any[]): this;
+    /**
+     * Removes the component from its container, destroys event callbacks, unregisters the component, recycles the component ID. Also prepares this component to be garbage-collected in JavaScript and GUI to free RAM.
+     *
+     * @param {boolean} [recursive=false] - Set to true to also destroy all of its descendants recursively
+     * @returns {void}
+     */
+    destroy(...args: any[]): void;
+    destroyed: boolean | undefined;
+    /**
+     * This function may be called to make sure the component wasn't destroyed yet before performing another operation with the component. If it's already destroyed, Exception is thrown.
+     *
+     * @return {this} Returns this component.
+     */
+    verifyComponent(): this;
+    /**
+     * Checks if this component is inside specified ancestor component (at any level, not just direct child).
+     * @param {Object} ancestor - Ancestor component to test against
+     * @return {boolean}
+     * @see ComponentContainer#contains
+     */
+    insideOf(ancestor: Object): boolean;
+    /**
+     * Sets or gets component's visibility.
+     * NOTE: Window and InternalWindow components visibility is set to `false` by default. Use .visible(true) or .show() to make it visible.
+     *
+     * @param {boolean} [visible] - `true` to make it visible, `false` to hide it.
+     * @return {boolean|this} If called with an argument, then `this` component instance is returned, otherwise `boolean` value is returned.
+     */
+    visible(...args: any[]): boolean | this;
+    /**
+     * Convenience function that calls this.visible(true)
+     * @return {this}
+     */
+    show(): this;
+    /**
+     * Convenience function that calls this.visible(false)
+     * @return {this}
+     */
+    hide(): this;
+    /**
+     * Enables or disables the component.
+     *
+     * @param {boolean} [enabled] `true` to enable, `false` to disable the component. Omit to get current value.
+     * @return {boolean|this} If called with an argument, then `this` component instance is returned, otherwise `boolean` value is returned.
+     */
+    enabled(...args: any[]): boolean | this;
+    /**
+     * Sets or gets the size of the component.
+     *
+     * For {@link Window}, the returned and assigned size represents the entire window, including the title bar and borders. The actual area available for placing child components is smaller. Use {@link Window#innerSize} when you need to specify the content area size instead.
+     *
+     * @param {number|Size} [width_or_size] - Number as width, or `Size` formatted object.
+     * @param {number} [height] - Height of component. Required if first argument is `number`.
+     * @return {Size|this} Component size object if no arguments are set, otherwise returns `this` component.
+     * @see Size
+     * @example
+     * // Usage examples:
+     * button.size(100, 25);
+     * button.size({width: 100, height: 25});
+     * let size = button.size();
+     */
+    size(...args: any[]): Size | this;
+    /**
+     * Convenience method to set or get the width of component.
+     *
+     * @param {number} [width] - New width of the component.
+     * @return {number|UIComponent} Returns width if no argument is set, otherwise returns `this` component.
+     * @see UIComponent#size
+     */
+    width(...args: any[]): number | UIComponent;
+    /**
+     * Convenience method to set or get the height of component.
+     *
+     * @param {number} [height] - New height of the component.
+     * @return {number|UIComponent} Returns height if no argument is set, otherwise returns `this` component.
+     * @see UIComponent#size
+     */
+    height(...args: any[]): number | UIComponent;
+    /**
+     * Sets or gets text content of the component. Even though some components don't show text, you can still set text to it.
+     *
+     * @param {string} [text=undefined] - Can be plain text or HTML. HTML is only supported in some components (e.g. Label, Button, TextDocument, ...) and should be surrounded with HTML tags. Check example below.
+     * @param {TextAction} [action=TextAction.Set] - Specific action to perform with text. Replace, append, prepend, or insert. Applies only to some components. Do not use this argument for HTML content.
+     * @param {number} [insert_position=undefined] - Position where to insert text. Applies only if `action` argument is TextAction.Insert.
+     * @return {string|this} Returns text value if no argument is set, otherwise returns `this` component.
+     * @example
+     * const txt = textfield.text(); // gets text value
+     * textfield.text("New Text"); // sets new text value
+     * textfield.text("Appended Text", TextAction.Append); // Appends new text to the end of current text
+     * textfield.text("Inserted Text", TextAction.Insert); // Inserts at current caret position
+     * textfield.text("Inserted Text", TextAction.Insert, textfield.caretPosition() - 50); // Inserts at specified position
+     * textfield.text("New Text", TextAction.ReplaceSelection); // Replaces selected text or inserts at current cursor position if no text is selected (applies only to text editing components, like TextField, TextArea, ...).
+     */
+    text(...args: any[]): string | this;
+    /**
+     * @internal
+     * @ignore
+     * @private
+     * @param {string} property
+     * @param {any} value
+     * @return {any}
+     */
+    private property;
+    /**
+     * Registers, unregisters, and gets an event handler callback function for a specified events.
+     *
+     *  - component.event(name, function, true); // unregisters one callback function (even if the same callback was registered multiple times)
+     *  - component.event(name, function); // registers callback to be called when the event is emitted
+     *  - component.event(name); // returns all callback functions for specified event
+     *
+     * @param {string} name - Name of event
+     * @param {function(Object):any|null} [callback=undefined] - Callback function. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to true to unregister the callback function.
+     * @return {Function[]|this} If only the `name` argument is provided, returns an array of registered callback functions. Otherwise, returns `this` component.
+     * @internal
+     * @ignore
+     * @private
+     * @example
+     * const _callbacks_array = button.event("onAction"); // gets an array of previously registered handler functions
+     * button.event("onAction", _callbacks_array[0], true); // unregisters callback function, same as button.onAction(_callbacks_array[0], true);
+     * button.event("onAction", e => {console.debug(e);}); // registers new event handler function, same as button.onAction(e => {console.debug(e);});
+     */
+    private event;
+    /**
+     * Sets or gets the background color of the component. <br />
+     * <br />
+     * Accepts three formats: <br />
+     * - RGB hex (e.g. `"#FF0000"`) <br />
+     * - RGBA hex with alpha (e.g. `"#FF000050"`) <br />
+     * - The string `"transparent"` (equivalent to `"#00000000"`)
+     *
+     * @param {string} [value] - Background color in supported formats. Panel and Window components also accept gradient, image position and other info like in CSS. If omitted, returns the current value.
+     * @param {boolean} [update] - For Panel or Window only. Specifies whether to update specified background attributes instead of replacing all previously set background attributes.
+     * @returns {this|string} Returns `this` when setting value, or the current background color string when getting.
+     *
+     * @example
+     * component.background("#FF0000");         // Red background
+     * component.background("#00FF0080");       // Semi-transparent green
+     * component.background("transparent");     // Fully transparent
+     *
+     * // For Panel and Window components the background value can be a string that contains a mixture of background color,
+     * // image, linear-gradient, radial-gradient, like in CSS in web browsers. Some features may not be supported though.
+     * panel.background("#FF000055 url(images/bg.png) center no-repeat opacity=0.6 10px 15px linear-gradient(#DDDDDD55, #F8F8F855 10%) / auto);
+     * panel.background("url(data:image/png;base64,As8fE4fdt1r.....)", true); // supports base64 encoded image string
+     */
+    background(...args: any[]): this | string;
+    /**
+     * Sets or gets a foreground color of component (usually text color).
+     *
+     * @param {string} value Three formats are acceptable, regular RGB "#FF0000", with alpha RGBA "#FF000050", and "transparent" string, which is equivalent to "#00000000".
+     * @return {string|this} Returns color value if no argument is set, otherwise returns `this` component.
+     */
+    color(...args: any[]): string | this;
+    /**
+     * Sets or gets the position of the component relative to its parent component's top-let corner (or to the screen's top-left corner when component is Window).
+     *
+     * @param {number|Point} [x_or_position] - X position. Alternatively, provide a single `Point` object parameter to specify the position.
+     * @param {number} [y] - Y position.
+     * @param {number} [right] - Resizes the component so that its right edge is this many pixels from the right edge of the parent component or screen.
+     * @param {number} [bottom] - Resizes the component so that its bottom edge is this many pixels from the bottom edge of the parent component or screen.
+     * @return {Point|this} If no arguments are provided, returns a {x: number, y: number} position object. Otherwise, returns `this` component.
+     * @see Point
+     * @example
+     * panel.size(50, 100); // sets position
+     * panel.size({x: 50, y: 100}); // sets position
+     * panel.size(50, 100, 20); // sets position of left, top and right sides relative to sides of parent component.
+     * const window = new Window("New Window").size(50, 100, 20, 20); // sets position of each side relative to sides of screen.
+     */
+    position(...args: any[]): Point | this;
+    /**
+     * Convenience method to set or get left position of component.
+     *
+     * @param {number} [value]
+     * @return {number} Returns left position if no argument is set, otherwise returns `this` component.
+     * @see UIComponent#position
+     */
+    x(...args: any[]): number;
+    /**
+     * Convenience method to set or get top position of component.
+     *
+     * @param {number} [value]
+     * @return {number} Returns top position if no argument is set, otherwise returns `this` component.
+     * @see UIComponent#position
+     */
+    y(...args: any[]): number;
+    /**
+     * Convenience method to get or set the distance between the right edge of this component and the right edge of its parent.
+     *
+     * @param {number} [value] - Distance from the parent's right edge.
+     * @param {boolean} [reize] - `True` to resize the width to accommodate for specified `right` position instead of moving the object. `false` to move the component.
+     * @return {number|this} Returns the current right distance if no argument is provided; otherwise, returns `this` component.
+     */
+    right(...args: any[]): number | this;
+    /**
+     * Convenience method to get or set the distance between the bottom edge of this component and the bottom edge of its parent.
+     *
+     * @param {number} [value] - Distance from the parent's bottom edge to this component's bottom edge.
+     * @param {boolean} [reize] - `True` to resize the height to accommodate for specified `bottom` position instead of moving the object. `false` to move the component.
+     * @return {number|this} Returns the current bottom distance if no argument is provided; otherwise, returns `this` component.
+     */
+    bottom(...args: any[]): number | this;
+    /**
+     * Moves the component by adding the specified x and y values to its current position.
+     * The function shifts the element's position relative to current position.
+     *
+     * @param {number} [dx=0] - Delta x (can be positive or negative number)
+     * @param {number} [dy=0] - Delta y (can be positive or negative number)
+     * @return {this} Returns `this` component.
+     */
+    move(dx?: number, dy?: number): this;
+    /**
+     * When called without arguments and repainting is not disabled, it flushes message queue, revalidates and repaints the component.
+     * When the first argument is `true`, it enables repainting (enabled by default) and flushes the message queue.
+     * When the first argument is `false`, it disables repainting.
+     *
+     * @param {boolean} repaint_enabled - `false` to pause repainting this element. `true` to resume repainting
+     * @return {this} Returns `this` component.
+     */
+    update(...args: any[]): this;
+    /**
+     * Sets or gets context menu component for this UI component.
+     *
+     * @param {ContextMenu} [menu] - ContextMenu component to be assigned to this component. Set to `null` to remove ContextMenu.
+     * @return {ContextMenu|null|this} Returns the current context menu if no argument is provided; otherwise, returns `this` component.
+     */
+    contextMenu(...args: any[]): ContextMenu | null | this;
+    /**
+     * Sets or gets component `focusable` property whether component can retain focus.
+     *
+     * @param {boolean} [value]
+     * @return {boolean|this} If called with an argument, then `this` component instance is returned, otherwise `boolean` value is returned.
+     */
+    focusable(...args: any[]): boolean | this;
+    /**
+     * If value is passed, it makes component to get or loose focus, otherwise returns `boolean` indicating if it has focus or not.
+     *
+     * @param {boolean} [value] - `true` to get focus, `false` to attempt to shift focus to next component (if it has focus), usually by switching focus to next component.
+     * @returns {boolean|this} If called with an argument, then `this` component instance is returned, otherwise `boolean` value is returned.
+     */
+    focused(...args: any[]): boolean | this;
+    /**
+     * Sets or gets an index (z-order) of this component if it is added to a container, otherwise returns null.
+     * Larger value brings component forward, smaller to the back, like z-index in CSS.
+     *
+     * @param {number} [index]
+     * @returns {this|null|number} If called with an argument, then `this` component instance is returned, if component has no parent then `null` is returned, otherwise index is returned.
+     */
+    index(...args: any[]): this | null | number;
+    /**
+     * Sets or gets a layer at which this component resides in Panel container. This is separate from z-index.
+     * This applies only to components that are added to Panel or Window components.
+     * For example components in layer 2 are always on top of components in layer 1, regardless on their z-index.
+     * Larger value brings component forward, smaller to the back, like width z-index.
+     *
+     * @param {number} layer_index
+     * @returns {number|this} If called with an argument, then `this` component instance is returned, otherwise `number` value is returned.
+     */
+    layer(...args: any[]): number | this;
+    /**
+     * Gets or sets the font used for the component's text. See the example for font object format.
+     *
+     * @param {Font} [font] - Font formatted object.
+     * @param {boolean} [update] - If `true`, only the specified font properties will be updated instead of replacing the entire font.
+     * @return {this|Font}
+     * @see Font
+     * @example <h2>Full list of supported font properties:</h2>
+     * Font {
+     *     name: string,           // Font name or family name from {@link FontFamily} enum (e.g., "sans-serif")
+     *     size: number,           // Font size in pixels
+     *     bold: boolean,          // Whether the text is bold
+     *     italic: boolean,        // Whether the text is italic
+     *     underlined: boolean,    // Whether the text is underlined
+     *     strikethrough: boolean, // Whether the text has a strikethrough
+     *     direction: string,      // Text direction: "ltr" or "rtl"
+     *     kerning: boolean,       // Enable or disable kerning
+     *     ligatures: boolean,     // Enable or disable font ligatures
+     *     tracking: number        // Letter spacing adjustment: -1, 0 (default), or 1
+     * };
+     * @example <h2>Usage examples:</h2>
+     * // Sets new font
+     * textarea.font({name: "sans-serif", size: 14, italic: true});
+     *
+     * // Set a new font; previously set italic style will be removed
+     * textarea.font({name: "sans-serif", size: 14});
+     *
+     * // Update only the font size, preserving other properties
+     * textarea.font({size: 20}, true);
+     *
+     * // get component's font
+     * const font = textarea.font();
+     * @see Font
+     * @see FontFamily
+     */
+    font(...args: any[]): this | Font;
+    /**
+     * Sets or gets an icon image of this component. You can set icon to any component even though not all components display the icon.
+     * When a component is added to Tabs, that component's icon is used as a Tab icon by default.
+     * Following image types are supported: ICO, PNG, JPG, JPEG, GIF, BMP, WBMP, TIFF/TIF, and base64 encoded images of such types.
+     * If FFMPEG with support of these image types is installed, the following image types are also supported from local relative or absolute paths: WEBP, HEIC, HEIF, AVIF.
+     *
+     * @param {string|null} image_path - Relative or absolute path to image file, base64 encoded image string, or NULL to remove existing icon.
+     * @returns {this|string|null} Returns `this` component if no arguments are set, a string of a previously set icon, or `null` if icon hasn't been set.
+     */
+    icon(...args: any[]): this | string | null;
+    /**
+     * Sets an cursor to the control. Passing NULL value removes custom cursor.
+     *
+     * @param {number|null|string} cursor - A value from Cursor enum, or a relative path to image file for custom cursor icon.
+     * @param {number} x - Used with custom image cursor to set pointer point on the image.
+     * @param {number} y - Used with custom image cursor to set pointer point on the image.
+     * @returns {this} Returns `this` component.
+     */
+    cursor(cursor: number | null | string, ...point: any[]): this;
+    /**
+     * Sets or gets the drag action for this component (e.g., `Copy`, `Move`), and enables or disables dragging accordingly.
+     * Passing `None` disables dragging; all other values enable it.
+     *
+     * @param {DragDropAction} [action] - One of enum values: DragDropAction.[None|Copy|Move|CopyOrMove|Link]. `None` is default.
+     * @returns {string|this} Returns `this` component if argument is provided, otherwise returns `string` value as one of the DragDropAction enum values.
+     */
+    dragAction(...args: any[]): string | this;
+    /**
+     * Sets or gets which type of drop action is accepted by the component (e.g., `Copy`, `Move`). Setting any action other
+     * than `None` enables dropping on the component. Action `None` disables dropping.
+     *
+     * @param {DragDropAction} [action] - One of enum values: DragDropAction.[None|Copy|Move|CopyOrMove|Link]. `None` is default.
+     * @returns {string|this} Returns `this` component if argument is provided, otherwise returns `string` value as one of the DragDropAction enum values.
+     */
+    dropAction(...args: any[]): string | this;
+    /**
+     * Sets or gets the types of data that should be transffered during drag operation. The data itself can be set using dragData(...) method.
+     * More than one type can be specified by setting multiple arguments or passing an array of values.
+     *
+     * @param {...DataType|DataType[]} data_type - DataType.[None|Text|Image|...]
+     * @returns {string[]|this}
+     * @example
+     * // Usage examples:
+     * label.dragDataType(DataType.Text, DataType.HTML); // setting by multiple arguments
+     * label.dragDataType([DataType.Text, DataType.HTML]); // setting by an array of values
+     * const _types = label.dragDataType(); // getting an array of data types
+     */
+    dragDataType(...args: any[]): string[] | this;
+    /**
+     * Sets custom data that should be passed when dragging this component instead of passing component's data, such as text or icon.
+     * Without setting this data a default component data will be dragged, such as text, list item, icon, what what ever applies to this component.
+     *
+     * @arg {string|string[]} data - String data or array of strings. For a list of files or URLs use array or separate them by new line character \n.
+     * @return {this} Returns `this` component.
+     */
+    dragData(...args: any[]): this;
+    /**
+     * Sets acceptable data types that may be dropped on this component during drag and drop operation.
+     *
+     * @param {...DataType|DataType[]} data_type - DataType.[None|All|Text|Image|...]. Use `All` to accept all data types.
+     * @return {string[]|this} Returns `this` component is argument is provided, otherwise returns `string[]` value.
+     * @example
+     * // Usage examples:
+     * label.dropDataType(DataType.All); // Setting to accept all data types
+     * label.dropDataType(.DataType.Text, DataType.HTML); // setting by multiple arguments
+     * label.dropDataType([DataType.Text, DataType.HTML]); // setting by an array of values
+     * const _types = label.dropDataType(); // getting an array of data types
+     */
+    dropDataType(...args: any[]): string[] | this;
+    /**
+     * Sets a drop mode for components: Table, List, Tree.
+     *
+     * @param {DropMode} [mode] - Enum value: DropMode.[On|Insert|OnOrInsert]. On - allows data to be dropped on list items. Insert - allows to drop data between list items.
+     * @returns {DropMode|this} Returns `this` component if an argument is provided; otherwise, returns the current drop mode as one of the DropMode enum values.
+     * @see DropMode
+     */
+    dropMode(...args: any[]): DropMode | this;
+    /**
+     * Sets, updates, or gets component border object. Border object should contain only properties that you want to set or update.
+     *
+     * @param {Border} [border] - Border object.
+     * @param {boolean} [update] - Set to `true` to only change specified border properties instead of replacing existing border.
+     * @return {this|Border|null} - If called without arguments a `Border` object is returned or `null` if the component's border wasn't set. Otherwise and instance of the component is returned.
+     * @see UIComponent#border
+     */
+    border(...args: any[]): this | Border | null;
+    /**
+     * Sets or gets an alignment of icon relative to text of a Label, Button, or items of a List.
+     *
+     * @param {string} [alignment] - A combination of one or more words: "top right bottom left center leading trailing"
+     * @return {this|string} Returns `this` component if an argument is provided, otherwise returns `string` value.
+     */
+    iconAlignment(...args: any[]): this | string;
+    /**
+     * Sets or gets an alignment of the component's content relative to the component, such as Label, Button, CheckBox, RadioBox, or items of a List.
+     *
+     * @param {string} [alignment] - A combination of one or more words: "top bottom right left center leading trailing"
+     * @return {this|string} Returns `this` component if an argument is provided, otherwise returns `string` value.
+     */
+    alignment(...args: any[]): this | string;
+    /**
+     * Sets or get a gap in pixel between icon and text of a List item, Button, Label, ComboBox, CheckBox, and RadioBox.
+     *
+     * @param {number} [gap] - The gap in pixels (must be an integer ≥ 0). If omitted, returns the current gap.
+     * @return {this|number} Returns `number` if argument is omitted, otherwise returns `this` component instance.
+     */
+    iconTextGap(...args: any[]): this | number;
+    /**
+     * Captures an image of the component and all subcomponents. Returns the image as a base 64 encoded string in format "data:image/FORMAT;base64,As8fE4fdt1r.....".
+     *
+     * @param {string} [format="png"] - Image format: `png`, `jpg`, `jpeg`, `bmp`, `gif`.
+     * @param {Object} [crop] - Object that holds position and size of the cropped area. Format: {x: number, y: number, width: number, height: number}.
+     * @return {string} Returns base 64 encoded string representation of the image. To get its binary data you must extract the base 64 string, then decode it from base 64 to bytes.
+     */
+    snapshot(format?: string, crop?: Object): string;
+    /**
+     * Sets or gets the anchor style of the component that indicates how to resize this component based on the resizing parent component.
+     * Anchor defines which sides (top, right, bottom, left) of the component stay attached to the parent's edge when parent gets resized.
+     * Set anchors after the component and its ancestors are added to a container to ensure expected behaviour.
+     *
+     * @param {string} [anchors] - Space-separated list of sides to anchor (e.g., `"top left"`). If omitted, returns the current anchor value.
+     * @returns {this|string} Returns `this` component when setting, or the current anchor `string` when getting value.
+     * @example
+     * const txt1 = new TextArea().anchor("top left right"); // Horizontally resizable
+     * const txt2 = new TextArea().anchor("top left bottom"); // Vertically resizable
+     */
+    anchor(...args: any[]): this | string;
+    /**
+     * Sets or gets tooltip text for the component. It's the text that pops up when cursor hovers the component.
+     *
+     * @param {string} text - Can be plain text or HTML. HTML string should be surrounded with HTML tags. See example.
+     * @return {string|this} Returns `this` component if argument is set, otherwise returns `string` value.
+     * @example
+     * button.tooltip("<html>This is line 1<br />This is line 2</html>"); // Setting HTML string with 2 lines of text
+     */
+    tooltip(...args: any[]): string | this;
+    /**
+     * Indicates the minimum size the component can be resized to.
+     *
+     * @param {number|Size} width_or_size - Minimum width, or a Size formatted object as a sole parameter.
+     * @param {number} height - Minimum height of the component.
+     * @returns {Size|this|null} If called without parameters, current minimum Size is returned or `null` if it wasn't previously set; otherwise returns `this` component instance for chaining.
+     * @see Size
+     */
+    minSize(...args: any[]): Size | this | null;
+    /**
+     * Indicates the maximum size the component can be resized to.
+     *
+     * @param {number|Size} width_or_size - Maximum width, or a Size formatted object as a sole parameter.
+     * @param {number} height - Maximum height of the component.
+     * @returns {Size|this|null} If called without parameters, current maximum Size is returned or `null` if it wasn't previously set; otherwise returns `this` component instance for chaining.
+     * @see Size
+     */
+    maxSize(...args: any[]): Size | this | null;
+    /**
+     * Positions the component in the center of it's parent component, owner Window (if Window has an owner Window), or screen (Window only).
+     * Applies only to components that have position() property (not like menu, menu item, tray icon, etc.)
+     *
+     * @arg {Object} [component] - If provided, `this` component will be positioned in the center of the provided component.
+     * @return {this} Returns `this` component.
+     */
+    center(component?: Object): this;
+    /**
+     * Enables/disables onKey() events to be emitted for focus traversal key (usually Tab key). By default onKey() event doesn't emit for such keys.
+     *
+     * @param {boolean} [enable] - `true` - enabled. `false` - disabled.
+     * @return {this|boolean} Returns `this` component if argumen is provided, otherwise returns `boolean` value.
+     */
+    emitFocusKeyEvents(...args: any[]): this | boolean;
+    /**
+     * Finds and returns first ancestor component of specified class. e.g. panel.getAncestor(Window) will return Window component that panel is in, or null if panel doesn't have a parent or ancestor with specified class.
+     *
+     * @param {Function} ancestor_class - UI Component class that comes with `swing-ui` module.
+     * @return {Object|null}
+     */
+    getAncestor(ancestor_class: Function): Object | null;
+    /**
+     * Emits a specified event with a custom event object for this component. This event will be sent to all event handlers registered with the specified event name.
+     *
+     * @param {string} event_name - Name of the event is same as name of an event handler registering function, such as `onAction` or `onChange`.
+     * @param {object} event - Custom event object
+     * @returns {this} Returns an instance of this component.
+     * @example
+     * button.emit("onAction", {type: "action", command: "Click Me"}); // emits a custom event without user clicking on the button
+     */
+    emit(event_name: string, event?: object): this;
+    /**
+     * Gets or sets the minimum size of the icon's largest side (in pixels).
+     * If the icon's largest side is smaller than the specified minimum, it will be scaled up proportionally.
+     * Applies to Button, Label, List, and ComboBox.
+     *
+     * @param {number|null} [min_size] - Sets the minimum size of a larger side of icon, or resets to no minimum when `null` is passed.
+     * @return {number|null|Object} If called without arguments, returns `number` value, otherwise returns `this` component instance.
+     */
+    minIconSize(...args: any[]): number | null | Object;
+    /**
+     * Gets or sets the maximum size of the icon's largest side (in pixels).
+     * If the icon's largest side is larger than the specified maximum, it will be scaled down proportionally.
+     * Applies to Button, Label, List, and ComboBox.
+     *
+     * @param {number|null} [max_size] - Sets the maximum size of a larger side of icon, or resets to no maximum when `null` is passed.
+     * @return {number|null|Object} If called without arguments, returns `number` value, otherwise returns `this` component instance.
+     */
+    maxIconSize(...args: any[]): number | null | Object;
+    /**
+     * Sets or gets an array of keyboard shortcuts handled by {@link UIComponent#onShortcut|onShortcut()} event handler.
+     *
+     * @param {object[]|string[]} [shortcuts] - An array of shortcut objects {shortcut:{string}, scope: {ShortcutScope}}, or an Array of String shortcuts (for strings a default {@link ShortcutScope} will be assigned).
+     * @returns {this|object[]} If called without arguments, then current shortcuts array is returned, otherwise an instance of `this` component is returned.
+     * @see ShortcutScope
+     * @example <h2>Setting shortcuts as strings</h2>
+     * window.shortcuts(["f1", "ctrl+s"]);
+     * @example <h2>Setting shortcuts as objects</h2>
+     * window.shortcuts([
+     *     {
+     *         key: "control+s",
+     *         scope: ShortcutScope.Window, // optional
+     *         action: "save_file" // optional
+     *     }
+     * ]);
+     * @example <h2>Clearing all shortcuts</h2>
+     * window.shortcuts([]); // pass an empty array
+     * @example <h2>Retrieving current shortcuts</h2>
+     * const shortcuts = window.shortcuts(); // returns an Array of objects with `key` and `scope` properties.
+     */
+    shortcuts(...args: any[]): this | object[];
+    /**
+     * Overrides current error handler.
+     *
+     * @param {function(ErrorEvent): any} [callback=undefined] - The event handler function receiving an {@link ErrorEvent} object. Pass `null` to unregister all handler functions.
+     * @return {this}
+     * @see ErrorEvent
+     */
+    onError(callback?: (arg0: ErrorEvent) => any): this;
+    /**
+     * Registers or unregisters a handler function for an event when the component gets disposed, either by calling destroy() method or loosing all references to the component.
+     *
+     * @param {function(DisposeEvent): any} [callback=undefined] - The event handler function receiving {@link DisposeEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to remove this event handler
+     * @return {this}
+     * @see DisposeEvent
+     */
+    onDispose(callback?: (arg0: DisposeEvent) => any, remove?: boolean): this;
+    /**
+     * Gets, registers or unregisters a handler function for component's primary action event.
+     *
+     * @param {function(ActionEvent): any} [callback=undefined] - The event handler function that receives a {@link ActionEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see ActionEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,        // The component that triggered the event.
+     *   command: string,       // Button text or a specified command using .command("") method
+     *   modifiers: number,     // Keyboard modifiers (bitmask or flags).
+     *   alt: boolean,          // Indicates if ALT key was pressed.
+     *   shift: boolean,        // Indicates if SHIFT key was pressed.
+     *   ctrl: boolean,         // Indicates if CTRL key was pressed.
+     *   type: string,          // `action` or `index_change`. Present when applicable.
+     *   x: number,             // Mouse x position relative to component
+     *   y: number,             // Mouse y position relative to component
+     *   screenX: number,       // Mouse x position relative to default screen
+     *   screenY: number,       // Mouse y position relative to default screen
+     *   interactive: boolean,  // Indicates if the action was triggered by user's interaction (not programmatically). Present when applicable.
+     *   selected: false        // Present when applicable.
+     * };
+     */
+    onAction(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters a mouse buttons event handler function.
+     *
+     * @param {function(MouseEvent): any} [callback=undefined] - The event handler function that receives a {@link MouseEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see MouseEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,    // The component that triggered the event.
+     *   type: string,      // `click`, `down`, `up`, `enter`, or `leave`.
+     *   button: number,    // Button number. One of MouseButton enum values.
+     *   clicks: number,    // Amount of time the click happened. Present when applicable.
+     *   modifiers: number, // Keyboard modifiers (bitmask or flags).
+     *   alt: boolean,      // Indicates if ALT key was pressed.
+     *   shift: boolean,    // Indicates if SHIFT key was pressed.
+     *   ctrl: boolean,     // Indicates if CTRL key was pressed.
+     *   x: number,         // Present when applicable.
+     *   y: number,         // Present when applicable.
+     *   screenX: number,   // Present when applicable.
+     *   screenY: number,   // Present when applicable.
+     * };
+     */
+    onMouseEvents(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters a mouse motion event handler function.
+     *
+     * @param {function(MouseMotionEvent): any} [callback=undefined] - The event handler function that receives a {@link MouseMotionEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see MouseMotionEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,     // The component that triggered the event.
+     *   type: string,       // `move` or `drag`.
+     *   button: number,     // Button number. One of MouseButton enum values. Present when applicable.
+     *   modifiers: number,  // Keyboard modifiers (bitmask or flags).
+     *   x: number,          // Mouse x position relative to component
+     *   y: number,          // Mouse y position relative to component
+     *   screenX: number,    // Mouse x position relative to default screen
+     *   screenY: number,    // Mouse y position relative to default screen
+     * };
+     */
+    onMouseMotion(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters a mouse wheel event handler function.
+     *
+     * @param {function(MouseWheelEvent): any} [callback=undefined] - The event handler function that receives a {@link MouseWheelEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see MouseWheelEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,        // The component that triggered the event.
+     *   type: string,          // `wheel`.
+     *   button: number,        // Button number. One of MouseButton enum values. Present when applicable.
+     *   scrollAmount: number,  // Returns the number of units that should be scrolled per click of mouse wheel rotation.
+     *   rotation: number,      // Indicates the number of "clicks" the mouse wheel was rotated.
+     *                          // A partial rotation may occur if the mouse supports a high-resolution wheel.
+     *                          // In this case, the number is zero until a full "click" has been accumulated.
+     *   modifiers: number,     // Keyboard modifiers (bitmask or flags).
+     *   alt: boolean,          // Indicates if ALT key was pressed.
+     *   shift: boolean,        // Indicates if SHIFT key was pressed.
+     *   ctrl: boolean,         // Indicates if CTRL key was pressed.
+     *   x: number,             // Mouse x position relative to component
+     *   y: number,             // Mouse y position relative to component
+     *   screenX: number,       // Mouse x position relative to default screen
+     *   screenY: number,       // Mouse y position relative to default screen
+     * };
+     */
+    onMouseWheel(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters a keyboard keys' event handler function.
+     *
+     * @param {function(KeyEvent): any} [callback=undefined] - The event handler function that receives a {@link KeyEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see KeyEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,           // The component that triggered the event.
+     *   type: string,             // `up`, `down`, `type`.
+     *   keyCode: number           // Numeric code associated with the key
+     *   extendedKeyCode: number   // The extended key code is a unique id assigned to a key on the keyboard just like keyCode. However, unlike keyCode, this value depends on the current keyboard layout.
+     *   keyChar: string           // Key character
+     *   modifiers: number,        // Keyboard modifiers (bitmask or flags).
+     *   modifiersText: string     // Modifiers representation as a string.
+     *   alt: boolean,             // Indicates if ALT key was pressed.
+     *   shift: boolean,           // Indicates if SHIFT key was pressed.
+     *   ctrl: boolean,            // Indicates if CTRL key was pressed.
+     *   keyLocation: string       // `standard`, `numpad`, `left`, `right`. Location of the key on keyboard. Only present when type is `up` or `down`.
+     * };
+     */
+    onKey(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters a focus event handler function.
+     *
+     * @param {function(FocusEvent): any} [callback=undefined] - The event handler function that receives a {@link FocusEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see FocusEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,     // The component that triggered the event.
+     *   type: string,       // `focus`, `blur`.
+     *   cause: string       // `UNKNOWN`, `ACTIVATION`, `TRAVERSAL_FORWARD`, `TRAVERSAL_BACKWARD`.
+     *   temporary: boolean, // Identifies the focus change event as temporary or permanent
+     * };
+     */
+    onFocusEvents(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters an event handler function for events: resize, move, show, hide.
+     *
+     * @param {function(ComponentEvent): any} [callback=undefined] - The event handler function that receives a {@link ComponentEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see ComponentEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *  target: object,       // The component that triggered the event.
+     *  type: string,         // `resize`, `move`, `show`, `hide`.
+     *  interactive: boolean, // Indicates if the event was triggered by user's interaction (not programmatically). Present when e.type is `move` or `resize`.
+     *  x: number,            // New x position of component.
+     *  y: number,            // New y position of component.
+     *  width: number,        // New width of component. Present when e.type is `resize`.
+     *  height: number,       // New height of component. Present when e.type is `resize`.
+     *  innerWidth: number,   // New width of content area of the component. Present when e.type is `resize` and component is Window or InternalWindow.
+     *  innerHeight: number,  // New height of content area of the component. Present when e.type is `resize` and component is Window or InternalWindow.
+     *};
+     */
+    onComponentEvents(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters an event handler that listens for changes to this component's properties.
+     *
+     * @param {function(PropertyChangeEvent): any} [callback=undefined] - The event handler function that receives a {@link PropertyChangeEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see PropertyChangeEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,     // The container component that triggered the event.
+     *   type: string,       // `change`.
+     *   property: string,   // The property that was changed
+     *   oldValue: any,      // Previous value of the changed property
+     *   newValue: any       // New value of the changed property
+     * };
+     */
+    onPropertyChange(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters a handler function for drag related events. Call without parameters to get an array of already registered handler functions.
+     *
+     * @param {function(DragEvent): any} [callback=undefined] - The event handler function that receives a {@link DragEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see DragEvent
+     *
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,         // The component that triggered the event.
+     *   type: string,           // `dragstart`, `dragend`, `cancel`.
+     *   action: string          // One of DragDropAction enum values. Present when applicable.
+     *   x: number,              // X position of a pointer relative to this component. Present when e.type is `dragstart` or `dragend`.
+     *   y: number,              // Y position of a pointer relative to this component. Present when e.type is `dragstart` or `dragend`.
+     *   screenX: number,        // X position of a pointer relative to default screen. Present when e.type is `dragstart` or `dragend`.
+     *   screenY: number,        // Y position of a pointer relative to default screen. Present when e.type is `dragstart` or `dragend`.
+     *   button: number,         // Indicates a pointing device button involved in dragging. Value of MouseButton enum.
+     *   modifiers: number,      // Keyboard modifiers (bitmask or flags). Present when e.type is `dragstart`.
+     *   modifiersText: string,  // Keyboard modifiers. Present when e.type is `dragstart`.
+     *   alt: boolean,           // Indicates if ALT key was pressed. Present when e.type is `dragstart`.
+     *   shift: boolean,         // Indicates if SHIFT key was pressed. Present when e.type is `dragstart`.
+     *   ctrl: boolean,          // Indicates if CTRL key was pressed. Present when e.type is `dragstart`.
+     *   selected: number[]      // Array of selected indexes of a List component whose items are being dragged. Present when List items are being dragged.
+     * };
+     */
+    onDragEvents(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters a handler function for drop related events. Call without parameters to get an array of already registered handler functions.
+     *
+     * @param {function(DropEvent): any} [callback=undefined] - The event handler function that receives a {@link DropEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see DropEvent
+     * @example <h2>{@link DropEvent} object format:</h2>
+     * const e = {
+     *   target: object,    // The component that triggered the event.
+     *   type: string,      // `dragenter`, `dragover`, `dragleave`, `drop`.
+     *   action: string     // One of the values of enum DragDropAction. Present when applicable.
+     *   data: object       // An object that contains the data that is being dropped. Present only when e.type is `drop` or `dragenter`.
+     *   source: object,    // A component that is being dragged or dropped onto this component.
+     *                      // Present only when a another UI component is dragged onto this component and `DataType.Component` is of the types set by dragDataType().
+     *   x: number,         // X position of a pointer relative to this component. Present when e.type is `dragstart` or `drop`.
+     *   y: number,         // Y position of a pointer relative to this component. Present when e.type is `dragstart` or `drop`.
+     *   screenX: number,   // X position of a pointer relative to default screen. Present when e.type is `dragstart` or `drop`.
+     *   screenY: number,   // Y position of a pointer relative to default screen. Present when e.type is `dragstart` or `drop`.
+     *   selected: number[] // Array of selected indexes of a List component whose items are being dragged. Present when List items are being dragged.
+     * };
+     */
+    onDropEvents(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters a handler function for component's text value change event. Applied to components where text can be changed by user, such as TextField, PasswordField, TextArea, DocumentEditor, ComboBox, Spinner, etc.
+     *
+     * @param {function(ChangeEvent): any} [callback=undefined] - The event handler function that receives a {@link ChangeEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see ChangeEvent
+     */
+    onChange(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters a handler function for component's event when ancestor is added, removed, or moved.
+     *
+     * @param {function(AncestorEvent): any} [callback=undefined] - The event handler function that receives a {@link AncestorEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {this|function[]} An array of handler functions if no arguments are passed, otherwise `this` component for method chaining.
+     * @see AncestorEvent
+     * @example
+     * // Example event object:
+     * const e = {
+     *   target: object,    // The component that triggered the event.
+     *   type: string,      // `add`, `remove`, `move`.
+     *   ancestor: object,  // The ancestor component.
+     * };
+     */
+    onAncestorEvents(...args: any[]): this | Function[];
+    /**
+     * Gets, registers or unregisters a handler function for component's {@link ShortcutEvent} when a shortcut is invoked.
+     *
+     * @param {function(ShortcutEvent): any} [callback=undefined] - The event handler function that receives a {@link ShortcutEvent} object. Pass `null` to unregister all handler functions.
+     * @param {boolean} [remove=false] - Set to `true` to unregister the event handler.
+     * @returns {Function[]|UIComponent}
+     */
+    onShortcut(...args: any[]): Function[] | UIComponent;
+    #private;
+}