typescript-to-gdscript 0.1.0

package/typings/classes/Joint3D.d.ts

@@ -0,0 +1,34 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for all 3D physics joints. */
+declare class Joint3D extends Node3D {
+  /** If `true`, the two bodies bound together do not collide with each other. */
+  exclude_nodes_from_collision: boolean;
+  /**
+   * Path to the first node (A) attached to the joint. The node must inherit {@link PhysicsBody3D}.
+   * If left empty and {@link node_b} is set, the body is attached to a fixed {@link StaticBody3D} without collision shapes.
+   */
+  node_a: NodePath;
+  /**
+   * Path to the second node (B) attached to the joint. The node must inherit {@link PhysicsBody3D}.
+   * If left empty and {@link node_a} is set, the body is attached to a fixed {@link StaticBody3D} without collision shapes.
+   */
+  node_b: NodePath;
+  /**
+   * The priority used to define which solver is executed first for multiple joints. The lower the value, the higher the priority.
+   * **Note:** Only supported when using GodotPhysics3D. This property is ignored when using Jolt Physics.
+   */
+  solver_priority: int;
+  set_exclude_nodes_from_collision(value: boolean): void;
+  get_exclude_nodes_from_collision(): boolean;
+  set_node_a(value: NodePath | string): void;
+  get_node_a(): NodePath;
+  set_node_b(value: NodePath | string): void;
+  get_node_b(): NodePath;
+  set_solver_priority(value: int): void;
+  get_solver_priority(): int;
+
+  /** Returns the joint's internal {@link RID} from the {@link PhysicsServer3D}. */
+  get_rid(): RID;
+}

package/typings/classes/JointLimitation3D.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A base class of the limitation that interacts with {@link ChainIK3D}. */
+declare class JointLimitation3D extends Resource {
+}

package/typings/classes/JointLimitationCone3D.d.ts

@@ -0,0 +1,13 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A cone shape limitation that interacts with {@link ChainIK3D}. */
+declare class JointLimitationCone3D extends JointLimitation3D {
+  /**
+   * The radius range of the hole made by the cone.
+   * `0` degrees makes a sphere without hole, `180` degrees makes a hemisphere, and `360` degrees become empty (no limitation).
+   */
+  angle: float;
+  set_angle(value: float): void;
+  get_angle(): float;
+}

package/typings/classes/KinematicCollision2D.d.ts

@@ -0,0 +1,36 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Holds collision data from the movement of a {@link PhysicsBody2D}. */
+declare class KinematicCollision2D extends RefCounted {
+  /**
+   * Returns the collision angle according to `up_direction`, which is {@link Vector2.UP} by default. This value is always positive.
+   */
+  get_angle(up_direction?: Vector2 | Vector2i): float;
+  /** Returns the colliding body's attached {@link Object}. */
+  get_collider(): GodotObject | null;
+  /**
+   * Returns the unique instance ID of the colliding body's attached {@link Object}. See {@link Object.get_instance_id}.
+   */
+  get_collider_id(): int;
+  /** Returns the colliding body's {@link RID} used by the {@link PhysicsServer2D}. */
+  get_collider_rid(): RID;
+  /** Returns the colliding body's shape. */
+  get_collider_shape(): GodotObject | null;
+  /** Returns the colliding body's shape index. See {@link CollisionObject2D}. */
+  get_collider_shape_index(): int;
+  /** Returns the colliding body's velocity. */
+  get_collider_velocity(): Vector2;
+  /** Returns the colliding body's length of overlap along the collision normal. */
+  get_depth(): float;
+  /** Returns the moving object's colliding shape. */
+  get_local_shape(): GodotObject | null;
+  /** Returns the colliding body's shape's normal at the point of collision. */
+  get_normal(): Vector2;
+  /** Returns the point of collision in global coordinates. */
+  get_position(): Vector2;
+  /** Returns the moving object's remaining movement vector. */
+  get_remainder(): Vector2;
+  /** Returns the moving object's travel before collision. */
+  get_travel(): Vector2;
+}

package/typings/classes/KinematicCollision3D.d.ts

@@ -0,0 +1,50 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Holds collision data from the movement of a {@link PhysicsBody3D}. */
+declare class KinematicCollision3D extends RefCounted {
+  /**
+   * Returns the collision angle according to `up_direction`, which is {@link Vector3.UP} by default. This value is always positive.
+   */
+  get_angle(collision_index?: int, up_direction?: Vector3 | Vector3i): float;
+  /**
+   * Returns the colliding body's attached {@link Object} given a collision index (the deepest collision by default).
+   */
+  get_collider(collision_index?: int): GodotObject | null;
+  /**
+   * Returns the unique instance ID of the colliding body's attached {@link Object} given a collision index (the deepest collision by default). See {@link Object.get_instance_id}.
+   */
+  get_collider_id(collision_index?: int): int;
+  /**
+   * Returns the colliding body's {@link RID} used by the {@link PhysicsServer3D} given a collision index (the deepest collision by default).
+   */
+  get_collider_rid(collision_index?: int): RID;
+  /** Returns the colliding body's shape given a collision index (the deepest collision by default). */
+  get_collider_shape(collision_index?: int): GodotObject | null;
+  /**
+   * Returns the colliding body's shape index given a collision index (the deepest collision by default). See {@link CollisionObject3D}.
+   */
+  get_collider_shape_index(collision_index?: int): int;
+  /** Returns the colliding body's velocity given a collision index (the deepest collision by default). */
+  get_collider_velocity(collision_index?: int): Vector3;
+  /** Returns the number of detected collisions. */
+  get_collision_count(): int;
+  /** Returns the colliding body's length of overlap along the collision normal. */
+  get_depth(): float;
+  /**
+   * Returns the moving object's colliding shape given a collision index (the deepest collision by default).
+   */
+  get_local_shape(collision_index?: int): GodotObject | null;
+  /**
+   * Returns the colliding body's shape's normal at the point of collision given a collision index (the deepest collision by default).
+   */
+  get_normal(collision_index?: int): Vector3;
+  /**
+   * Returns the point of collision in global coordinates given a collision index (the deepest collision by default).
+   */
+  get_position(collision_index?: int): Vector3;
+  /** Returns the moving object's remaining movement vector. */
+  get_remainder(): Vector3;
+  /** Returns the moving object's travel before collision. */
+  get_travel(): Vector3;
+}

package/typings/classes/Label.d.ts

@@ -0,0 +1,134 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A control for displaying plain text. */
+declare class Label extends Control {
+  /**
+   * If set to something other than {@link TextServer.AUTOWRAP_OFF}, the text gets wrapped inside the node's bounding rectangle. If you resize the node, it will change its height automatically to show all the text.
+   */
+  autowrap_mode: int;
+  /**
+   * Autowrap space trimming flags. See {@link TextServer.BREAK_TRIM_START_EDGE_SPACES} and {@link TextServer.BREAK_TRIM_END_EDGE_SPACES} for more info.
+   */
+  autowrap_trim_flags: int;
+  /**
+   * If `true`, the Label only shows the text that fits inside its bounding rectangle and will clip text horizontally.
+   */
+  clip_text: boolean;
+  /** Ellipsis character used for text clipping. */
+  ellipsis_char: string;
+  /**
+   * Controls the text's horizontal alignment. Supports left, center, right, and fill (also known as justify).
+   */
+  horizontal_alignment: int;
+  /** Line fill alignment rules. */
+  justification_flags: int;
+  /**
+   * A {@link LabelSettings} resource that can be shared between multiple {@link Label} nodes. Takes priority over theme properties.
+   */
+  label_settings: LabelSettings | null;
+  /**
+   * Language code used for line-breaking and text shaping algorithms. If left empty, the current locale is used instead.
+   */
+  language: string;
+  /** The number of the lines ignored and not displayed from the start of the {@link text} value. */
+  lines_skipped: int;
+  /** Limits the lines of text the node shows on screen. */
+  max_lines_visible: int;
+  /**
+   * <member name="paragraph_separator" type="String" setter="set_paragraph_separator" getter="get_paragraph_separator" default="&quot;\\n&quot;">
+   * String used as a paragraph separator. Each paragraph is processed independently, in its own BiDi context.
+   */
+  mouse_filter: int;
+  /**
+   * <member name="structured_text_bidi_override" type="int" setter="set_structured_text_bidi_override" getter="get_structured_text_bidi_override" enum="TextServer.StructuredTextParser" default="0">
+   * Set BiDi algorithm override for the structured text.
+   */
+  size_flags_vertical: int;
+  /** Set additional options for BiDi override. */
+  structured_text_bidi_override_options: Array<unknown>;
+  /** Aligns text to the given tab-stops. */
+  tab_stops: PackedFloat32Array;
+  /** The text to display on screen. */
+  text: string;
+  /** Base text writing direction. */
+  text_direction: int;
+  /** The clipping behavior when the text exceeds the node's bounding rectangle. */
+  text_overrun_behavior: int;
+  /** If `true`, all the text displays as UPPERCASE. */
+  uppercase: boolean;
+  /** Controls the text's vertical alignment. Supports top, center, bottom, and fill. */
+  vertical_alignment: int;
+  /**
+   * The number of characters to display. If set to `-1`, all characters are displayed. This can be useful when animating the text appearing in a dialog box.
+   * **Note:** Setting this property updates {@link visible_ratio} accordingly.
+   * **Note:** Characters are counted as Unicode codepoints. A single visible grapheme may contain multiple codepoints (e.g. certain emoji use three codepoints). A single codepoint may contain two UTF-16 characters, which are used in C# strings.
+   */
+  visible_characters: int;
+  /** The clipping behavior when {@link visible_characters} or {@link visible_ratio} is set. */
+  visible_characters_behavior: int;
+  /**
+   * The fraction of characters to display, relative to the total number of characters (see {@link get_total_character_count}). If set to `1.0`, all characters are displayed. If set to `0.5`, only half of the characters will be displayed. This can be useful when animating the text appearing in a dialog box.
+   * **Note:** Setting this property updates {@link visible_characters} accordingly.
+   */
+  visible_ratio: float;
+  set_autowrap_mode(value: int): void;
+  get_autowrap_mode(): int;
+  set_autowrap_trim_flags(value: int): void;
+  get_autowrap_trim_flags(): int;
+  set_clip_text(value: boolean): void;
+  is_clipping_text(): boolean;
+  set_ellipsis_char(value: string | NodePath): void;
+  get_ellipsis_char(): string;
+  set_horizontal_alignment(value: int): void;
+  get_horizontal_alignment(): int;
+  set_justification_flags(value: int): void;
+  get_justification_flags(): int;
+  set_label_settings(value: LabelSettings | null): void;
+  get_label_settings(): LabelSettings | null;
+  set_language(value: string | NodePath): void;
+  get_language(): string;
+  set_lines_skipped(value: int): void;
+  get_lines_skipped(): int;
+  set_max_lines_visible(value: int): void;
+  get_max_lines_visible(): int;
+  set_structured_text_bidi_override_options(value: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  get_structured_text_bidi_override_options(): Array<unknown>;
+  set_tab_stops(value: PackedFloat32Array | Array<unknown>): void;
+  get_tab_stops(): PackedFloat32Array;
+  set_text(value: string | NodePath): void;
+  get_text(): string;
+  set_text_direction(value: int): void;
+  get_text_direction(): int;
+  set_text_overrun_behavior(value: int): void;
+  get_text_overrun_behavior(): int;
+  set_uppercase(value: boolean): void;
+  is_uppercase(): boolean;
+  set_vertical_alignment(value: int): void;
+  get_vertical_alignment(): int;
+  set_visible_characters(value: int): void;
+  get_visible_characters(): int;
+  set_visible_characters_behavior(value: int): void;
+  get_visible_characters_behavior(): int;
+  set_visible_ratio(value: float): void;
+  get_visible_ratio(): float;
+
+  /**
+   * Returns the bounding rectangle of the character at position `pos` in the label's local coordinate system. If the character is a non-visual character or `pos` is outside the valid range, an empty {@link Rect2} is returned. If the character is a part of a composite grapheme, the bounding rectangle of the whole grapheme is returned.
+   */
+  get_character_bounds(pos: int): Rect2;
+  /** Returns the number of lines of text the Label has. */
+  get_line_count(): int;
+  /**
+   * Returns the height of the line `line`.
+   * If `line` is set to `-1`, returns the biggest line height.
+   * If there are no lines, returns font size in pixels.
+   */
+  get_line_height(line?: int): int;
+  /** Returns the total number of printable characters in the text (excluding spaces and newlines). */
+  get_total_character_count(): int;
+  /**
+   * Returns the number of lines shown. Useful if the {@link Label}'s height cannot currently display all lines.
+   */
+  get_visible_line_count(): int;
+}

package/typings/classes/Label3D.d.ts

@@ -0,0 +1,202 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node for displaying plain text in 3D space. */
+declare class Label3D extends GeometryInstance3D {
+  /** Threshold at which antialiasing will be applied on the alpha channel. */
+  alpha_antialiasing_edge: float;
+  /** The type of alpha antialiasing to apply. */
+  alpha_antialiasing_mode: int;
+  /** The alpha cutting mode to use for the sprite. */
+  alpha_cut: int;
+  /** The hashing scale for Alpha Hash. Recommended values between `0` and `2`. */
+  alpha_hash_scale: float;
+  /** Threshold at which the alpha scissor will discard values. */
+  alpha_scissor_threshold: float;
+  /**
+   * If set to something other than {@link TextServer.AUTOWRAP_OFF}, the text gets wrapped inside the node's bounding rectangle. If you resize the node, it will change its height automatically to show all the text.
+   */
+  autowrap_mode: int;
+  /**
+   * Autowrap space trimming flags. See {@link TextServer.BREAK_TRIM_START_EDGE_SPACES} and {@link TextServer.BREAK_TRIM_END_EDGE_SPACES} for more info.
+   */
+  autowrap_trim_flags: int;
+  /** The billboard mode to use for the label. */
+  billboard: int;
+  /**
+   * <member name="double_sided" type="bool" setter="set_draw_flag" getter="get_draw_flag" default="true">
+   * If `true`, text can be seen from the back as well, if `false`, it is invisible when looking at it from behind.
+   */
+  cast_shadow: int;
+  /**
+   * If `true`, the label is rendered at the same size regardless of distance. The label's size on screen is the same as if the camera was `1.0` units away from the label's origin, regardless of the actual distance from the camera. The {@link Camera3D}'s field of view (or {@link Camera3D.size} when in orthogonal/frustum mode) still affects the size the label is drawn at.
+   */
+  fixed_size: boolean;
+  /** Font configuration used to display text. */
+  font: Font | null;
+  /**
+   * Font size of the {@link Label3D}'s text. To make the font look more detailed when up close, increase {@link font_size} while decreasing {@link pixel_size} at the same time.
+   * Higher font sizes require more time to render new characters, which can cause stuttering during gameplay.
+   */
+  font_size: int;
+  /**
+   * <member name="horizontal_alignment" type="int" setter="set_horizontal_alignment" getter="get_horizontal_alignment" enum="HorizontalAlignment" default="1">
+   * Controls the text's horizontal alignment. Supports left, center, right, and fill (also known as justify).
+   */
+  gi_mode: int;
+  /** Line fill alignment rules. */
+  justification_flags: int;
+  /**
+   * Language code used for line-breaking and text shaping algorithms. If left empty, the current locale is used instead.
+   */
+  language: string;
+  /**
+   * Additional vertical spacing between lines (in pixels), spacing is added to line descent. This value can be negative.
+   */
+  line_spacing: float;
+  /** Text {@link Color} of the {@link Label3D}. */
+  modulate: Color;
+  /** If `true`, depth testing is disabled and the object will be drawn in render order. */
+  no_depth_test: boolean;
+  /** The text drawing offset (in pixels). */
+  offset: Vector2;
+  /** The tint of text outline. */
+  outline_modulate: Color;
+  /**
+   * Sets the render priority for the text outline. Higher priority objects will be sorted in front of lower priority objects.
+   * **Note:** This only applies if {@link alpha_cut} is set to {@link ALPHA_CUT_DISABLED} (default value).
+   * **Note:** This only applies to sorting of transparent objects. This will not impact how transparent objects are sorted relative to opaque objects. This is because opaque objects are not sorted, while transparent objects are sorted from back to front (subject to priority).
+   */
+  outline_render_priority: int;
+  /** Text outline size. */
+  outline_size: int;
+  /**
+   * The size of one pixel's width on the label to scale it in 3D. To make the font look more detailed when up close, increase {@link font_size} while decreasing {@link pixel_size} at the same time.
+   */
+  pixel_size: float;
+  /**
+   * Sets the render priority for the text. Higher priority objects will be sorted in front of lower priority objects.
+   * **Note:** This only applies if {@link alpha_cut} is set to {@link ALPHA_CUT_DISABLED} (default value).
+   * **Note:** This only applies to sorting of transparent objects. This will not impact how transparent objects are sorted relative to opaque objects. This is because opaque objects are not sorted, while transparent objects are sorted from back to front (subject to priority).
+   */
+  render_priority: int;
+  /** If `true`, the {@link Light3D} in the {@link Environment} has effects on the label. */
+  shaded: boolean;
+  /** Set BiDi algorithm override for the structured text. */
+  structured_text_bidi_override: int;
+  /** Set additional options for BiDi override. */
+  structured_text_bidi_override_options: Array<unknown>;
+  /** The text to display on screen. */
+  text: string;
+  /** Base text writing direction. */
+  text_direction: int;
+  /** Filter flags for the texture. */
+  texture_filter: int;
+  /** If `true`, all the text displays as UPPERCASE. */
+  uppercase: boolean;
+  /** Controls the text's vertical alignment. Supports top, center, and bottom. */
+  vertical_alignment: int;
+  /** Text width (in pixels), used for autowrap and fill alignment. */
+  width: float;
+  set_alpha_antialiasing_edge(value: float): void;
+  get_alpha_antialiasing_edge(): float;
+  set_alpha_antialiasing(value: int): void;
+  get_alpha_antialiasing(): int;
+  set_alpha_cut_mode(value: int): void;
+  get_alpha_cut_mode(): int;
+  set_alpha_hash_scale(value: float): void;
+  get_alpha_hash_scale(): float;
+  set_alpha_scissor_threshold(value: float): void;
+  get_alpha_scissor_threshold(): float;
+  set_autowrap_mode(value: int): void;
+  get_autowrap_mode(): int;
+  set_autowrap_trim_flags(value: int): void;
+  get_autowrap_trim_flags(): int;
+  set_billboard_mode(value: int): void;
+  get_billboard_mode(): int;
+  set_font(value: Font | null): void;
+  get_font(): Font | null;
+  set_font_size(value: int): void;
+  get_font_size(): int;
+  set_justification_flags(value: int): void;
+  get_justification_flags(): int;
+  set_language(value: string | NodePath): void;
+  get_language(): string;
+  set_line_spacing(value: float): void;
+  get_line_spacing(): float;
+  set_modulate(value: Color): void;
+  get_modulate(): Color;
+  set_offset(value: Vector2 | Vector2i): void;
+  get_offset(): Vector2;
+  set_outline_modulate(value: Color): void;
+  get_outline_modulate(): Color;
+  set_outline_render_priority(value: int): void;
+  get_outline_render_priority(): int;
+  set_outline_size(value: int): void;
+  get_outline_size(): int;
+  set_pixel_size(value: float): void;
+  get_pixel_size(): float;
+  set_render_priority(value: int): void;
+  get_render_priority(): int;
+  set_structured_text_bidi_override(value: int): void;
+  get_structured_text_bidi_override(): int;
+  set_structured_text_bidi_override_options(value: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  get_structured_text_bidi_override_options(): Array<unknown>;
+  set_text(value: string | NodePath): void;
+  get_text(): string;
+  set_text_direction(value: int): void;
+  get_text_direction(): int;
+  set_texture_filter(value: int): void;
+  get_texture_filter(): int;
+  set_uppercase(value: boolean): void;
+  is_uppercase(): boolean;
+  set_vertical_alignment(value: int): void;
+  get_vertical_alignment(): int;
+  set_width(value: float): void;
+  get_width(): float;
+
+  /**
+   * Returns a {@link TriangleMesh} with the label's vertices following its current configuration (such as its {@link pixel_size}).
+   */
+  generate_triangle_mesh(): TriangleMesh | null;
+  /** Returns the value of the specified flag. */
+  get_draw_flag(flag: int): boolean;
+  /** If `true`, the specified `flag` will be enabled. */
+  set_draw_flag(flag: int, enabled: boolean): void;
+
+  // enum DrawFlags
+  /** If set, lights in the environment affect the label. */
+  static readonly FLAG_SHADED: int;
+  /**
+   * If set, text can be seen from the back as well. If not, the text is invisible when looking at it from behind.
+   */
+  static readonly FLAG_DOUBLE_SIDED: int;
+  /**
+   * Disables the depth test, so this object is drawn on top of all others. However, objects drawn after it in the draw order may cover it.
+   */
+  static readonly FLAG_DISABLE_DEPTH_TEST: int;
+  /** Label is scaled by depth so that it always appears the same size on screen. */
+  static readonly FLAG_FIXED_SIZE: int;
+  /** Represents the size of the {@link DrawFlags} enum. */
+  static readonly FLAG_MAX: int;
+  // enum AlphaCutMode
+  /**
+   * This mode performs standard alpha blending. It can display translucent areas, but transparency sorting issues may be visible when multiple transparent materials are overlapping. {@link GeometryInstance3D.cast_shadow} has no effect when this transparency mode is used; the {@link Label3D} will never cast shadows.
+   */
+  static readonly ALPHA_CUT_DISABLED: int;
+  /**
+   * This mode only allows fully transparent or fully opaque pixels. Harsh edges will be visible unless some form of screen-space antialiasing is enabled (see {@link ProjectSettings.rendering/anti_aliasing/quality/screen_space_aa}). This mode is also known as *alpha testing* or *1-bit transparency*.
+   * **Note:** This mode might have issues with anti-aliased fonts and outlines, try adjusting {@link alpha_scissor_threshold} or using MSDF font.
+   * **Note:** When using text with overlapping glyphs (e.g., cursive scripts), this mode might have transparency sorting issues between the main text and the outline.
+   */
+  static readonly ALPHA_CUT_DISCARD: int;
+  /**
+   * This mode draws fully opaque pixels in the depth prepass. This is slower than {@link ALPHA_CUT_DISABLED} or {@link ALPHA_CUT_DISCARD}, but it allows displaying translucent areas and smooth edges while using proper sorting.
+   * **Note:** When using text with overlapping glyphs (e.g., cursive scripts), this mode might have transparency sorting issues between the main text and the outline.
+   */
+  static readonly ALPHA_CUT_OPAQUE_PREPASS: int;
+  /**
+   * This mode draws cuts off all values below a spatially-deterministic threshold, the rest will remain opaque.
+   */
+  static readonly ALPHA_CUT_HASH: int;
+}

package/typings/classes/LabelSettings.d.ts

@@ -0,0 +1,93 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides common settings to customize the text in a {@link Label}. */
+declare class LabelSettings extends Resource {
+  /** {@link Font} used for the text. */
+  font: Font | null;
+  /** Color of the text. */
+  font_color: Color;
+  /** Size of the text. */
+  font_size: int;
+  /**
+   * Additional vertical spacing between lines (in pixels), spacing is added to line descent. This value can be negative.
+   */
+  line_spacing: float;
+  /** The color of the outline. */
+  outline_color: Color;
+  /** Text outline size. */
+  outline_size: int;
+  /** Vertical space between paragraphs. Added on top of {@link line_spacing}. */
+  paragraph_spacing: float;
+  /** Color of the shadow effect. If alpha is `0`, no shadow will be drawn. */
+  shadow_color: Color;
+  /** Offset of the shadow effect, in pixels. */
+  shadow_offset: Vector2;
+  /** Size of the shadow effect. */
+  shadow_size: int;
+  /** The number of stacked outlines. */
+  stacked_outline_count: int;
+  /** The number of stacked shadows. */
+  stacked_shadow_count: int;
+  set_font(value: Font | null): void;
+  get_font(): Font | null;
+  set_font_color(value: Color): void;
+  get_font_color(): Color;
+  set_font_size(value: int): void;
+  get_font_size(): int;
+  set_line_spacing(value: float): void;
+  get_line_spacing(): float;
+  set_outline_color(value: Color): void;
+  get_outline_color(): Color;
+  set_outline_size(value: int): void;
+  get_outline_size(): int;
+  set_paragraph_spacing(value: float): void;
+  get_paragraph_spacing(): float;
+  set_shadow_color(value: Color): void;
+  get_shadow_color(): Color;
+  set_shadow_offset(value: Vector2 | Vector2i): void;
+  get_shadow_offset(): Vector2;
+  set_shadow_size(value: int): void;
+  get_shadow_size(): int;
+  set_stacked_outline_count(value: int): void;
+  get_stacked_outline_count(): int;
+  set_stacked_shadow_count(value: int): void;
+  get_stacked_shadow_count(): int;
+
+  /**
+   * Adds a new stacked outline to the label at the given `index`. If `index` is `-1`, the new stacked outline will be added at the end of the list.
+   */
+  add_stacked_outline(index?: int): void;
+  /**
+   * Adds a new stacked shadow to the label at the given `index`. If `index` is `-1`, the new stacked shadow will be added at the end of the list.
+   */
+  add_stacked_shadow(index?: int): void;
+  /** Returns the color of the stacked outline at `index`. */
+  get_stacked_outline_color(index: int): Color;
+  /** Returns the size of the stacked outline at `index`. */
+  get_stacked_outline_size(index: int): int;
+  /** Returns the color of the stacked shadow at `index`. */
+  get_stacked_shadow_color(index: int): Color;
+  /** Returns the offset of the stacked shadow at `index`. */
+  get_stacked_shadow_offset(index: int): Vector2;
+  /** Returns the outline size of the stacked shadow at `index`. */
+  get_stacked_shadow_outline_size(index: int): int;
+  /** Moves the stacked outline at index `from_index` to the given position `to_position` in the array. */
+  move_stacked_outline(from_index: int, to_position: int): void;
+  /** Moves the stacked shadow at index `from_index` to the given position `to_position` in the array. */
+  move_stacked_shadow(from_index: int, to_position: int): void;
+  /** Removes the stacked outline at index `index`. */
+  remove_stacked_outline(index: int): void;
+  /** Removes the stacked shadow at index `index`. */
+  remove_stacked_shadow(index: int): void;
+  /** Sets the color of the stacked outline identified by the given `index` to `color`. */
+  set_stacked_outline_color(index: int, color: Color): void;
+  /** Sets the size of the stacked outline identified by the given `index` to `size`. */
+  set_stacked_outline_size(index: int, size: int): void;
+  /** Sets the color of the stacked shadow identified by the given `index` to `color`. */
+  set_stacked_shadow_color(index: int, color: Color): void;
+  /** Sets the offset of the stacked shadow identified by the given `index` to `offset`. */
+  set_stacked_shadow_offset(index: int, offset: Vector2 | Vector2i): void;
+  /** Sets the outline size of the stacked shadow identified by the given `index` to `size`. */
+  set_stacked_shadow_outline_size(index: int, size: int): void;
+}