typescript-to-gdscript 0.1.0

package/typings/classes/Texture2D.d.ts

@@ -0,0 +1,69 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture for 2D and 3D. */
+declare class Texture2D extends Texture {
+  /**
+   * Called when the entire {@link Texture2D} is requested to be drawn over a {@link CanvasItem}, with the top-left offset specified in `pos`. `modulate` specifies a multiplier for the colors being drawn, while `transpose` specifies whether drawing should be performed in column-major order instead of row-major order (resulting in 90-degree clockwise rotation).
+   * **Note:** This is only used in 2D rendering, not 3D.
+   */
+  _draw(to_canvas_item: RID, pos: Vector2 | Vector2i, modulate: Color, transpose: boolean): void;
+  /**
+   * Called when the {@link Texture2D} is requested to be drawn onto {@link CanvasItem}'s specified `rect`. `modulate` specifies a multiplier for the colors being drawn, while `transpose` specifies whether drawing should be performed in column-major order instead of row-major order (resulting in 90-degree clockwise rotation).
+   * **Note:** This is only used in 2D rendering, not 3D.
+   */
+  _draw_rect(to_canvas_item: RID, rect: Rect2 | Rect2i, tile: boolean, modulate: Color, transpose: boolean): void;
+  /**
+   * Called when a part of the {@link Texture2D} specified by `src_rect`'s coordinates is requested to be drawn onto {@link CanvasItem}'s specified `rect`. `modulate` specifies a multiplier for the colors being drawn, while `transpose` specifies whether drawing should be performed in column-major order instead of row-major order (resulting in 90-degree clockwise rotation).
+   * **Note:** This is only used in 2D rendering, not 3D.
+   */
+  _draw_rect_region(to_canvas_item: RID, rect: Rect2 | Rect2i, src_rect: Rect2 | Rect2i, modulate: Color, transpose: boolean, clip_uv: boolean): void;
+  /** Called when {@link get_format} is called. */
+  _get_format(): int;
+  /** Called when the {@link Texture2D}'s height is queried. */
+  _get_height(): int;
+  /** Called when {@link get_image} is called. */
+  _get_image(): Image | null;
+  /** Called when {@link get_mipmap_count} is called. */
+  _get_mipmap_count(): int;
+  /** Called when the {@link Texture2D}'s width is queried. */
+  _get_width(): int;
+  /** Called when the presence of an alpha channel in the {@link Texture2D} is queried. */
+  _has_alpha(): boolean;
+  /** Called when {@link has_mipmaps} is called. */
+  _has_mipmaps(): boolean;
+  /**
+   * Called when a pixel's opaque state in the {@link Texture2D} is queried at the specified `(x, y)` position.
+   */
+  _is_pixel_opaque(x: int, y: int): boolean;
+  /** Creates a placeholder version of this resource ({@link PlaceholderTexture2D}). */
+  create_placeholder(): Resource;
+  /**
+   * Draws the texture using a {@link CanvasItem} with the {@link RenderingServer} API at the specified `position`.
+   */
+  draw(canvas_item: RID, position: Vector2 | Vector2i, modulate?: Color, transpose?: boolean): void;
+  /** Draws the texture using a {@link CanvasItem} with the {@link RenderingServer} API. */
+  draw_rect(canvas_item: RID, rect: Rect2 | Rect2i, tile: boolean, modulate?: Color, transpose?: boolean): void;
+  /** Draws a part of the texture using a {@link CanvasItem} with the {@link RenderingServer} API. */
+  draw_rect_region(canvas_item: RID, rect: Rect2 | Rect2i, src_rect: Rect2 | Rect2i, modulate?: Color, transpose?: boolean, clip_uv?: boolean): void;
+  /** Returns the image format of the texture. */
+  get_format(): int;
+  /** Returns the texture height in pixels. */
+  get_height(): int;
+  /**
+   * Returns an {@link Image} that is a copy of data from this {@link Texture2D} (a new {@link Image} is created each time). {@link Image}s can be accessed and manipulated directly.
+   * **Note:** This will return `null` if this {@link Texture2D} is invalid.
+   * **Note:** This will fetch the texture data from the GPU, which might cause performance problems when overused. Avoid calling {@link get_image} every frame, especially on large textures.
+   */
+  get_image(): Image | null;
+  /** Returns the number of mipmaps of the texture. */
+  get_mipmap_count(): int;
+  /** Returns the texture size in pixels. */
+  get_size(): Vector2;
+  /** Returns the texture width in pixels. */
+  get_width(): int;
+  /** Returns `true` if this {@link Texture2D} has an alpha channel. */
+  has_alpha(): boolean;
+  /** Returns `true` if the texture has mipmaps. */
+  has_mipmaps(): boolean;
+}

package/typings/classes/Texture2DArray.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A single texture resource which consists of multiple, separate images. Each image has the same dimensions and number of mipmap levels.
+ */
+declare class Texture2DArray extends ImageTextureLayered {
+  /** Creates a placeholder version of this resource ({@link PlaceholderTexture2DArray}). */
+  create_placeholder(): Resource;
+}

package/typings/classes/Texture2DArrayRD.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture Array for 2D that is bound to a texture created on the {@link RenderingDevice}. */
+declare class Texture2DArrayRD extends TextureLayeredRD {
+}

package/typings/classes/Texture2DRD.d.ts

@@ -0,0 +1,11 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture for 2D that is bound to a texture created on the {@link RenderingDevice}. */
+declare class Texture2DRD extends Texture2D {
+  /**
+   * <member name="texture_rd_rid" type="RID" setter="set_texture_rd_rid" getter="get_texture_rd_rid">
+   * The RID of the texture object created on the {@link RenderingDevice}.
+   */
+  resource_local_to_scene: boolean;
+}

package/typings/classes/Texture3D.d.ts

@@ -0,0 +1,36 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for 3-dimensional textures. */
+declare class Texture3D extends Texture {
+  /** Called when the {@link Texture3D}'s data is queried. */
+  _get_data(): Array<Image>;
+  /** Called when the {@link Texture3D}'s depth is queried. */
+  _get_depth(): int;
+  /** Called when the {@link Texture3D}'s format is queried. */
+  _get_format(): int;
+  /** Called when the {@link Texture3D}'s height is queried. */
+  _get_height(): int;
+  /** Called when the {@link Texture3D}'s width is queried. */
+  _get_width(): int;
+  /** Called when the presence of mipmaps in the {@link Texture3D} is queried. */
+  _has_mipmaps(): boolean;
+  /** Creates a placeholder version of this resource ({@link PlaceholderTexture3D}). */
+  create_placeholder(): Resource;
+  /**
+   * Returns the {@link Texture3D}'s data as an array of {@link Image}s. Each {@link Image} represents a *slice* of the {@link Texture3D}, with different slices mapping to different depth (Z axis) levels.
+   */
+  get_data(): Array<Image>;
+  /**
+   * Returns the {@link Texture3D}'s depth in pixels. Depth is typically represented by the Z axis (a dimension not present in {@link Texture2D}).
+   */
+  get_depth(): int;
+  /** Returns the current format being used by this texture. */
+  get_format(): int;
+  /** Returns the {@link Texture3D}'s height in pixels. Width is typically represented by the Y axis. */
+  get_height(): int;
+  /** Returns the {@link Texture3D}'s width in pixels. Width is typically represented by the X axis. */
+  get_width(): int;
+  /** Returns `true` if the {@link Texture3D} has generated mipmaps. */
+  has_mipmaps(): boolean;
+}

package/typings/classes/Texture3DRD.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture for 3D that is bound to a texture created on the {@link RenderingDevice}. */
+declare class Texture3DRD extends Texture3D {
+  /** The RID of the texture object created on the {@link RenderingDevice}. */
+  texture_rd_rid: RID;
+  set_texture_rd_rid(value: RID): void;
+  get_texture_rd_rid(): RID;
+}

package/typings/classes/TextureButton.d.ts

@@ -0,0 +1,80 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture-based button. Supports Pressed, Hover, Disabled and Focused states. */
+declare class TextureButton extends BaseButton {
+  /** If `true`, texture is flipped horizontally. */
+  flip_h: boolean;
+  /** If `true`, texture is flipped vertically. */
+  flip_v: boolean;
+  /**
+   * If `true`, the size of the texture won't be considered for minimum size calculation, so the {@link TextureButton} can be shrunk down past the texture size.
+   */
+  ignore_texture_size: boolean;
+  /**
+   * Controls the texture's behavior when you resize the node's bounding rectangle. See the {@link StretchMode} constants for available options.
+   */
+  stretch_mode: int;
+  /**
+   * Pure black and white {@link BitMap} image to use for click detection. On the mask, white pixels represent the button's clickable area. Use it to create buttons with curved shapes.
+   */
+  texture_click_mask: BitMap | null;
+  /**
+   * Texture to display when the node is disabled. See {@link BaseButton.disabled}. If not assigned, the {@link TextureButton} displays {@link texture_normal} instead.
+   */
+  texture_disabled: Texture2D | null;
+  /**
+   * Texture to *overlay on the base texture* when the node has mouse or keyboard focus. Because {@link texture_focused} is displayed on top of the base texture, a partially transparent texture should be used to ensure the base texture remains visible. A texture that represents an outline or an underline works well for this purpose. To disable the focus visual effect, assign a fully transparent texture of any size. Note that disabling the focus visual effect will harm keyboard/controller navigation usability, so this is not recommended for accessibility reasons.
+   */
+  texture_focused: Texture2D | null;
+  /**
+   * Texture to display when the mouse hovers over the node. If not assigned, the {@link TextureButton} displays {@link texture_normal} instead when hovered over.
+   */
+  texture_hover: Texture2D | null;
+  /**
+   * Texture to display by default, when the node is **not** in the disabled, hover or pressed state. This texture is still displayed in the focused state, with {@link texture_focused} drawn on top.
+   */
+  texture_normal: Texture2D | null;
+  /**
+   * Texture to display on mouse down over the node, if the node has keyboard focus and the player presses the Enter key or if the player presses the {@link BaseButton.shortcut} key. If not assigned, the {@link TextureButton} displays {@link texture_hover} instead when pressed.
+   */
+  texture_pressed: Texture2D | null;
+  set_flip_h(value: boolean): void;
+  is_flipped_h(): boolean;
+  set_flip_v(value: boolean): void;
+  is_flipped_v(): boolean;
+  set_ignore_texture_size(value: boolean): void;
+  get_ignore_texture_size(): boolean;
+  set_stretch_mode(value: int): void;
+  get_stretch_mode(): int;
+  set_click_mask(value: BitMap | null): void;
+  get_click_mask(): BitMap | null;
+  set_texture_disabled(value: Texture2D | null): void;
+  get_texture_disabled(): Texture2D | null;
+  set_texture_focused(value: Texture2D | null): void;
+  get_texture_focused(): Texture2D | null;
+  set_texture_hover(value: Texture2D | null): void;
+  get_texture_hover(): Texture2D | null;
+  set_texture_normal(value: Texture2D | null): void;
+  get_texture_normal(): Texture2D | null;
+  set_texture_pressed(value: Texture2D | null): void;
+  get_texture_pressed(): Texture2D | null;
+
+  // enum StretchMode
+  /** Scale to fit the node's bounding rectangle. */
+  static readonly STRETCH_SCALE: int;
+  /** Tile inside the node's bounding rectangle. */
+  static readonly STRETCH_TILE: int;
+  /** The texture keeps its original size and stays in the bounding rectangle's top-left corner. */
+  static readonly STRETCH_KEEP: int;
+  /** The texture keeps its original size and stays centered in the node's bounding rectangle. */
+  static readonly STRETCH_KEEP_CENTERED: int;
+  /** Scale the texture to fit the node's bounding rectangle, but maintain the texture's aspect ratio. */
+  static readonly STRETCH_KEEP_ASPECT: int;
+  /** Scale the texture to fit the node's bounding rectangle, center it, and maintain its aspect ratio. */
+  static readonly STRETCH_KEEP_ASPECT_CENTERED: int;
+  /**
+   * Scale the texture so that the shorter side fits the bounding rectangle. The other side clips to the node's limits.
+   */
+  static readonly STRETCH_KEEP_ASPECT_COVERED: int;
+}

package/typings/classes/TextureCubemapArrayRD.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture Array for Cubemaps that is bound to a texture created on the {@link RenderingDevice}. */
+declare class TextureCubemapArrayRD extends TextureLayeredRD {
+}

package/typings/classes/TextureCubemapRD.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture for Cubemap that is bound to a texture created on the {@link RenderingDevice}. */
+declare class TextureCubemapRD extends TextureLayeredRD {
+}

package/typings/classes/TextureLayered.d.ts

@@ -0,0 +1,46 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Base class for texture types which contain the data of multiple {@link Image}s. Each image is of the same size and format.
+ */
+declare class TextureLayered extends Texture {
+  /** Called when the {@link TextureLayered}'s format is queried. */
+  _get_format(): int;
+  /** Called when the {@link TextureLayered}'s height is queried. */
+  _get_height(): int;
+  /** Called when the data for a layer in the {@link TextureLayered} is queried. */
+  _get_layer_data(layer_index: int): Image | null;
+  /** Called when the layers' type in the {@link TextureLayered} is queried. */
+  _get_layered_type(): int;
+  /** Called when the number of layers in the {@link TextureLayered} is queried. */
+  _get_layers(): int;
+  /** Called when the {@link TextureLayered}'s width queried. */
+  _get_width(): int;
+  /** Called when the presence of mipmaps in the {@link TextureLayered} is queried. */
+  _has_mipmaps(): boolean;
+  /** Returns the current format being used by this texture. */
+  get_format(): int;
+  /** Returns the height of the texture in pixels. Height is typically represented by the Y axis. */
+  get_height(): int;
+  /** Returns an {@link Image} resource with the data from specified `layer`. */
+  get_layer_data(layer: int): Image | null;
+  /**
+   * Returns the {@link TextureLayered}'s type. The type determines how the data is accessed, with cubemaps having special types.
+   */
+  get_layered_type(): int;
+  /** Returns the number of referenced {@link Image}s. */
+  get_layers(): int;
+  /** Returns the width of the texture in pixels. Width is typically represented by the X axis. */
+  get_width(): int;
+  /** Returns `true` if the layers have generated mipmaps. */
+  has_mipmaps(): boolean;
+
+  // enum LayeredType
+  /** Texture is a generic {@link Texture2DArray}. */
+  static readonly LAYERED_TYPE_2D_ARRAY: int;
+  /** Texture is a {@link Cubemap}, with each side in its own layer (6 in total). */
+  static readonly LAYERED_TYPE_CUBEMAP: int;
+  /** Texture is a {@link CubemapArray}, with each cubemap being made of 6 layers. */
+  static readonly LAYERED_TYPE_CUBEMAP_ARRAY: int;
+}

package/typings/classes/TextureLayeredRD.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for layered texture RD types. */
+declare class TextureLayeredRD extends TextureLayered {
+  /** The RID of the texture object created on the {@link RenderingDevice}. */
+  texture_rd_rid: RID;
+  set_texture_rd_rid(value: RID): void;
+  get_texture_rd_rid(): RID;
+}

package/typings/classes/TextureProgressBar.d.ts

@@ -0,0 +1,120 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture-based progress bar. Useful for loading screens and life or stamina bars. */
+declare class TextureProgressBar extends Range {
+  /** The fill direction. See {@link FillMode} for possible values. */
+  fill_mode: int;
+  /**
+   * <member name="nine_patch_stretch" type="bool" setter="set_nine_patch_stretch" getter="get_nine_patch_stretch" default="false">
+   * If `true`, Godot treats the bar's textures like in {@link NinePatchRect}. Use the `stretch_margin_*` properties like {@link stretch_margin_bottom} to set up the nine patch's 3×3 grid. When using a radial {@link fill_mode}, this setting will only enable stretching for {@link texture_progress}, while {@link texture_under} and {@link texture_over} will be treated like in {@link NinePatchRect}.
+   */
+  mouse_filter: int;
+  /**
+   * Offsets {@link texture_progress} if {@link fill_mode} is {@link FILL_CLOCKWISE}, {@link FILL_COUNTER_CLOCKWISE}, or {@link FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE}.
+   * **Note:** The effective radial center always stays within the {@link texture_progress} bounds. If you need to move it outside the texture's bounds, modify the {@link texture_progress} to contain additional empty space where needed.
+   */
+  radial_center_offset: Vector2;
+  /**
+   * Upper limit for the fill of {@link texture_progress} if {@link fill_mode} is {@link FILL_CLOCKWISE}, {@link FILL_COUNTER_CLOCKWISE}, or {@link FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE}. When the node's `value` is equal to its `max_value`, the texture fills up to this angle.
+   * See {@link Range.value}, {@link Range.max_value}.
+   */
+  radial_fill_degrees: float;
+  /**
+   * Starting angle for the fill of {@link texture_progress} if {@link fill_mode} is {@link FILL_CLOCKWISE}, {@link FILL_COUNTER_CLOCKWISE}, or {@link FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE}. When the node's `value` is equal to its `min_value`, the texture doesn't show up at all. When the `value` increases, the texture fills and tends towards {@link radial_fill_degrees}.
+   * **Note:** {@link radial_initial_angle} is wrapped between `0` and `360` degrees (inclusive).
+   */
+  radial_initial_angle: float;
+  /**
+   * <member name="step" type="float" setter="set_step" getter="get_step" overrides="Range" default="1.0" />
+   * <member name="stretch_margin_bottom" type="int" setter="set_stretch_margin" getter="get_stretch_margin" default="0">
+   * The height of the 9-patch's bottom row. A margin of 16 means the 9-slice's bottom corners and side will have a height of 16 pixels. You can set all 4 margin values individually to create panels with non-uniform borders. Only effective if {@link nine_patch_stretch} is `true`.
+   */
+  size_flags_vertical: int;
+  /** The width of the 9-patch's left column. Only effective if {@link nine_patch_stretch} is `true`. */
+  stretch_margin_left: int;
+  /** The width of the 9-patch's right column. Only effective if {@link nine_patch_stretch} is `true`. */
+  stretch_margin_right: int;
+  /** The height of the 9-patch's top row. Only effective if {@link nine_patch_stretch} is `true`. */
+  stretch_margin_top: int;
+  /**
+   * {@link Texture2D} that draws over the progress bar. Use it to add highlights or an upper-frame that hides part of {@link texture_progress}.
+   */
+  texture_over: Texture2D | null;
+  /**
+   * {@link Texture2D} that clips based on the node's `value` and {@link fill_mode}. As `value` increased, the texture fills up. It shows entirely when `value` reaches `max_value`. It doesn't show at all if `value` is equal to `min_value`.
+   * The `value` property comes from {@link Range}. See {@link Range.value}, {@link Range.min_value}, {@link Range.max_value}.
+   */
+  texture_progress: Texture2D | null;
+  /**
+   * The offset of {@link texture_progress}. Useful for {@link texture_over} and {@link texture_under} with fancy borders, to avoid transparent margins in your progress texture.
+   */
+  texture_progress_offset: Vector2;
+  /** {@link Texture2D} that draws under the progress bar. The bar's background. */
+  texture_under: Texture2D | null;
+  /**
+   * Multiplies the color of the bar's {@link texture_over} texture. The effect is similar to {@link CanvasItem.modulate}, except it only affects this specific texture instead of the entire node.
+   */
+  tint_over: Color;
+  /** Multiplies the color of the bar's {@link texture_progress} texture. */
+  tint_progress: Color;
+  /** Multiplies the color of the bar's {@link texture_under} texture. */
+  tint_under: Color;
+  set_fill_mode(value: int): void;
+  get_fill_mode(): int;
+  set_radial_center_offset(value: Vector2 | Vector2i): void;
+  get_radial_center_offset(): Vector2;
+  set_fill_degrees(value: float): void;
+  get_fill_degrees(): float;
+  set_radial_initial_angle(value: float): void;
+  get_radial_initial_angle(): float;
+  set_over_texture(value: Texture2D | null): void;
+  get_over_texture(): Texture2D | null;
+  set_progress_texture(value: Texture2D | null): void;
+  get_progress_texture(): Texture2D | null;
+  set_texture_progress_offset(value: Vector2 | Vector2i): void;
+  get_texture_progress_offset(): Vector2;
+  set_under_texture(value: Texture2D | null): void;
+  get_under_texture(): Texture2D | null;
+  set_tint_over(value: Color): void;
+  get_tint_over(): Color;
+  set_tint_progress(value: Color): void;
+  get_tint_progress(): Color;
+  set_tint_under(value: Color): void;
+  get_tint_under(): Color;
+
+  /**
+   * Returns the stretch margin with the specified index. See {@link stretch_margin_bottom} and related properties.
+   */
+  get_stretch_margin(margin: int): int;
+  /**
+   * Sets the stretch margin with the specified index. See {@link stretch_margin_bottom} and related properties.
+   */
+  set_stretch_margin(margin: int, value: int): void;
+
+  // enum FillMode
+  /** The {@link texture_progress} fills from left to right. */
+  static readonly FILL_LEFT_TO_RIGHT: int;
+  /** The {@link texture_progress} fills from right to left. */
+  static readonly FILL_RIGHT_TO_LEFT: int;
+  /** The {@link texture_progress} fills from top to bottom. */
+  static readonly FILL_TOP_TO_BOTTOM: int;
+  /** The {@link texture_progress} fills from bottom to top. */
+  static readonly FILL_BOTTOM_TO_TOP: int;
+  /**
+   * Turns the node into a radial bar. The {@link texture_progress} fills clockwise. See {@link radial_center_offset}, {@link radial_initial_angle} and {@link radial_fill_degrees} to control the way the bar fills up.
+   */
+  static readonly FILL_CLOCKWISE: int;
+  /**
+   * Turns the node into a radial bar. The {@link texture_progress} fills counterclockwise. See {@link radial_center_offset}, {@link radial_initial_angle} and {@link radial_fill_degrees} to control the way the bar fills up.
+   */
+  static readonly FILL_COUNTER_CLOCKWISE: int;
+  /** The {@link texture_progress} fills from the center, expanding both towards the left and the right. */
+  static readonly FILL_BILINEAR_LEFT_AND_RIGHT: int;
+  /** The {@link texture_progress} fills from the center, expanding both towards the top and the bottom. */
+  static readonly FILL_BILINEAR_TOP_AND_BOTTOM: int;
+  /**
+   * Turns the node into a radial bar. The {@link texture_progress} fills radially from the center, expanding both clockwise and counterclockwise. See {@link radial_center_offset}, {@link radial_initial_angle} and {@link radial_fill_degrees} to control the way the bar fills up.
+   */
+  static readonly FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE: int;
+}

package/typings/classes/TextureRect.d.ts

@@ -0,0 +1,69 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A control that displays a texture. */
+declare class TextureRect extends Control {
+  /** Defines how minimum size is determined based on the texture's size. */
+  expand_mode: int;
+  /** If `true`, texture is flipped horizontally. */
+  flip_h: boolean;
+  /** If `true`, texture is flipped vertically. */
+  flip_v: boolean;
+  /**
+   * <member name="stretch_mode" type="int" setter="set_stretch_mode" getter="get_stretch_mode" enum="TextureRect.StretchMode" default="0">
+   * Controls the texture's behavior when resizing the node's bounding rectangle.
+   */
+  mouse_filter: int;
+  /** The node's {@link Texture2D} resource. */
+  texture: Texture2D | null;
+  set_expand_mode(value: int): void;
+  get_expand_mode(): int;
+  set_flip_h(value: boolean): void;
+  is_flipped_h(): boolean;
+  set_flip_v(value: boolean): void;
+  is_flipped_v(): boolean;
+  set_texture(value: Texture2D | null): void;
+  get_texture(): Texture2D | null;
+
+  // enum ExpandMode
+  /**
+   * The minimum size will be equal to texture size, i.e. {@link TextureRect} can't be smaller than the texture.
+   */
+  static readonly EXPAND_KEEP_SIZE: int;
+  /**
+   * The size of the texture won't be considered for minimum size calculation, so the {@link TextureRect} can be shrunk down past the texture size.
+   */
+  static readonly EXPAND_IGNORE_SIZE: int;
+  /**
+   * The height of the texture will be ignored. Minimum width will be equal to the current height. Useful for horizontal layouts, e.g. inside {@link HBoxContainer}.
+   */
+  static readonly EXPAND_FIT_WIDTH: int;
+  /** Same as {@link EXPAND_FIT_WIDTH}, but keeps texture's aspect ratio. */
+  static readonly EXPAND_FIT_WIDTH_PROPORTIONAL: int;
+  /**
+   * The width of the texture will be ignored. Minimum height will be equal to the current width. Useful for vertical layouts, e.g. inside {@link VBoxContainer}.
+   */
+  static readonly EXPAND_FIT_HEIGHT: int;
+  /** Same as {@link EXPAND_FIT_HEIGHT}, but keeps texture's aspect ratio. */
+  static readonly EXPAND_FIT_HEIGHT_PROPORTIONAL: int;
+  // enum StretchMode
+  /** Scale to fit the node's bounding rectangle. */
+  static readonly STRETCH_SCALE: int;
+  /**
+   * Tile inside the node's bounding rectangle.
+   * **Note:** {@link STRETCH_TILE} mode is not supported for {@link texture} set to an {@link AtlasTexture} with non-zero {@link AtlasTexture.margin}.
+   */
+  static readonly STRETCH_TILE: int;
+  /** The texture keeps its original size and stays in the bounding rectangle's top-left corner. */
+  static readonly STRETCH_KEEP: int;
+  /** The texture keeps its original size and stays centered in the node's bounding rectangle. */
+  static readonly STRETCH_KEEP_CENTERED: int;
+  /** Scale the texture to fit the node's bounding rectangle, but maintain the texture's aspect ratio. */
+  static readonly STRETCH_KEEP_ASPECT: int;
+  /** Scale the texture to fit the node's bounding rectangle, center it and maintain its aspect ratio. */
+  static readonly STRETCH_KEEP_ASPECT_CENTERED: int;
+  /**
+   * Scale the texture so that the shorter side fits the bounding rectangle. The other side clips to the node's limits.
+   */
+  static readonly STRETCH_KEEP_ASPECT_COVERED: int;
+}