@ringozz/godot 0.1.0

package/gen/classes/Window.ts

@@ -0,0 +1,1127 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Viewport } from './Viewport.ts';
+import type { PackedStringArray, PackedVector2Array, Signal, StringName } from '../heap-types/index.ts';
+import type { Color, Rect2i, Vector2, Vector2i } from '../value-types/index.ts';
+import type { ProgressState, WindowResizeEdge } from './DisplayServer.ts';
+import type { Font } from './Font.ts';
+import type { InputEvent } from './InputEvent.ts';
+import type { Node } from './Node.ts';
+import type { StyleBox } from './StyleBox.ts';
+import type { Texture2D } from './Texture2D.ts';
+import type { Theme } from './Theme.ts';
+
+/**
+ * A node that creates a window. The window can either be a native system window or embedded inside another {@link Window} (see {@link Viewport.guiEmbedSubwindows}).
+ * At runtime, {@link Window}s will not close automatically when requested. You need to handle it manually using the {@link close_requested} signal (this applies both to pressing the close button and clicking outside of a popup).
+ */
+export class Window extends Viewport {
+    constructor(name = 964) { super(name); }
+
+    /**
+     * Centers the window in the current screen. If the window is embedded, it is centered in the embedder {@link Viewport} instead.
+     */
+    moveToCenter(): void { _C(this, 9000); }
+
+    /**
+     * Resets the size to the minimum size, which is the max of {@link minSize} and (if {@link wrapControls} is enabled) {@link getContentsMinimumSize}. This is equivalent to calling `set_size(Vector2i())` (or any size below the minimum).
+     */
+    resetSize(): void { _C(this, 10073); }
+
+    /**
+     * Returns the window's position including its border.
+     * **Note:** If {@link visible} is `false`, this method returns the same value as {@link position}.
+     */
+    getPositionWithDecorations(): Vector2i { return _C(this, 5977) as Vector2i; }
+
+    /**
+     * Returns the window's size including its border.
+     * **Note:** If {@link visible} is `false`, this method returns the same value as {@link size}.
+     */
+    getSizeWithDecorations(): Vector2i { return _C(this, 6404) as Vector2i; }
+
+    /**
+     * Returns the maximum value for linear color components that can be displayed in this window, regardless of SDR or HDR output. Returns `1.0` if HDR is not enabled or not supported. The {@link output_max_linear_value_changed} signal will be emitted whenever this value changes.
+     * This value is used by tonemapping and other {@link Environment} effects to ensure that bright colors are presented in the range that can be displayed by this window. When using this maximum linear value in your project, it should only be used to present colors directly to the screen without tonemapping and without influencing lighting, post-processing effects, or surrounding color. The following is an example that produces the brightest purple color that the screen can produce:
+     *
+     *
+     * ```gdscript
+     *
+     * func _process(_delta):
+     * 	# output_max_linear_value may change often, so do this every frame.
+     * 	var max_linear_value = get_window().get_output_max_linear_value()
+     * 	# Replace this with your color:
+     * 	var original_color = Color.PURPLE
+     * 	# Normalize to max_linear_value to produce the brightest color possible,
+     * 	# regardless of SDR or HDR output:
+     * 	var bright_color = normalize_color(original_color, max_linear_value)
+     *
+     *
+     * func normalize_color(srgb_color, max_linear_value = 1.0):
+     * 	# Color must be linear-encoded to use math operations.
+     * 	var linear_color = srgb_color.srgb_to_linear()
+     * 	var max_rgb_value = maxf(linear_color.r, maxf(linear_color.g, linear_color.b))
+     * 	var brightness_scale = max_linear_value / max_rgb_value
+     * 	linear_color *= brightness_scale
+     * 	# Undo changes to the alpha channel, which should not be modified.
+     * 	linear_color.a = srgb_color.a
+     * 	# Convert back to nonlinear sRGB encoding, which is required for Color in
+     * 	# Godot unless stated otherwise.
+     * 	return linear_color.linear_to_srgb()
+     *
+     * ```
+     *
+     *
+     * **Note:** You will need to convert sRGB colors to linear before multiplying by this value to get correct results.
+     */
+    getOutputMaxLinearValue(): number { return _C(this, 5765) as number; }
+
+    /**
+     * Returns `true` if the window can be maximized (the maximize button is enabled).
+     */
+    isMaximizeAllowed(): boolean { return _C(this, 8098) as boolean; }
+
+    /**
+     * Tells the OS that the {@link Window} needs an attention. This makes the window stand out in some way depending on the system, e.g. it might blink on the task bar.
+     */
+    requestAttention(): void { _C(this, 10051); }
+
+    /**
+     * Creates a progress bar on the taskbar/dock icon of the {@link Window} if it does not exist, sets the progress of the icon.
+     * `value` acts as a relative percentage value, ranges from `0.0` (lowest) to `1.0` (highest).
+     * **Note:** This method is implemented only on Windows and macOS.
+     */
+    setTaskbarProgressValue(value: number): void { _C(this, 13011, value); }
+
+    /**
+     * Sets the type and state of the progress bar on the taskbar/dock icon of the {@link Window}. See {@link DisplayServer.ProgressState} for possible values and how each mode behaves.
+     * **Note:** This method is implemented only on Windows and macOS.
+     */
+    setTaskbarProgressState(state: ProgressState): void { _C(this, 13010, state); }
+
+    /**
+     * Causes the window to grab focus, allowing it to receive user input.
+     */
+    moveToForeground(): void { _C(this, 9001); }
+
+    /**
+     * Hides the window. This is not the same as minimized state. Hidden window can't be interacted with and needs to be made visible with {@link show}.
+     */
+    hide(): void { _C(this, 7513); }
+
+    /**
+     * Makes the {@link Window} appear. This enables interactions with the {@link Window} and doesn't change any of its property other than visibility (unlike e.g. {@link popup}).
+     */
+    show(): void { _C(this, 13573); }
+
+    /**
+     * If `unparent` is `true`, the window is automatically unparented when going invisible.
+     * **Note:** Make sure to keep a reference to the node, otherwise it will be orphaned. You also need to manually call {@link Node.queueFree} to free the window if it's not parented.
+     */
+    setUnparentWhenInvisible(unparent: boolean): void { _C(this, 13177, unparent); }
+
+    /**
+     * Returns whether the window is being drawn to the screen.
+     */
+    canDraw(): boolean { return _C(this, 2010) as boolean; }
+
+    /**
+     * Returns `true` if the window is focused.
+     */
+    hasFocus(): boolean { return _C(this, 7397) as boolean; }
+
+    /**
+     * Causes the window to grab focus, allowing it to receive user input.
+     */
+    grabFocus(): void { _C(this, 7285); }
+
+    /**
+     * Starts an interactive drag operation on the window, using the current mouse position. Call this method when handling a mouse button being pressed to simulate a pressed event on the window's title bar. Using this method allows the window to participate in space switching, tiling, and other system features.
+     */
+    startDrag(): void { _C(this, 13833); }
+
+    /**
+     * Starts an interactive resize operation on the window, using the current mouse position. Call this method when handling a mouse button being pressed to simulate a pressed event on the window's edge.
+     */
+    startResize(edge: WindowResizeEdge): void { _C(this, 13843, edge); }
+
+    /**
+     * If `active` is `true`, enables system's native IME (Input Method Editor).
+     */
+    setImeActive(active: boolean): void { _C(this, 11674, active); }
+
+    /**
+     * Moves IME to the given position.
+     */
+    setImePosition(position: Vector2i): void { _C(this, 11675, position); }
+
+    /**
+     * Returns `true` if the window is currently embedded in another window.
+     */
+    isEmbedded(): boolean { return _C(this, 7925) as boolean; }
+
+    /**
+     * Returns the combined minimum size from the child {@link Control} nodes of the window. Use {@link childControlsChanged} to update it when child nodes have changed.
+     * The value returned by this method can be overridden with {@link _getContentsMinimumSize}.
+     */
+    getContentsMinimumSize(): Vector2 { return _C(this, 4318) as Vector2; }
+
+    /**
+     * Requests an update of the {@link Window} size to fit underlying {@link Control} nodes.
+     */
+    childControlsChanged(): void { _C(this, 2195); }
+
+    /**
+     * Prevents `*_theme_*_override` methods from emitting {@link NOTIFICATION_THEME_CHANGED} until {@link endBulkThemeOverride} is called.
+     */
+    beginBulkThemeOverride(): void { _C(this, 1746); }
+
+    /**
+     * Ends a bulk theme override update. See {@link beginBulkThemeOverride}.
+     */
+    endBulkThemeOverride(): void { _C(this, 3095); }
+
+    /**
+     * Creates a local override for a theme icon with the specified `name`. Local overrides always take precedence when fetching theme items for the control. An override can be removed with {@link removeThemeIconOverride}.
+     * See also {@link getThemeIcon}.
+     */
+    addThemeIconOverride(name: StringName, texture: Texture2D): void { _C(this, 1312, name, texture); }
+
+    /**
+     * Creates a local override for a theme {@link StyleBox} with the specified `name`. Local overrides always take precedence when fetching theme items for the control. An override can be removed with {@link removeThemeStyleboxOverride}.
+     * See also {@link getThemeStylebox} and {@link Control.addThemeStyleboxOverride} for more details.
+     */
+    addThemeStyleboxOverride(name: StringName, stylebox: StyleBox): void { _C(this, 1313, name, stylebox); }
+
+    /**
+     * Creates a local override for a theme {@link Font} with the specified `name`. Local overrides always take precedence when fetching theme items for the control. An override can be removed with {@link removeThemeFontOverride}.
+     * See also {@link getThemeFont}.
+     */
+    addThemeFontOverride(name: StringName, font: Font): void { _C(this, 1310, name, font); }
+
+    /**
+     * Creates a local override for a theme font size with the specified `name`. Local overrides always take precedence when fetching theme items for the control. An override can be removed with {@link removeThemeFontSizeOverride}.
+     * See also {@link getThemeFontSize}.
+     */
+    addThemeFontSizeOverride(name: StringName, fontSize: number): void { _C(this, 1311, name, fontSize); }
+
+    /**
+     * Creates a local override for a theme {@link Color} with the specified `name`. Local overrides always take precedence when fetching theme items for the control. An override can be removed with {@link removeThemeColorOverride}.
+     * See also {@link getThemeColor} and {@link Control.addThemeColorOverride} for more details.
+     */
+    addThemeColorOverride(name: StringName, color: Color): void { _C(this, 1308, name, color); }
+
+    /**
+     * Creates a local override for a theme constant with the specified `name`. Local overrides always take precedence when fetching theme items for the control. An override can be removed with {@link removeThemeConstantOverride}.
+     * See also {@link getThemeConstant}.
+     */
+    addThemeConstantOverride(name: StringName, constant: number): void { _C(this, 1309, name, constant); }
+
+    /**
+     * Removes a local override for a theme icon with the specified `name` previously added by {@link addThemeIconOverride} or via the Inspector dock.
+     */
+    removeThemeIconOverride(name: StringName): void { _C(this, 9974, name); }
+
+    /**
+     * Removes a local override for a theme {@link StyleBox} with the specified `name` previously added by {@link addThemeStyleboxOverride} or via the Inspector dock.
+     */
+    removeThemeStyleboxOverride(name: StringName): void { _C(this, 9975, name); }
+
+    /**
+     * Removes a local override for a theme {@link Font} with the specified `name` previously added by {@link addThemeFontOverride} or via the Inspector dock.
+     */
+    removeThemeFontOverride(name: StringName): void { _C(this, 9972, name); }
+
+    /**
+     * Removes a local override for a theme font size with the specified `name` previously added by {@link addThemeFontSizeOverride} or via the Inspector dock.
+     */
+    removeThemeFontSizeOverride(name: StringName): void { _C(this, 9973, name); }
+
+    /**
+     * Removes a local override for a theme {@link Color} with the specified `name` previously added by {@link addThemeColorOverride} or via the Inspector dock.
+     */
+    removeThemeColorOverride(name: StringName): void { _C(this, 9970, name); }
+
+    /**
+     * Removes a local override for a theme constant with the specified `name` previously added by {@link addThemeConstantOverride} or via the Inspector dock.
+     */
+    removeThemeConstantOverride(name: StringName): void { _C(this, 9971, name); }
+
+    /**
+     * Returns an icon from the first matching {@link Theme} in the tree if that {@link Theme} has an icon item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for details.
+     */
+    getThemeIcon(name: StringName, themeType?: StringName /* = &"" */): Texture2D { return _C(this, 6767, name, themeType) as Texture2D; }
+
+    /**
+     * Returns a {@link StyleBox} from the first matching {@link Theme} in the tree if that {@link Theme} has a stylebox item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for details.
+     */
+    getThemeStylebox(name: StringName, themeType?: StringName /* = &"" */): StyleBox { return _C(this, 6771, name, themeType) as StyleBox; }
+
+    /**
+     * Returns a {@link Font} from the first matching {@link Theme} in the tree if that {@link Theme} has a font item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for details.
+     */
+    getThemeFont(name: StringName, themeType?: StringName /* = &"" */): Font { return _C(this, 6765, name, themeType) as Font; }
+
+    /**
+     * Returns a font size from the first matching {@link Theme} in the tree if that {@link Theme} has a font size item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for details.
+     */
+    getThemeFontSize(name: StringName, themeType?: StringName /* = &"" */): number { return _C(this, 6766, name, themeType) as number; }
+
+    /**
+     * Returns a {@link Color} from the first matching {@link Theme} in the tree if that {@link Theme} has a color item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for more details.
+     */
+    getThemeColor(name: StringName, themeType?: StringName /* = &"" */): Color { return _C(this, 6760, name, themeType) as Color; }
+
+    /**
+     * Returns a constant from the first matching {@link Theme} in the tree if that {@link Theme} has a constant item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for more details.
+     */
+    getThemeConstant(name: StringName, themeType?: StringName /* = &"" */): number { return _C(this, 6761, name, themeType) as number; }
+
+    /**
+     * Returns `true` if there is a local override for a theme icon with the specified `name` in this {@link Control} node.
+     * See {@link addThemeIconOverride}.
+     */
+    hasThemeIconOverride(name: StringName): boolean { return _C(this, 7467, name) as boolean; }
+
+    /**
+     * Returns `true` if there is a local override for a theme {@link StyleBox} with the specified `name` in this {@link Control} node.
+     * See {@link addThemeStyleboxOverride}.
+     */
+    hasThemeStyleboxOverride(name: StringName): boolean { return _C(this, 7470, name) as boolean; }
+
+    /**
+     * Returns `true` if there is a local override for a theme {@link Font} with the specified `name` in this {@link Control} node.
+     * See {@link addThemeFontOverride}.
+     */
+    hasThemeFontOverride(name: StringName): boolean { return _C(this, 7463, name) as boolean; }
+
+    /**
+     * Returns `true` if there is a local override for a theme font size with the specified `name` in this {@link Control} node.
+     * See {@link addThemeFontSizeOverride}.
+     */
+    hasThemeFontSizeOverride(name: StringName): boolean { return _C(this, 7465, name) as boolean; }
+
+    /**
+     * Returns `true` if there is a local override for a theme {@link Color} with the specified `name` in this {@link Control} node.
+     * See {@link addThemeColorOverride}.
+     */
+    hasThemeColorOverride(name: StringName): boolean { return _C(this, 7459, name) as boolean; }
+
+    /**
+     * Returns `true` if there is a local override for a theme constant with the specified `name` in this {@link Control} node.
+     * See {@link addThemeConstantOverride}.
+     */
+    hasThemeConstantOverride(name: StringName): boolean { return _C(this, 7461, name) as boolean; }
+
+    /**
+     * Returns `true` if there is a matching {@link Theme} in the tree that has an icon item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for details.
+     */
+    hasThemeIcon(name: StringName, themeType?: StringName /* = &"" */): boolean { return _C(this, 7466, name, themeType) as boolean; }
+
+    /**
+     * Returns `true` if there is a matching {@link Theme} in the tree that has a stylebox item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for details.
+     */
+    hasThemeStylebox(name: StringName, themeType?: StringName /* = &"" */): boolean { return _C(this, 7469, name, themeType) as boolean; }
+
+    /**
+     * Returns `true` if there is a matching {@link Theme} in the tree that has a font item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for details.
+     */
+    hasThemeFont(name: StringName, themeType?: StringName /* = &"" */): boolean { return _C(this, 7462, name, themeType) as boolean; }
+
+    /**
+     * Returns `true` if there is a matching {@link Theme} in the tree that has a font size item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for details.
+     */
+    hasThemeFontSize(name: StringName, themeType?: StringName /* = &"" */): boolean { return _C(this, 7464, name, themeType) as boolean; }
+
+    /**
+     * Returns `true` if there is a matching {@link Theme} in the tree that has a color item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for details.
+     */
+    hasThemeColor(name: StringName, themeType?: StringName /* = &"" */): boolean { return _C(this, 7458, name, themeType) as boolean; }
+
+    /**
+     * Returns `true` if there is a matching {@link Theme} in the tree that has a constant item with the specified `name` and `themeType`.
+     * See {@link Control.getThemeColor} for details.
+     */
+    hasThemeConstant(name: StringName, themeType?: StringName /* = &"" */): boolean { return _C(this, 7460, name, themeType) as boolean; }
+
+    /**
+     * Returns the default base scale value from the first matching {@link Theme} in the tree if that {@link Theme} has a valid {@link Theme.defaultBaseScale} value.
+     * See {@link Control.getThemeColor} for details.
+     */
+    getThemeDefaultBaseScale(): number { return _C(this, 6762) as number; }
+
+    /**
+     * Returns the default font from the first matching {@link Theme} in the tree if that {@link Theme} has a valid {@link Theme.defaultFont} value.
+     * See {@link Control.getThemeColor} for details.
+     */
+    getThemeDefaultFont(): Font { return _C(this, 6763) as Font; }
+
+    /**
+     * Returns the default font size value from the first matching {@link Theme} in the tree if that {@link Theme} has a valid {@link Theme.defaultFontSize} value.
+     * See {@link Control.getThemeColor} for details.
+     */
+    getThemeDefaultFontSize(): number { return _C(this, 6764) as number; }
+
+    /**
+     * Returns the ID of the window.
+     */
+    getWindowId(): number { return _C(this, 7154) as number; }
+
+    /**
+     * Returns the focused window.
+     */
+    static getFocusedWindow(): Window { return _C(964, 4828) as Window; }
+
+    /**
+     * Sets layout direction and text writing direction. Right-to-left layouts are necessary for certain languages (e.g. Arabic and Hebrew).
+     */
+    setLayoutDirection(direction: LayoutDirection): void { _C(this, 11889, direction); }
+
+    /**
+     * Returns layout direction and text writing direction.
+     */
+    getLayoutDirection(): LayoutDirection { return _C(this, 5329) as LayoutDirection; }
+
+    /**
+     * Returns `true` if the layout is right-to-left.
+     */
+    isLayoutRtl(): boolean { return _C(this, 8067) as boolean; }
+
+    /**
+     * Enables font oversampling. This makes fonts look better when they are scaled up.
+     */
+    setUseFontOversampling(enable: boolean): void { _C(this, 13216, enable); }
+
+    /**
+     * Returns `true` if font oversampling is enabled. See {@link setUseFontOversampling}.
+     */
+    isUsingFontOversampling(): boolean { return _C(this, 8404) as boolean; }
+
+    /**
+     * Shows the {@link Window} and makes it transient (see {@link transient}). If `rect` is provided, it will be set as the {@link Window}'s size. Fails if called on the main window.
+     * If {@link ProjectSettings.display/window/subwindows/embedSubwindows} is `true` (single-window mode), `rect`'s coordinates are global and relative to the main window's top-left corner (excluding window decorations). If `rect`'s position coordinates are negative, the window will be located outside the main window and may not be visible as a result.
+     * If {@link ProjectSettings.display/window/subwindows/embedSubwindows} is `false` (multi-window mode), `rect`'s coordinates are global and relative to the top-left corner of the leftmost screen. If `rect`'s position coordinates are negative, the window will be placed at the top-left corner of the screen.
+     * **Note:** `rect` must be in global coordinates if specified.
+     */
+    popup(rect?: Rect2i /* = Rect2i(0, 0, 0, 0) */): void { _C(this, 9482, rect); }
+
+    /**
+     * Popups the {@link Window} with a position shifted by parent {@link Window}'s position. If the {@link Window} is embedded, has the same effect as {@link popup}.
+     */
+    popupOnParent(parentRect: Rect2i): void { _C(this, 9494, parentRect); }
+
+    /**
+     * Popups the {@link Window} at the center of the current screen, with optionally given minimum size. If the {@link Window} is embedded, it will be centered in the parent {@link Viewport} instead.
+     * **Note:** Calling it with the default value of `minsize` is equivalent to calling it with {@link size}.
+     */
+    popupCentered(minsize?: Vector2i /* = Vector2i(0, 0) */): void { _C(this, 9483, minsize); }
+
+    /**
+     * If {@link Window} is embedded, popups the {@link Window} centered inside its embedder and sets its size as a `ratio` of embedder's size.
+     * If {@link Window} is a native window, popups the {@link Window} centered inside the screen of its parent {@link Window} and sets its size as a `ratio` of the screen size.
+     */
+    popupCenteredRatio(ratio?: number /* = 0.8 */): void { _C(this, 9485, ratio); }
+
+    /**
+     * Popups the {@link Window} centered inside its parent {@link Window}. `fallbackRatio` determines the maximum size of the {@link Window}, in relation to its parent.
+     * **Note:** Calling it with the default value of `minsize` is equivalent to calling it with {@link size}.
+     */
+    popupCenteredClamped(minsize?: Vector2i /* = Vector2i(0, 0) */, fallbackRatio?: number /* = 0.75 */): void { _C(this, 9484, minsize, fallbackRatio); }
+
+    /**
+     * Attempts to parent this dialog to the last exclusive window relative to `fromNode`, and then calls {@link Window.popup} on it. The dialog must have no current parent, otherwise the method fails.
+     * See also {@link setUnparentWhenInvisible} and {@link Node.getLastExclusiveWindow}.
+     */
+    popupExclusive(fromNode: Node, rect?: Rect2i /* = Rect2i(0, 0, 0, 0) */): void { _C(this, 9487, fromNode, rect); }
+
+    /**
+     * Attempts to parent this dialog to the last exclusive window relative to `fromNode`, and then calls {@link Window.popupOnParent} on it. The dialog must have no current parent, otherwise the method fails.
+     * See also {@link setUnparentWhenInvisible} and {@link Node.getLastExclusiveWindow}.
+     */
+    popupExclusiveOnParent(fromNode: Node, parentRect: Rect2i): void { _C(this, 9491, fromNode, parentRect); }
+
+    /**
+     * Attempts to parent this dialog to the last exclusive window relative to `fromNode`, and then calls {@link Window.popupCentered} on it. The dialog must have no current parent, otherwise the method fails.
+     * See also {@link setUnparentWhenInvisible} and {@link Node.getLastExclusiveWindow}.
+     */
+    popupExclusiveCentered(fromNode: Node, minsize?: Vector2i /* = Vector2i(0, 0) */): void { _C(this, 9488, fromNode, minsize); }
+
+    /**
+     * Attempts to parent this dialog to the last exclusive window relative to `fromNode`, and then calls {@link Window.popupCenteredRatio} on it. The dialog must have no current parent, otherwise the method fails.
+     * See also {@link setUnparentWhenInvisible} and {@link Node.getLastExclusiveWindow}.
+     */
+    popupExclusiveCenteredRatio(fromNode: Node, ratio?: number /* = 0.8 */): void { _C(this, 9490, fromNode, ratio); }
+
+    /**
+     * Attempts to parent this dialog to the last exclusive window relative to `fromNode`, and then calls {@link Window.popupCenteredClamped} on it. The dialog must have no current parent, otherwise the method fails.
+     * See also {@link setUnparentWhenInvisible} and {@link Node.getLastExclusiveWindow}.
+     */
+    popupExclusiveCenteredClamped(fromNode: Node, minsize?: Vector2i /* = Vector2i(0, 0) */, fallbackRatio?: number /* = 0.75 */): void { _C(this, 9489, fromNode, minsize, fallbackRatio); }
+
+    /**
+     * Set's the window's current mode.
+     * **Note:** Fullscreen mode is not exclusive full screen on Windows and Linux.
+     * **Note:** This method only works with native windows, i.e. the main window and {@link Window}-derived nodes when {@link Viewport.guiEmbedSubwindows} is disabled in the main viewport.
+     */
+    get mode(): Mode { return _C(this, 5568) as Mode; }
+    set mode(v: Mode) { _C(this, 12073, v); }
+
+    /**
+     * The window's title. If the {@link Window} is native, title styles set in {@link Theme} will have no effect.
+     */
+    get title(): string { return _C(this, 6829) as string; }
+    set title(v: string) { _C(this, 13099, v); }
+
+    /**
+     * Specifies the initial type of position for the {@link Window}.
+     */
+    get initialPosition(): WindowInitialPosition { return _C(this, 5103) as WindowInitialPosition; }
+    set initialPosition(v: WindowInitialPosition) { _C(this, 11703, v); }
+
+    /**
+     * The window's position in pixels.
+     * If {@link ProjectSettings.display/window/subwindows/embedSubwindows} is `false`, the position is in absolute screen coordinates. This typically applies to editor plugins. If the setting is `true`, the window's position is in the coordinates of its parent {@link Viewport}.
+     * **Note:** This property only works if {@link initialPosition} is set to {@link WINDOW_INITIAL_POSITION_ABSOLUTE}.
+     */
+    get position(): Vector2i { return _C(this, 5973) as Vector2i; }
+    set position(v: Vector2i) { _C(this, 12381, v); }
+
+    /**
+     * The window's size in pixels. See also {@link contentScaleSize}, which doesn't set the window's physical size but affects how scaling works relative to the current {@link contentScaleMode}.
+     */
+    get size(): Vector2i { return _C(this, 6399) as Vector2i; }
+    set size(v: Vector2i) { _C(this, 12752, v); }
+
+    /**
+     * The screen the window is currently on.
+     */
+    get currentScreen(): number { return _C(this, 4366) as number; }
+    set currentScreen(v: number) { _C(this, 10991, v); }
+
+    /**
+     * If set, defines the window's custom decoration area which will receive mouse input, even if normal input to the window is blocked (such as when it has an exclusive child opened). See also {@link nonclient_window_input}.
+     */
+    get nonclientArea(): Rect2i { return _C(this, 5674) as Rect2i; }
+    set nonclientArea(v: Rect2i) { _C(this, 12144, v); }
+
+    /**
+     * Sets a polygonal region of the window which accepts mouse events. Mouse events outside the region will be passed through.
+     * Passing an empty array will disable passthrough support (all mouse events will be intercepted by the window, which is the default behavior).
+     *
+     *
+     * ```gdscript
+     *
+     * # Set region, using Path2D node.
+     * $Window.mouse_passthrough_polygon = $Path2D.curve.get_baked_points()
+     *
+     * # Set region, using Polygon2D node.
+     * $Window.mouse_passthrough_polygon = $Polygon2D.polygon
+     *
+     * # Reset region to default.
+     * $Window.mouse_passthrough_polygon = []
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** This property is ignored if {@link mousePassthrough} is set to `true`.
+     * **Note:** On Windows, the portion of a window that lies outside the region is not drawn, while on Linux (X11) and macOS it is.
+     * **Note:** This property is implemented on Linux (X11), macOS and Windows.
+     */
+    get mousePassthroughPolygon(): PackedVector2Array { return _C(this, 5590) as PackedVector2Array; }
+    set mousePassthroughPolygon(v: PackedVector2Array) { _C(this, 12096, v); }
+
+    /**
+     * If `true`, the window is visible.
+     */
+    get visible(): boolean { return _C(this, 8450) as boolean; }
+    set visible(v: boolean) { _C(this, 13331, v); }
+
+    /**
+     * If `true`, the window's size will automatically update when a child node is added or removed, ignoring {@link minSize} if the new size is bigger.
+     * If `false`, you need to call {@link childControlsChanged} manually.
+     */
+    get wrapControls(): boolean { return _C(this, 8455) as boolean; }
+    set wrapControls(v: boolean) { _C(this, 13384, v); }
+
+    /**
+     * If `true`, the {@link Window} is transient, i.e. it's considered a child of another {@link Window}. The transient window will be destroyed with its transient parent and will return focus to their parent when closed. The transient window is displayed on top of a non-exclusive full-screen parent window. Transient windows can't enter full-screen mode.
+     * Note that behavior might be different depending on the platform.
+     */
+    get _transient(): boolean { return _C(this, 8372) as boolean; }
+    set _transient(v: boolean) { _C(this, 13139, v); }
+
+    /**
+     * If `true`, and the {@link Window} is {@link transient}, this window will (at the time of becoming visible) become transient to the currently focused window instead of the immediate parent window in the hierarchy. Note that the transient parent is assigned at the time this window becomes visible, so changing it afterwards has no effect until re-shown.
+     */
+    get transientToFocused(): boolean { return _C(this, 8373) as boolean; }
+    set transientToFocused(v: boolean) { _C(this, 13140, v); }
+
+    /**
+     * If `true`, the {@link Window} will be in exclusive mode. Exclusive windows are always on top of their parent and will block all input going to the parent {@link Window}.
+     * Needs {@link transient} enabled to work.
+     */
+    get exclusive(): boolean { return _C(this, 7941) as boolean; }
+    set exclusive(v: boolean) { _C(this, 11317, v); }
+
+    /**
+     * If `true`, the window can't be resized.
+     */
+    get unresizable(): boolean { return _C(this, 4803, 0) as boolean; }
+    set unresizable(v: boolean) { _C(this, 11408, 0, v); }
+
+    /**
+     * If `true`, the window will have no borders.
+     */
+    get borderless(): boolean { return _C(this, 4803, 1) as boolean; }
+    set borderless(v: boolean) { _C(this, 11408, 1, v); }
+
+    /**
+     * If `true`, the window will be on top of all other windows. Does not work if {@link transient} is enabled.
+     */
+    get alwaysOnTop(): boolean { return _C(this, 4803, 2) as boolean; }
+    set alwaysOnTop(v: boolean) { _C(this, 11408, 2, v); }
+
+    /**
+     * If `true`, the {@link Window}'s background can be transparent. This is best used with embedded windows.
+     * **Note:** Transparency support is implemented on Linux, macOS and Windows, but availability might vary depending on GPU driver, display manager, and compositor capabilities.
+     * **Note:** This property has no effect if {@link ProjectSettings.display/window/perPixelTransparency/allowed} is set to `false`.
+     */
+    get transparent(): boolean { return _C(this, 4803, 3) as boolean; }
+    set transparent(v: boolean) { _C(this, 11408, 3, v); }
+
+    /**
+     * If `true`, the {@link Window} can't be focused nor interacted with. It can still be visible.
+     */
+    get unfocusable(): boolean { return _C(this, 4803, 4) as boolean; }
+    set unfocusable(v: boolean) { _C(this, 11408, 4, v); }
+
+    /**
+     * If `true`, the {@link Window} will be considered a popup. Popups are sub-windows that don't show as separate windows in system's window manager's window list and will send close request when anything is clicked outside of them (unless {@link exclusive} is enabled).
+     */
+    get popupWindow(): boolean { return _C(this, 4803, 5) as boolean; }
+    set popupWindow(v: boolean) { _C(this, 11408, 5, v); }
+
+    /**
+     * If `true`, the {@link Window} contents is expanded to the full size of the window, window title bar is transparent.
+     * **Note:** This property is implemented only on macOS.
+     * **Note:** This property only works with native windows.
+     */
+    get extendToTitle(): boolean { return _C(this, 4803, 6) as boolean; }
+    set extendToTitle(v: boolean) { _C(this, 11408, 6, v); }
+
+    /**
+     * If `true`, all mouse events will be passed to the underlying window of the same application. See also {@link mousePassthroughPolygon}.
+     * **Note:** This property is implemented on Linux (X11), macOS and Windows.
+     * **Note:** This property only works with native windows.
+     */
+    get mousePassthrough(): boolean { return _C(this, 4803, 7) as boolean; }
+    set mousePassthrough(v: boolean) { _C(this, 11408, 7, v); }
+
+    /**
+     * If `true`, the {@link Window} will override the OS window style to display sharp corners.
+     * **Note:** This property is implemented only on Windows (11).
+     * **Note:** This property only works with native windows.
+     */
+    get sharpCorners(): boolean { return _C(this, 4803, 8) as boolean; }
+    set sharpCorners(v: boolean) { _C(this, 11408, 8, v); }
+
+    /**
+     * If `true`, the {@link Window} is excluded from screenshots taken by {@link DisplayServer.screenGetImage}, {@link DisplayServer.screenGetImageRect}, and {@link DisplayServer.screenGetPixel}.
+     * **Note:** This property is implemented on macOS and Windows.
+     * **Note:** Enabling this setting will prevent standard screenshot methods from capturing a window image, but does **NOT** guarantee that other apps won't be able to capture an image. It should not be used as a DRM or security measure.
+     */
+    get excludeFromCapture(): boolean { return _C(this, 4803, 9) as boolean; }
+    set excludeFromCapture(v: boolean) { _C(this, 11408, 9, v); }
+
+    /**
+     * If `true`, the {@link Window} will signal to the window manager that it is supposed to be an implementation-defined "popup" (usually a floating, borderless, untileable and immovable child window).
+     */
+    get popupWmHint(): boolean { return _C(this, 4803, 10) as boolean; }
+    set popupWmHint(v: boolean) { _C(this, 11408, 10, v); }
+
+    /**
+     * If `true`, the {@link Window}'s minimize button is disabled.
+     * **Note:** If both minimize and maximize buttons are disabled, buttons are fully hidden, and only close button is visible.
+     * **Note:** This property is implemented only on macOS and Windows.
+     */
+    get minimizeDisabled(): boolean { return _C(this, 4803, 11) as boolean; }
+    set minimizeDisabled(v: boolean) { _C(this, 11408, 11, v); }
+
+    /**
+     * If `true`, the {@link Window}'s maximize button is disabled.
+     * **Note:** If both minimize and maximize buttons are disabled, buttons are fully hidden, and only close button is visible.
+     * **Note:** This property is implemented only on macOS and Windows.
+     */
+    get maximizeDisabled(): boolean { return _C(this, 4803, 12) as boolean; }
+    set maximizeDisabled(v: boolean) { _C(this, 11408, 12, v); }
+
+    /**
+     * If `true`, native window will be used regardless of parent viewport and project settings.
+     */
+    get forceNative(): boolean { return _C(this, 4860) as boolean; }
+    set forceNative(v: boolean) { _C(this, 11463, v); }
+
+    /**
+     * If non-zero, the {@link Window} can't be resized to be smaller than this size.
+     * **Note:** This property will be ignored in favor of {@link getContentsMinimumSize} if {@link wrapControls} is enabled and if its size is bigger.
+     */
+    get minSize(): Vector2i { return _C(this, 5544) as Vector2i; }
+    set minSize(v: Vector2i) { _C(this, 12054, v); }
+
+    /**
+     * If non-zero, the {@link Window} can't be resized to be bigger than this size.
+     * **Note:** This property will be ignored if the value is lower than {@link minSize}.
+     */
+    get maxSize(): Vector2i { return _C(this, 5485) as Vector2i; }
+    set maxSize(v: Vector2i) { _C(this, 12007, v); }
+
+    /**
+     * If `true`, the {@link Window} width is expanded to keep the title bar text fully visible.
+     */
+    get keepTitleVisible(): boolean { return _C(this, 5285) as boolean; }
+    set keepTitleVisible(v: boolean) { _C(this, 11864, v); }
+
+    /**
+     * The content's base size in "virtual" pixels. Not to be confused with {@link size}, which sets the actual window's physical size in pixels. If set to a value greater than `0` and {@link contentScaleMode} is set to a value other than {@link CONTENT_SCALE_MODE_DISABLED}, the {@link Window}'s content will be scaled when the window is resized to a different size. Higher values will make the content appear *smaller*, as it will be able to fit more of the project in view. On the root {@link Window}, this is set to match {@link ProjectSettings.display/window/size/viewportWidth} and {@link ProjectSettings.display/window/size/viewportHeight} by default.
+     * For example, when using {@link CONTENT_SCALE_MODE_CANVAS_ITEMS} and {@link contentScaleSize} set to `Vector2i(1280, 720)`, using a window size of `2560×1440` will make 2D elements appear at double their original size, as the content is scaled by a factor of `2.0` (`2560.0 / 1280.0 = 2.0`, `1440.0 / 720.0 = 2.0`).
+     * See [the Base size section of the Multiple resolutions documentation]($DOCS_URL/tutorials/rendering/multiple_resolutions.html#base-size) for details.
+     */
+    get contentScaleSize(): Vector2i { return _C(this, 4315) as Vector2i; }
+    set contentScaleSize(v: Vector2i) { _C(this, 10957, v); }
+
+    /**
+     * Specifies how the content is scaled when the {@link Window} is resized.
+     */
+    get contentScaleMode(): ContentScaleMode { return _C(this, 4314) as ContentScaleMode; }
+    set contentScaleMode(v: ContentScaleMode) { _C(this, 10956, v); }
+
+    /**
+     * Specifies how the content's aspect behaves when the {@link Window} is resized. The base aspect is determined by {@link contentScaleSize}.
+     */
+    get contentScaleAspect(): ContentScaleAspect { return _C(this, 4312) as ContentScaleAspect; }
+    set contentScaleAspect(v: ContentScaleAspect) { _C(this, 10954, v); }
+
+    /**
+     * The policy to use to determine the final scale factor for 2D elements. This affects how {@link contentScaleFactor} is applied, in addition to the automatic scale factor determined by {@link contentScaleSize}.
+     */
+    get contentScaleStretch(): ContentScaleStretch { return _C(this, 4316) as ContentScaleStretch; }
+    set contentScaleStretch(v: ContentScaleStretch) { _C(this, 10958, v); }
+
+    /**
+     * Specifies the base scale of {@link Window}'s content when its {@link size} is equal to {@link contentScaleSize}. See also {@link Viewport.getStretchTransform}.
+     */
+    get contentScaleFactor(): number { return _C(this, 4313) as number; }
+    set contentScaleFactor(v: number) { _C(this, 10955, v); }
+
+    /**
+     * If `true`, requests HDR output for the {@link Window}, falling back to SDR if not supported, and automatically switching between HDR and SDR as the window moves between screens, screen capabilities change, or system settings are modified. This will internally force {@link Viewport.useHdr2d} to be enabled on the main {@link Viewport}. All other {@link SubViewport} of this {@link Window} must have their {@link Viewport.useHdr2d} property enabled to produce HDR output.
+     */
+    get hdrOutputRequested(): boolean { return _C(this, 7988) as boolean; }
+    set hdrOutputRequested(v: boolean) { _C(this, 11607, v); }
+
+    /**
+     * Toggles if any text should automatically change to its translated version depending on the current locale.
+     */
+    get autoTranslate(): boolean { return _C(this, 7776) as boolean; }
+    set autoTranslate(v: boolean) { _C(this, 10581, v); }
+
+    /**
+     * The human-readable node name that is reported to assistive apps.
+     */
+    get accessibilityName(): string { return _C(this, 3673) as string; }
+    set accessibilityName(v: string) { _C(this, 10411, v); }
+
+    /**
+     * The human-readable node description that is reported to assistive apps.
+     */
+    get accessibilityDescription(): string { return _C(this, 3668) as string; }
+    set accessibilityDescription(v: string) { _C(this, 10407, v); }
+
+    /**
+     * The {@link Theme} resource this node and all its {@link Control} and {@link Window} children use. If a child node has its own {@link Theme} resource set, theme items are merged with child's definitions having higher priority.
+     * **Note:** {@link Window} styles will have no effect unless the window is embedded.
+     */
+    get theme(): Theme { return _C(this, 6759) as Theme; }
+    set theme(v: Theme) { _C(this, 13051, v); }
+
+    /**
+     * The name of a theme type variation used by this {@link Window} to look up its own theme items. See {@link Control.themeTypeVariation} for more details.
+     */
+    get themeTypeVariation(): StringName { return _C(this, 6772) as StringName; }
+    set themeTypeVariation(v: StringName) { _C(this, 13053, v); }
+
+    /**
+     * Emitted when {@link Window}'s visibility changes, right before {@link visibility_changed}.
+     */
+    static readonly NOTIFICATION_VISIBILITY_CHANGED = 30;
+
+    /**
+     * Sent when the node needs to refresh its theme items. This happens in one of the following cases:
+     * - The {@link theme} property is changed on this node or any of its ancestors.
+     * - The {@link themeTypeVariation} property is changed on this node.
+     * - The node enters the scene tree.
+     * **Note:** As an optimization, this notification won't be sent from changes that occur while this node is outside of the scene tree. Instead, all of the theme item updates can be applied at once when the node enters the scene tree.
+     */
+    static readonly NOTIFICATION_THEME_CHANGED = 32;
+
+    /**
+     * Emitted when the {@link Window} is currently focused and receives any input, passing the received event as an argument. The event's position, if present, is in the embedder's coordinate system.
+     */
+    get windowInput(): Signal<(event: InputEvent) => void> { return _G(this, 14879) as Signal<(event: InputEvent) => void>; }
+    set windowInput(v: ((event: InputEvent) => void) | null) { _G(this, 14879, v); }
+
+    /**
+     * Emitted when the mouse event is received by the custom decoration area defined by {@link nonclientArea}, and normal input to the window is blocked (such as when it has an exclusive child opened). `event`'s position is in the embedder's coordinate system.
+     */
+    get nonclientWindowInput(): Signal<(event: InputEvent) => void> { return _G(this, 9093) as Signal<(event: InputEvent) => void>; }
+    set nonclientWindowInput(v: ((event: InputEvent) => void) | null) { _G(this, 9093, v); }
+
+    /**
+     * Emitted when files are dragged from the OS file manager and dropped in the game window. The argument is a list of file paths.
+     *
+     * ```text
+     *
+     * func _ready():
+     * 	get_window().files_dropped.connect(on_files_dropped)
+     *
+     * func on_files_dropped(files):
+     * 	print(files)
+     *
+     * ```
+     *
+     * **Note:** This signal only works with native windows, i.e. the main window and {@link Window}-derived nodes when {@link Viewport.guiEmbedSubwindows} is disabled in the main viewport.
+     */
+    get filesDropped(): Signal<(files: PackedStringArray) => void> { return _G(this, 3258) as Signal<(files: PackedStringArray) => void>; }
+    set filesDropped(v: ((files: PackedStringArray) => void) | null) { _G(this, 3258, v); }
+
+    /**
+     * Emitted when the mouse cursor enters the {@link Window}'s visible area, that is not occluded behind other {@link Control}s or windows, provided its {@link Viewport.guiDisableInput} is `false` and regardless if it's currently focused or not.
+     */
+    get mouseEntered(): Signal<() => void> { return _G(this, 8963) as Signal<() => void>; }
+    set mouseEntered(v: (() => void) | null) { _G(this, 8963, v); }
+
+    /**
+     * Emitted when the mouse cursor leaves the {@link Window}'s visible area, that is not occluded behind other {@link Control}s or windows, provided its {@link Viewport.guiDisableInput} is `false` and regardless if it's currently focused or not.
+     */
+    get mouseExited(): Signal<() => void> { return _G(this, 8964) as Signal<() => void>; }
+    set mouseExited(v: (() => void) | null) { _G(this, 8964, v); }
+
+    /**
+     * Emitted when the {@link Window} gains focus.
+     */
+    get focusEntered(): Signal<() => void> { return _G(this, 3347) as Signal<() => void>; }
+    set focusEntered(v: (() => void) | null) { _G(this, 3347, v); }
+
+    /**
+     * Emitted when the {@link Window} loses its focus.
+     */
+    get focusExited(): Signal<() => void> { return _G(this, 3348) as Signal<() => void>; }
+    set focusExited(v: (() => void) | null) { _G(this, 3348, v); }
+
+    /**
+     * Emitted when the {@link Window}'s close button is pressed or when {@link popupWindow} is enabled and user clicks outside the window.
+     * This signal can be used to handle window closing, e.g. by connecting it to {@link hide}.
+     */
+    get closeRequested(): Signal<() => void> { return _G(this, 2334) as Signal<() => void>; }
+    set closeRequested(v: (() => void) | null) { _G(this, 2334, v); }
+
+    /**
+     * Emitted when a go back request is sent (e.g. pressing the "Back" button on Android), right after {@link Node.NOTIFICATION_WM_GO_BACK_REQUEST}.
+     */
+    get goBackRequested(): Signal<() => void> { return _G(this, 7279) as Signal<() => void>; }
+    set goBackRequested(v: (() => void) | null) { _G(this, 7279, v); }
+
+    /**
+     * Emitted when {@link Window} is made visible or disappears.
+     */
+    get visibilityChanged(): Signal<() => void> { return _G(this, 14772) as Signal<() => void>; }
+    set visibilityChanged(v: (() => void) | null) { _G(this, 14772, v); }
+
+    /**
+     * Emitted right after {@link popup} call, before the {@link Window} appears or does anything.
+     */
+    get aboutToPopup(): Signal<() => void> { return _G(this, 1052) as Signal<() => void>; }
+    set aboutToPopup(v: (() => void) | null) { _G(this, 1052, v); }
+
+    /**
+     * Emitted when the {@link NOTIFICATION_THEME_CHANGED} notification is sent.
+     */
+    get themeChanged(): Signal<() => void> { return _G(this, 14239) as Signal<() => void>; }
+    set themeChanged(v: (() => void) | null) { _G(this, 14239, v); }
+
+    /**
+     * Emitted when the {@link Window}'s DPI changes as a result of OS-level changes (e.g. moving the window from a Retina display to a lower resolution one).
+     * **Note:** Only implemented on macOS and Linux (Wayland).
+     */
+    get dpiChanged(): Signal<() => void> { return _G(this, 2878) as Signal<() => void>; }
+    set dpiChanged(v: (() => void) | null) { _G(this, 2878, v); }
+
+    /**
+     * Emitted when window title bar decorations are changed, e.g. macOS window enter/exit full screen mode, or extend-to-title flag is changed.
+     */
+    get titlebarChanged(): Signal<() => void> { return _G(this, 14280) as Signal<() => void>; }
+    set titlebarChanged(v: (() => void) | null) { _G(this, 14280, v); }
+
+    /**
+     * Emitted when window title bar text is changed.
+     */
+    get titleChanged(): Signal<() => void> { return _G(this, 14276) as Signal<() => void>; }
+    set titleChanged(v: (() => void) | null) { _G(this, 14276, v); }
+
+    /**
+     * Emitted when the output max linear value returned by {@link Window.getOutputMaxLinearValue} has changed. This occurs when HDR output is enabled or disabled and when any HDR output luminance values of the window have changed, such as when the player adjusts their screen brightness setting or moves the window to a different screen. `outputMaxLinearValue` is the new value.
+     */
+    get outputMaxLinearValueChanged(): Signal<(outputMaxLinearValue: number) => void> { return _G(this, 9243) as Signal<(outputMaxLinearValue: number) => void>; }
+    set outputMaxLinearValueChanged(v: ((outputMaxLinearValue: number) => void) | null) { _G(this, 9243, v); }
+
+    static readonly name = _R(964, Window);
+}
+
+export const Mode = {
+    /**
+     * Windowed mode, i.e. {@link Window} doesn't occupy the whole screen (unless set to the size of the screen).
+     */
+    MODE_WINDOWED: 0,
+    /**
+     * Minimized window mode, i.e. {@link Window} is not visible and available on window manager's window list. Normally happens when the minimize button is pressed.
+     */
+    MODE_MINIMIZED: 1,
+    /**
+     * Maximized window mode, i.e. {@link Window} will occupy whole screen area except task bar and still display its borders. Normally happens when the maximize button is pressed.
+     */
+    MODE_MAXIMIZED: 2,
+    /**
+     * Full screen mode with full multi-window support.
+     * Full screen window covers the entire display area of a screen and has no decorations. The display's video mode is not changed.
+     * **On Android:** This enables immersive mode.
+     * **On macOS:** A new desktop is used to display the running project.
+     * **Note:** Regardless of the platform, enabling full screen will change the window size to match the monitor's size. Therefore, make sure your project supports [multiple resolutions]($DOCS_URL/tutorials/rendering/multiple_resolutions.html) when enabling full screen mode.
+     */
+    MODE_FULLSCREEN: 3,
+    /**
+     * A single window full screen mode. This mode has less overhead, but only one window can be open on a given screen at a time (opening a child window or application switching will trigger a full screen transition).
+     * Full screen window covers the entire display area of a screen and has no border or decorations. The display's video mode is not changed.
+     * **Note:** This mode might not work with screen recording software.
+     * **On Android:** This enables immersive mode.
+     * **On Windows:** Depending on video driver, full screen transition might cause screens to go black for a moment.
+     * **On macOS:** A new desktop is used to display the running project. Exclusive full screen mode prevents Dock and Menu from showing up when the mouse pointer is hovering the edge of the screen.
+     * **On Linux (X11):** Exclusive full screen mode bypasses compositor.
+     * **On Linux (Wayland):** Equivalent to {@link MODE_FULLSCREEN}.
+     * **Note:** Regardless of the platform, enabling full screen will change the window size to match the monitor's size. Therefore, make sure your project supports [multiple resolutions]($DOCS_URL/tutorials/rendering/multiple_resolutions.html) when enabling full screen mode.
+     */
+    MODE_EXCLUSIVE_FULLSCREEN: 4,
+} as const;
+
+export type Mode = (typeof Mode)[keyof typeof Mode];
+
+export const Flags = {
+    /**
+     * The window can't be resized by dragging its resize grip. It's still possible to resize the window using {@link size}. This flag is ignored for full screen windows. Set with {@link unresizable}.
+     * **Note:** This flag is implemented on Linux (X11), macOS, Windows, and embedded windows.
+     */
+    FLAG_RESIZE_DISABLED: 0,
+    /**
+     * The window do not have native title bar and other decorations. This flag is ignored for full-screen windows. Set with {@link borderless}.
+     * **Note:** This flag is implemented on Linux (X11/Wayland), macOS, Windows, and embedded windows.
+     */
+    FLAG_BORDERLESS: 1,
+    /**
+     * The window is floating on top of all other windows. This flag is ignored for full-screen windows. Set with {@link alwaysOnTop}.
+     * **Note:** This flag is implemented on Linux (X11), macOS, Windows, and embedded windows.
+     */
+    FLAG_ALWAYS_ON_TOP: 2,
+    /**
+     * The window background can be transparent. Set with {@link transparent}.
+     * **Note:** This flag has no effect if either {@link ProjectSettings.display/window/perPixelTransparency/allowed}, or the window's {@link Viewport.transparentBg} is set to `false`.
+     * **Note:** Transparency support is implemented on Linux (X11/Wayland), macOS, Windows, and embedded windows.
+     */
+    FLAG_TRANSPARENT: 3,
+    /**
+     * The window can't be focused. No-focus window will ignore all input, except mouse clicks. Set with {@link unfocusable}.
+     * **Note:** This flag is implemented on Linux (X11), macOS, Windows, and embedded windows.
+     */
+    FLAG_NO_FOCUS: 4,
+    /**
+     * Window is part of menu or {@link OptionButton} dropdown. This flag can't be changed when the window is visible. An active popup window will exclusively receive all input, without stealing focus from its parent. Popup windows are automatically closed when uses click outside it, or when an application is switched. Popup window must have transient parent set (see {@link transient}).
+     * **Note:** This flag is implemented on Linux (X11/Wayland), macOS, Windows, and embedded {@link Popup} windows.
+     */
+    FLAG_POPUP: 5,
+    /**
+     * Window content is expanded to the full size of the window. Unlike borderless window, the frame is left intact and can be used to resize the window, title bar is transparent, but have minimize/maximize/close buttons. Set with {@link extendToTitle}.
+     * **Note:** This flag has no effect in embedded windows.
+     * **Note:** This flag is implemented only on macOS.
+     */
+    FLAG_EXTEND_TO_TITLE: 6,
+    /**
+     * All mouse events are passed to the underlying window of the same application.
+     * **Note:** This flag has no effect in embedded windows.
+     * **Note:** This flag is implemented on Linux (X11), macOS, Windows.
+     */
+    FLAG_MOUSE_PASSTHROUGH: 7,
+    /**
+     * Window style is overridden, forcing sharp corners.
+     * **Note:** This flag has no effect in embedded windows.
+     * **Note:** This flag is implemented only on Windows (11).
+     */
+    FLAG_SHARP_CORNERS: 8,
+    /**
+     * Windows is excluded from screenshots taken by {@link DisplayServer.screenGetImage}, {@link DisplayServer.screenGetImageRect}, and {@link DisplayServer.screenGetPixel}.
+     * **Note:** This flag has no effect in embedded windows.
+     * **Note:** This flag is implemented on macOS and Windows (10, 20H1).
+     * **Note:** Setting this flag will prevent standard screenshot methods from capturing a window image, but does **NOT** guarantee that other apps won't be able to capture an image. It should not be used as a DRM or security measure.
+     */
+    FLAG_EXCLUDE_FROM_CAPTURE: 9,
+    /**
+     * Signals the window manager that this window is supposed to be an implementation-defined "popup" (usually a floating, borderless, untileable and immovable child window).
+     * **Note:** This flag has no effect in embedded windows.
+     * **Note:** This flag is implemented on Linux (Wayland).
+     */
+    FLAG_POPUP_WM_HINT: 10,
+    /**
+     * Window minimize button is disabled.
+     * **Note:** This flag has no effect in embedded windows.
+     * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
+     */
+    FLAG_MINIMIZE_DISABLED: 11,
+    /**
+     * Window maximize button is disabled.
+     * **Note:** This flag has no effect in embedded windows.
+     * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
+     */
+    FLAG_MAXIMIZE_DISABLED: 12,
+    /**
+     * Max value of the {@link Flags}.
+     */
+    FLAG_MAX: 13,
+} as const;
+
+export type Flags = (typeof Flags)[keyof typeof Flags];
+
+export const ContentScaleMode = {
+    /**
+     * The content will not be scaled to match the {@link Window}'s size ({@link contentScaleSize} is ignored).
+     */
+    CONTENT_SCALE_MODE_DISABLED: 0,
+    /**
+     * The content will be rendered at the target size. This is more performance-expensive than {@link CONTENT_SCALE_MODE_VIEWPORT}, but provides better results.
+     */
+    CONTENT_SCALE_MODE_CANVAS_ITEMS: 1,
+    /**
+     * The content will be rendered at the base size and then scaled to the target size. More performant than {@link CONTENT_SCALE_MODE_CANVAS_ITEMS}, but results in pixelated image.
+     */
+    CONTENT_SCALE_MODE_VIEWPORT: 2,
+} as const;
+
+export type ContentScaleMode = (typeof ContentScaleMode)[keyof typeof ContentScaleMode];
+
+export const ContentScaleAspect = {
+    /**
+     * The aspect will be ignored. Scaling will simply stretch the content to fit the target size.
+     */
+    CONTENT_SCALE_ASPECT_IGNORE: 0,
+    /**
+     * The content's aspect will be preserved. If the target size has different aspect from the base one, the image will be centered and black bars will appear on left and right sides.
+     */
+    CONTENT_SCALE_ASPECT_KEEP: 1,
+    /**
+     * The content can be expanded vertically. Scaling horizontally will result in keeping the width ratio and then black bars on left and right sides.
+     */
+    CONTENT_SCALE_ASPECT_KEEP_WIDTH: 2,
+    /**
+     * The content can be expanded horizontally. Scaling vertically will result in keeping the height ratio and then black bars on top and bottom sides.
+     */
+    CONTENT_SCALE_ASPECT_KEEP_HEIGHT: 3,
+    /**
+     * The content's aspect will be preserved. If the target size has different aspect from the base one, the content will stay in the top-left corner and add an extra visible area in the stretched space.
+     */
+    CONTENT_SCALE_ASPECT_EXPAND: 4,
+} as const;
+
+export type ContentScaleAspect = (typeof ContentScaleAspect)[keyof typeof ContentScaleAspect];
+
+export const ContentScaleStretch = {
+    /**
+     * The content will be stretched according to a fractional factor. This fills all the space available in the window, but allows "pixel wobble" to occur due to uneven pixel scaling.
+     */
+    CONTENT_SCALE_STRETCH_FRACTIONAL: 0,
+    /**
+     * The content will be stretched only according to an integer factor, preserving sharp pixels. This may leave a black background visible on the window's edges depending on the window size.
+     */
+    CONTENT_SCALE_STRETCH_INTEGER: 1,
+} as const;
+
+export type ContentScaleStretch = (typeof ContentScaleStretch)[keyof typeof ContentScaleStretch];
+
+export const LayoutDirection = {
+    /**
+     * Automatic layout direction, determined from the parent window layout direction.
+     */
+    LAYOUT_DIRECTION_INHERITED: 0,
+    /**
+     * Automatic layout direction, determined from the current locale.
+     */
+    LAYOUT_DIRECTION_APPLICATION_LOCALE: 1,
+    /**
+     * Left-to-right layout direction.
+     */
+    LAYOUT_DIRECTION_LTR: 2,
+    /**
+     * Right-to-left layout direction.
+     */
+    LAYOUT_DIRECTION_RTL: 3,
+    /**
+     * Automatic layout direction, determined from the system locale.
+     */
+    LAYOUT_DIRECTION_SYSTEM_LOCALE: 4,
+    /**
+     * Represents the size of the {@link LayoutDirection} enum.
+     */
+    LAYOUT_DIRECTION_MAX: 5,
+    LAYOUT_DIRECTION_LOCALE: 1,
+} as const;
+
+export type LayoutDirection = (typeof LayoutDirection)[keyof typeof LayoutDirection];
+
+export const WindowInitialPosition = {
+    /**
+     * Initial window position is determined by {@link position}.
+     */
+    WINDOW_INITIAL_POSITION_ABSOLUTE: 0,
+    /**
+     * Initial window position is the center of the primary screen.
+     */
+    WINDOW_INITIAL_POSITION_CENTER_PRIMARY_SCREEN: 1,
+    /**
+     * Initial window position is the center of the main window screen.
+     */
+    WINDOW_INITIAL_POSITION_CENTER_MAIN_WINDOW_SCREEN: 2,
+    /**
+     * Initial window position is the center of {@link currentScreen} screen.
+     */
+    WINDOW_INITIAL_POSITION_CENTER_OTHER_SCREEN: 3,
+    /**
+     * Initial window position is the center of the screen containing the mouse pointer.
+     */
+    WINDOW_INITIAL_POSITION_CENTER_SCREEN_WITH_MOUSE_FOCUS: 4,
+    /**
+     * Initial window position is the center of the screen containing the window with the keyboard focus.
+     */
+    WINDOW_INITIAL_POSITION_CENTER_SCREEN_WITH_KEYBOARD_FOCUS: 5,
+} as const;
+
+export type WindowInitialPosition = (typeof WindowInitialPosition)[keyof typeof WindowInitialPosition];
+