typescript-to-gdscript 0.1.0

package/typings/classes/StyleBoxFlat.d.ts

@@ -0,0 +1,120 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A customizable {@link StyleBox} that doesn't use a texture. */
+declare class StyleBoxFlat extends StyleBox {
+  /**
+   * Antialiasing draws a small ring around the edges, which fades to transparency. As a result, edges look much smoother. This is only noticeable when using rounded corners or {@link skew}.
+   * **Note:** When using beveled corners with 45-degree angles ({@link corner_detail} = 1), it is recommended to set {@link anti_aliasing} to `false` to ensure crisp visuals and avoid possible visual glitches.
+   */
+  anti_aliasing: boolean;
+  /**
+   * This changes the size of the antialiasing effect. `1.0` is recommended for an optimal result at 100% scale, identical to how rounded rectangles are rendered in web browsers and most vector drawing software.
+   * **Note:** Higher values may produce a blur effect but can also create undesired artifacts on small boxes with large-radius corners.
+   */
+  anti_aliasing_size: float;
+  /** The background color of the stylebox. */
+  bg_color: Color;
+  /** If `true`, the border will fade into the background color. */
+  border_blend: boolean;
+  /** Sets the color of the border. */
+  border_color: Color;
+  /** Border width for the bottom border. */
+  border_width_bottom: int;
+  /** Border width for the left border. */
+  border_width_left: int;
+  /** Border width for the right border. */
+  border_width_right: int;
+  /** Border width for the top border. */
+  border_width_top: int;
+  /**
+   * This sets the number of vertices used for each corner. Higher values result in rounder corners but take more processing power to compute. When choosing a value, you should take the corner radius ({@link set_corner_radius_all}) into account.
+   * For corner radii less than 10, `4` or `5` should be enough. For corner radii less than 30, values between `8` and `12` should be enough.
+   * A corner detail of `1` will result in chamfered corners instead of rounded corners, which is useful for some artistic effects.
+   */
+  corner_detail: int;
+  /** The bottom-left corner's radius. If `0`, the corner is not rounded. */
+  corner_radius_bottom_left: int;
+  /** The bottom-right corner's radius. If `0`, the corner is not rounded. */
+  corner_radius_bottom_right: int;
+  /** The top-left corner's radius. If `0`, the corner is not rounded. */
+  corner_radius_top_left: int;
+  /** The top-right corner's radius. If `0`, the corner is not rounded. */
+  corner_radius_top_right: int;
+  /** Toggles drawing of the inner part of the stylebox. */
+  draw_center: boolean;
+  /**
+   * Expands the stylebox outside of the control rect on the bottom edge. Useful in combination with {@link border_width_bottom} to draw a border outside the control rect.
+   * **Note:** Unlike {@link StyleBox.content_margin_bottom}, {@link expand_margin_bottom} does *not* affect the size of the clickable area for {@link Control}s. This can negatively impact usability if used wrong, as the user may try to click an area of the StyleBox that cannot actually receive clicks.
+   */
+  expand_margin_bottom: float;
+  /**
+   * Expands the stylebox outside of the control rect on the left edge. Useful in combination with {@link border_width_left} to draw a border outside the control rect.
+   * **Note:** Unlike {@link StyleBox.content_margin_left}, {@link expand_margin_left} does *not* affect the size of the clickable area for {@link Control}s. This can negatively impact usability if used wrong, as the user may try to click an area of the StyleBox that cannot actually receive clicks.
+   */
+  expand_margin_left: float;
+  /**
+   * Expands the stylebox outside of the control rect on the right edge. Useful in combination with {@link border_width_right} to draw a border outside the control rect.
+   * **Note:** Unlike {@link StyleBox.content_margin_right}, {@link expand_margin_right} does *not* affect the size of the clickable area for {@link Control}s. This can negatively impact usability if used wrong, as the user may try to click an area of the StyleBox that cannot actually receive clicks.
+   */
+  expand_margin_right: float;
+  /**
+   * Expands the stylebox outside of the control rect on the top edge. Useful in combination with {@link border_width_top} to draw a border outside the control rect.
+   * **Note:** Unlike {@link StyleBox.content_margin_top}, {@link expand_margin_top} does *not* affect the size of the clickable area for {@link Control}s. This can negatively impact usability if used wrong, as the user may try to click an area of the StyleBox that cannot actually receive clicks.
+   */
+  expand_margin_top: float;
+  /** The color of the shadow. This has no effect if {@link shadow_size} is lower than 1. */
+  shadow_color: Color;
+  /** The shadow offset in pixels. Adjusts the position of the shadow relatively to the stylebox. */
+  shadow_offset: Vector2;
+  /** The shadow size in pixels. */
+  shadow_size: int;
+  /**
+   * If set to a non-zero value on either axis, {@link skew} distorts the StyleBox horizontally and/or vertically. This can be used for "futuristic"-style UIs. Positive values skew the StyleBox towards the right (X axis) and upwards (Y axis), while negative values skew the StyleBox towards the left (X axis) and downwards (Y axis).
+   * **Note:** To ensure text does not touch the StyleBox's edges, consider increasing the {@link StyleBox}'s content margin (see {@link StyleBox.content_margin_bottom}). It is preferable to increase the content margin instead of the expand margin (see {@link expand_margin_bottom}), as increasing the expand margin does not increase the size of the clickable area for {@link Control}s.
+   */
+  skew: Vector2;
+  set_anti_aliased(value: boolean): void;
+  is_anti_aliased(): boolean;
+  set_aa_size(value: float): void;
+  get_aa_size(): float;
+  set_bg_color(value: Color): void;
+  get_bg_color(): Color;
+  set_border_blend(value: boolean): void;
+  get_border_blend(): boolean;
+  set_border_color(value: Color): void;
+  get_border_color(): Color;
+  set_corner_detail(value: int): void;
+  get_corner_detail(): int;
+  set_draw_center(value: boolean): void;
+  is_draw_center_enabled(): boolean;
+  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_skew(value: Vector2 | Vector2i): void;
+  get_skew(): Vector2;
+
+  /** Returns the specified {@link Side}'s border width. */
+  get_border_width(margin: int): int;
+  /** Returns the smallest border width out of all four borders. */
+  get_border_width_min(): int;
+  /** Returns the given `corner`'s radius. */
+  get_corner_radius(corner: int): int;
+  /** Returns the size of the specified {@link Side}'s expand margin. */
+  get_expand_margin(margin: int): float;
+  /** Sets the specified {@link Side}'s border width to `width` pixels. */
+  set_border_width(margin: int, width: int): void;
+  /** Sets the border width to `width` pixels for all sides. */
+  set_border_width_all(width: int): void;
+  /** Sets the corner radius to `radius` pixels for the given `corner`. */
+  set_corner_radius(corner: int, radius: int): void;
+  /** Sets the corner radius to `radius` pixels for all corners. */
+  set_corner_radius_all(radius: int): void;
+  /** Sets the expand margin to `size` pixels for the specified {@link Side}. */
+  set_expand_margin(margin: int, size: float): void;
+  /** Sets the expand margin to `size` pixels for all sides. */
+  set_expand_margin_all(size: float): void;
+}

package/typings/classes/StyleBoxLine.d.ts

@@ -0,0 +1,30 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link StyleBox} that displays a single line of a given color and thickness. */
+declare class StyleBoxLine extends StyleBox {
+  /** The line's color. */
+  color: Color;
+  /**
+   * The number of pixels the line will extend before the {@link StyleBoxLine}'s bounds. If set to a negative value, the line will begin inside the {@link StyleBoxLine}'s bounds.
+   */
+  grow_begin: float;
+  /**
+   * The number of pixels the line will extend past the {@link StyleBoxLine}'s bounds. If set to a negative value, the line will end inside the {@link StyleBoxLine}'s bounds.
+   */
+  grow_end: float;
+  /** The line's thickness in pixels. */
+  thickness: int;
+  /** If `true`, the line will be vertical. If `false`, the line will be horizontal. */
+  vertical: boolean;
+  set_color(value: Color): void;
+  get_color(): Color;
+  set_grow_begin(value: float): void;
+  get_grow_begin(): float;
+  set_grow_end(value: float): void;
+  get_grow_end(): float;
+  set_thickness(value: int): void;
+  get_thickness(): int;
+  set_vertical(value: boolean): void;
+  is_vertical(): boolean;
+}

package/typings/classes/StyleBoxTexture.d.ts

@@ -0,0 +1,99 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A texture-based nine-patch {@link StyleBox}. */
+declare class StyleBoxTexture extends StyleBox {
+  /** Controls how the stylebox's texture will be stretched or tiled horizontally. */
+  axis_stretch_horizontal: int;
+  /** Controls how the stylebox's texture will be stretched or tiled vertically. */
+  axis_stretch_vertical: int;
+  /** If `true`, the nine-patch texture's center tile will be drawn. */
+  draw_center: boolean;
+  /**
+   * Expands the bottom margin of this style box when drawing, causing it to be drawn larger than requested.
+   */
+  expand_margin_bottom: float;
+  /**
+   * Expands the left margin of this style box when drawing, causing it to be drawn larger than requested.
+   */
+  expand_margin_left: float;
+  /**
+   * Expands the right margin of this style box when drawing, causing it to be drawn larger than requested.
+   */
+  expand_margin_right: float;
+  /**
+   * Expands the top margin of this style box when drawing, causing it to be drawn larger than requested.
+   */
+  expand_margin_top: float;
+  /** Modulates the color of the texture when this style box is drawn. */
+  modulate_color: Color;
+  /**
+   * The region to use from the {@link texture}.
+   * This is equivalent to first wrapping the {@link texture} in an {@link AtlasTexture} with the same region.
+   * If empty (`Rect2(0, 0, 0, 0)`), the whole {@link texture} is used.
+   */
+  region_rect: Rect2;
+  /** The texture to use when drawing this style box. */
+  texture: Texture2D | null;
+  /**
+   * Increases the bottom margin of the 3×3 texture box.
+   * A higher value means more of the source texture is considered to be part of the bottom border of the 3×3 box.
+   * This is also the value used as fallback for {@link StyleBox.content_margin_bottom} if it is negative.
+   */
+  texture_margin_bottom: float;
+  /**
+   * Increases the left margin of the 3×3 texture box.
+   * A higher value means more of the source texture is considered to be part of the left border of the 3×3 box.
+   * This is also the value used as fallback for {@link StyleBox.content_margin_left} if it is negative.
+   */
+  texture_margin_left: float;
+  /**
+   * Increases the right margin of the 3×3 texture box.
+   * A higher value means more of the source texture is considered to be part of the right border of the 3×3 box.
+   * This is also the value used as fallback for {@link StyleBox.content_margin_right} if it is negative.
+   */
+  texture_margin_right: float;
+  /**
+   * Increases the top margin of the 3×3 texture box.
+   * A higher value means more of the source texture is considered to be part of the top border of the 3×3 box.
+   * This is also the value used as fallback for {@link StyleBox.content_margin_top} if it is negative.
+   */
+  texture_margin_top: float;
+  set_h_axis_stretch_mode(value: int): void;
+  get_h_axis_stretch_mode(): int;
+  set_v_axis_stretch_mode(value: int): void;
+  get_v_axis_stretch_mode(): int;
+  set_draw_center(value: boolean): void;
+  is_draw_center_enabled(): boolean;
+  set_modulate(value: Color): void;
+  get_modulate(): Color;
+  set_region_rect(value: Rect2 | Rect2i): void;
+  get_region_rect(): Rect2;
+  set_texture(value: Texture2D | null): void;
+  get_texture(): Texture2D | null;
+
+  /** Returns the expand margin size of the specified {@link Side}. */
+  get_expand_margin(margin: int): float;
+  /** Returns the margin size of the specified {@link Side}. */
+  get_texture_margin(margin: int): float;
+  /** Sets the expand margin to `size` pixels for the specified {@link Side}. */
+  set_expand_margin(margin: int, size: float): void;
+  /** Sets the expand margin to `size` pixels for all sides. */
+  set_expand_margin_all(size: float): void;
+  /** Sets the margin to `size` pixels for the specified {@link Side}. */
+  set_texture_margin(margin: int, size: float): void;
+  /** Sets the margin to `size` pixels for all sides. */
+  set_texture_margin_all(size: float): void;
+
+  // enum AxisStretchMode
+  /**
+   * Stretch the stylebox's texture. This results in visible distortion unless the texture size matches the stylebox's size perfectly.
+   */
+  static readonly AXIS_STRETCH_MODE_STRETCH: int;
+  /** Repeats the stylebox's texture to match the stylebox's size according to the nine-patch system. */
+  static readonly AXIS_STRETCH_MODE_TILE: int;
+  /**
+   * Repeats the stylebox's texture to match the stylebox's size according to the nine-patch system. Unlike {@link AXIS_STRETCH_MODE_TILE}, the texture may be slightly stretched to make the nine-patch texture tile seamlessly.
+   */
+  static readonly AXIS_STRETCH_MODE_TILE_FIT: int;
+}

package/typings/classes/SubViewport.d.ts

@@ -0,0 +1,57 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An interface to a game world that doesn't create a window or draw to the screen directly. */
+declare class SubViewport extends Viewport {
+  /**
+   * The clear mode when the sub-viewport is used as a render target.
+   * **Note:** This property is intended for 2D usage.
+   */
+  render_target_clear_mode: int;
+  /** The update mode when the sub-viewport is used as a render target. */
+  render_target_update_mode: int;
+  /**
+   * The width and height of the sub-viewport. Must be set to a value greater than or equal to 2 pixels on both dimensions. Otherwise, nothing will be displayed.
+   * **Note:** If the parent node is a {@link SubViewportContainer} and its {@link SubViewportContainer.stretch} is `true`, the viewport size cannot be changed manually.
+   */
+  size: Vector2i;
+  /**
+   * The 2D size override of the sub-viewport. If either the width or height is `0`, the override is disabled.
+   */
+  size_2d_override: Vector2i;
+  /** If `true`, the 2D size override affects stretch as well. */
+  size_2d_override_stretch: boolean;
+  /** The number of view layers we are rendering to. Set this to `2` to enable stereo rendering. */
+  view_count: int;
+  set_clear_mode(value: int): void;
+  get_clear_mode(): int;
+  set_update_mode(value: int): void;
+  get_update_mode(): int;
+  set_size(value: Vector2i | Vector2): void;
+  get_size(): Vector2i;
+  set_size_2d_override(value: Vector2i | Vector2): void;
+  get_size_2d_override(): Vector2i;
+  set_size_2d_override_stretch(value: boolean): void;
+  is_size_2d_override_stretch_enabled(): boolean;
+  set_view_count(value: int): void;
+  get_view_count(): int;
+
+  // enum ClearMode
+  /** Always clear the render target before drawing. */
+  static readonly CLEAR_MODE_ALWAYS: int;
+  /** Never clear the render target. */
+  static readonly CLEAR_MODE_NEVER: int;
+  /** Clear the render target on the next frame, then switch to {@link CLEAR_MODE_NEVER}. */
+  static readonly CLEAR_MODE_ONCE: int;
+  // enum UpdateMode
+  /** Do not update the render target. */
+  static readonly UPDATE_DISABLED: int;
+  /** Update the render target once, then switch to {@link UPDATE_DISABLED}. */
+  static readonly UPDATE_ONCE: int;
+  /** Update the render target only when it is visible. This is the default value. */
+  static readonly UPDATE_WHEN_VISIBLE: int;
+  /** Update the render target only when its parent is visible. */
+  static readonly UPDATE_WHEN_PARENT_VISIBLE: int;
+  /** Always update the render target. */
+  static readonly UPDATE_ALWAYS: int;
+}

package/typings/classes/SubViewportContainer.d.ts

@@ -0,0 +1,33 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container used for displaying the contents of a {@link SubViewport}. */
+declare class SubViewportContainer extends Container {
+  /**
+   * <member name="mouse_target" type="bool" setter="set_mouse_target" getter="is_mouse_target_enabled" default="false">
+   * Configure, if either the {@link SubViewportContainer} or alternatively the {@link Control} nodes of its {@link SubViewport} children should be available as targets of mouse-related functionalities, like identifying the drop target in drag-and-drop operations or cursor shape of hovered {@link Control} node.
+   * If `false`, the {@link Control} nodes inside its {@link SubViewport} children are considered as targets.
+   * If `true`, the {@link SubViewportContainer} itself will be considered as a target.
+   */
+  focus_mode: int;
+  /**
+   * If `true`, the sub-viewport will be automatically resized to the control's size.
+   * **Note:** If `true`, this will prohibit changing {@link SubViewport.size} of its children manually.
+   */
+  stretch: boolean;
+  /**
+   * Divides the sub-viewport's effective resolution by this value while preserving its scale. This can be used to speed up rendering.
+   * For example, a 1280×720 sub-viewport with {@link stretch_shrink} set to `2` will be rendered at 640×360 while occupying the same size in the container.
+   * **Note:** {@link stretch} must be `true` for this property to work.
+   */
+  stretch_shrink: int;
+  set_stretch(value: boolean): void;
+  is_stretch_enabled(): boolean;
+  set_stretch_shrink(value: int): void;
+  get_stretch_shrink(): int;
+
+  /**
+   * Virtual method to be implemented by the user. If it returns `true`, the `event` is propagated to {@link SubViewport} children. Propagation doesn't happen if it returns `false`. If the function is not implemented, all events are propagated to SubViewports.
+   */
+  _propagate_input_event(event: InputEvent): boolean;
+}

package/typings/classes/SubtweenTweener.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Runs a {@link Tween} nested within another {@link Tween}. */
+declare class SubtweenTweener extends Tweener {
+  /**
+   * Sets the time in seconds after which the {@link SubtweenTweener} will start running the subtween. By default there's no delay.
+   */
+  set_delay(delay: float): SubtweenTweener;
+}

package/typings/classes/SurfaceTool.d.ts

@@ -0,0 +1,178 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Helper tool to create geometry. */
+declare class SurfaceTool extends RefCounted {
+  /**
+   * Adds a vertex to index array if you are using indexed vertices. Does not need to be called before adding vertices.
+   */
+  add_index(index: int): void;
+  /**
+   * Inserts a triangle fan made of array data into {@link Mesh} being constructed.
+   * Requires the primitive type be set to {@link Mesh.PRIMITIVE_TRIANGLES}.
+   */
+  add_triangle_fan(vertices: PackedVector3Array | Array<unknown>, uvs?: PackedVector2Array | Array<unknown>, colors?: PackedColorArray | Array<unknown>, uv2s?: PackedVector2Array | Array<unknown>, normals?: PackedVector3Array | Array<unknown>, tangents?: Array<Plane>): void;
+  /**
+   * Specifies the position of current vertex. Should be called after specifying other vertex properties (e.g. Color, UV).
+   */
+  add_vertex(vertex: Vector3 | Vector3i): void;
+  /**
+   * Append vertices from a given {@link Mesh} surface onto the current vertex array with specified {@link Transform3D}.
+   */
+  append_from(existing: Mesh, surface: int, transform: Transform3D | Projection): void;
+  /**
+   * Called before adding any vertices. Takes the primitive type as an argument (e.g. {@link Mesh.PRIMITIVE_TRIANGLES}).
+   */
+  begin(primitive: int): void;
+  /** Clear all information passed into the surface tool so far. */
+  clear(): void;
+  /**
+   * Returns a constructed {@link ArrayMesh} from current information passed in. If an existing {@link ArrayMesh} is passed in as an argument, will add an extra surface to the existing {@link ArrayMesh}.
+   * The `flags` argument can be the bitwise OR of {@link Mesh.ARRAY_FLAG_USE_DYNAMIC_UPDATE}, {@link Mesh.ARRAY_FLAG_USE_8_BONE_WEIGHTS}, or {@link Mesh.ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY}.
+   */
+  commit(existing?: ArrayMesh, flags?: int): ArrayMesh;
+  /**
+   * Commits the data to the same format used by {@link ArrayMesh.add_surface_from_arrays}, {@link ImporterMesh.add_surface}, and {@link create_from_arrays}. This way you can further process the mesh data using the {@link ArrayMesh} or {@link ImporterMesh} APIs.
+   */
+  commit_to_arrays(): Array<unknown>;
+  /** Creates a vertex array from an existing {@link Mesh}. */
+  create_from(existing: Mesh, surface: int): void;
+  /**
+   * Creates this SurfaceTool from existing vertex arrays such as returned by {@link commit_to_arrays}, {@link Mesh.surface_get_arrays}, {@link Mesh.surface_get_blend_shape_arrays}, {@link ImporterMesh.get_surface_arrays}, and {@link ImporterMesh.get_surface_blend_shape_arrays}. `primitive_type` controls the type of mesh data, defaulting to {@link Mesh.PRIMITIVE_TRIANGLES}.
+   */
+  create_from_arrays(arrays: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array, primitive_type: int): void;
+  /**
+   * Creates a vertex array from the specified blend shape of an existing {@link Mesh}. This can be used to extract a specific pose from a blend shape.
+   */
+  create_from_blend_shape(existing: Mesh, surface: int, blend_shape: string | NodePath): void;
+  /** Removes the index array by expanding the vertex array. */
+  deindex(): void;
+  /**
+   * Generates an LOD for a given `nd_threshold` in linear units (square root of quadric error metric), using at most `target_index_count` indices.
+   */
+  generate_lod(nd_threshold: float, target_index_count?: int): PackedInt32Array;
+  /**
+   * Generates normals from vertices so you do not have to do it manually. If `flip` is `true`, the resulting normals will be inverted. {@link generate_normals} should be called *after* generating geometry and *before* committing the mesh using {@link commit} or {@link commit_to_arrays}. For correct display of normal-mapped surfaces, you will also have to generate tangents using {@link generate_tangents}.
+   * **Note:** {@link generate_normals} only works if the primitive type is set to {@link Mesh.PRIMITIVE_TRIANGLES}.
+   * **Note:** {@link generate_normals} takes smooth groups into account. To generate smooth normals, set the smooth group to a value greater than or equal to `0` using {@link set_smooth_group} or leave the smooth group at the default of `0`. To generate flat normals, set the smooth group to `-1` using {@link set_smooth_group} prior to adding vertices.
+   */
+  generate_normals(flip?: boolean): void;
+  /**
+   * Generates a tangent vector for each vertex. Requires that each vertex already has UVs and normals set (see {@link generate_normals}).
+   */
+  generate_tangents(): void;
+  /** Returns the axis-aligned bounding box of the vertex positions. */
+  get_aabb(): AABB;
+  /**
+   * Returns the format for custom `channel_index` (currently up to 4). Returns {@link CUSTOM_MAX} if this custom channel is unused.
+   */
+  get_custom_format(channel_index: int): int;
+  /** Returns the type of mesh geometry, such as {@link Mesh.PRIMITIVE_TRIANGLES}. */
+  get_primitive_type(): int;
+  /**
+   * By default, returns {@link SKIN_4_WEIGHTS} to indicate only 4 bone influences per vertex are used.
+   * Returns {@link SKIN_8_WEIGHTS} if up to 8 influences are used.
+   * **Note:** This function returns an enum, not the exact number of weights.
+   */
+  get_skin_weight_count(): int;
+  /**
+   * Shrinks the vertex array by creating an index array. This can improve performance by avoiding vertex reuse.
+   */
+  index(): void;
+  /**
+   * Optimizes triangle sorting for performance. Requires that {@link get_primitive_type} is {@link Mesh.PRIMITIVE_TRIANGLES}.
+   */
+  optimize_indices_for_cache(): void;
+  /** Specifies an array of bones to use for the *next* vertex. `bones` must contain 4 integers. */
+  set_bones(bones: PackedInt32Array | Array<unknown>): void;
+  /**
+   * Specifies a {@link Color} to use for the *next* vertex. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+   * **Note:** The material must have {@link BaseMaterial3D.vertex_color_use_as_albedo} enabled for the vertex color to be visible.
+   */
+  set_color(color: Color): void;
+  /**
+   * Sets the custom value on this vertex for `channel_index`.
+   * {@link set_custom_format} must be called first for this `channel_index`. Formats which are not RGBA will ignore other color channels.
+   */
+  set_custom(channel_index: int, custom_color: Color): void;
+  /**
+   * Sets the color format for this custom `channel_index`. Use {@link CUSTOM_MAX} to disable.
+   * Must be invoked after {@link begin} and should be set before {@link commit} or {@link commit_to_arrays}.
+   */
+  set_custom_format(channel_index: int, format: int): void;
+  /** Sets {@link Material} to be used by the {@link Mesh} you are constructing. */
+  set_material(material: Material): void;
+  /**
+   * Specifies a normal to use for the *next* vertex. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+   */
+  set_normal(normal: Vector3 | Vector3i): void;
+  /**
+   * Set to {@link SKIN_8_WEIGHTS} to indicate that up to 8 bone influences per vertex may be used.
+   * By default, only 4 bone influences are used ({@link SKIN_4_WEIGHTS}).
+   * **Note:** This function takes an enum, not the exact number of weights.
+   */
+  set_skin_weight_count(count: int): void;
+  /**
+   * Specifies the smooth group to use for the *next* vertex. If this is never called, all vertices will have the default smooth group of `0` and will be smoothed with adjacent vertices of the same group. To produce a mesh with flat normals, set the smooth group to `-1`.
+   * **Note:** This function actually takes a `uint32_t`, so C# users should use `uint32.MaxValue` instead of `-1` to produce a mesh with flat normals.
+   */
+  set_smooth_group(index: int): void;
+  /**
+   * Specifies a tangent to use for the *next* vertex. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+   * **Note:** Even though `tangent` is a {@link Plane}, it does not directly represent the tangent plane. Its {@link Plane.x}, {@link Plane.y}, and {@link Plane.z} represent the tangent vector and {@link Plane.d} should be either `-1` or `1`. See also {@link Mesh.ARRAY_TANGENT}.
+   */
+  set_tangent(tangent: Plane): void;
+  /**
+   * Specifies a set of UV coordinates to use for the *next* vertex. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+   */
+  set_uv(uv: Vector2 | Vector2i): void;
+  /**
+   * Specifies an optional second set of UV coordinates to use for the *next* vertex. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+   */
+  set_uv2(uv2: Vector2 | Vector2i): void;
+  /**
+   * Specifies weight values to use for the *next* vertex. `weights` must contain 4 values. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+   */
+  set_weights(weights: PackedFloat32Array | Array<unknown>): void;
+
+  // enum CustomFormat
+  /**
+   * Limits range of data passed to {@link set_custom} to unsigned normalized 0 to 1 stored in 8 bits per channel. See {@link Mesh.ARRAY_CUSTOM_RGBA8_UNORM}.
+   */
+  static readonly CUSTOM_RGBA8_UNORM: int;
+  /**
+   * Limits range of data passed to {@link set_custom} to signed normalized -1 to 1 stored in 8 bits per channel. See {@link Mesh.ARRAY_CUSTOM_RGBA8_SNORM}.
+   */
+  static readonly CUSTOM_RGBA8_SNORM: int;
+  /**
+   * Stores data passed to {@link set_custom} as half precision floats, and uses only red and green color channels. See {@link Mesh.ARRAY_CUSTOM_RG_HALF}.
+   */
+  static readonly CUSTOM_RG_HALF: int;
+  /**
+   * Stores data passed to {@link set_custom} as half precision floats and uses all color channels. See {@link Mesh.ARRAY_CUSTOM_RGBA_HALF}.
+   */
+  static readonly CUSTOM_RGBA_HALF: int;
+  /**
+   * Stores data passed to {@link set_custom} as full precision floats, and uses only red color channel. See {@link Mesh.ARRAY_CUSTOM_R_FLOAT}.
+   */
+  static readonly CUSTOM_R_FLOAT: int;
+  /**
+   * Stores data passed to {@link set_custom} as full precision floats, and uses only red and green color channels. See {@link Mesh.ARRAY_CUSTOM_RG_FLOAT}.
+   */
+  static readonly CUSTOM_RG_FLOAT: int;
+  /**
+   * Stores data passed to {@link set_custom} as full precision floats, and uses only red, green and blue color channels. See {@link Mesh.ARRAY_CUSTOM_RGB_FLOAT}.
+   */
+  static readonly CUSTOM_RGB_FLOAT: int;
+  /**
+   * Stores data passed to {@link set_custom} as full precision floats, and uses all color channels. See {@link Mesh.ARRAY_CUSTOM_RGBA_FLOAT}.
+   */
+  static readonly CUSTOM_RGBA_FLOAT: int;
+  /** Used to indicate a disabled custom channel. */
+  static readonly CUSTOM_MAX: int;
+  // enum SkinWeightCount
+  /** Each individual vertex can be influenced by only 4 bone weights. */
+  static readonly SKIN_4_WEIGHTS: int;
+  /** Each individual vertex can be influenced by up to 8 bone weights. */
+  static readonly SKIN_8_WEIGHTS: int;
+}

package/typings/classes/SyntaxHighlighter.d.ts

@@ -0,0 +1,33 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for syntax highlighters. Provides syntax highlighting data to a {@link TextEdit}. */
+declare class SyntaxHighlighter extends Resource {
+  /** Virtual method which can be overridden to clear any local caches. */
+  _clear_highlighting_cache(): void;
+  /**
+   * Virtual method which can be overridden to return syntax highlighting data.
+   * See {@link get_line_syntax_highlighting} for more details.
+   */
+  _get_line_syntax_highlighting(line: int): Dictionary;
+  /** Virtual method which can be overridden to update any local caches. */
+  _update_cache(): void;
+  /**
+   * Clears all cached syntax highlighting data.
+   * Then calls overridable method {@link _clear_highlighting_cache}.
+   */
+  clear_highlighting_cache(): void;
+  /**
+   * Returns the syntax highlighting data for the line at index `line`. If the line is not cached, calls {@link _get_line_syntax_highlighting} first to calculate the data.
+   * Each entry is a column number containing a nested {@link Dictionary}. The column number denotes the start of a region, the region will end if another region is found, or at the end of the line. The nested {@link Dictionary} contains the data for that region. Currently only the key `"color"` is supported.
+   * **Example:** Possible return value. This means columns `0` to `4` should be red, and columns `5` to the end of the line should be green:
+   */
+  get_line_syntax_highlighting(line: int): Dictionary;
+  /** Returns the associated {@link TextEdit} node. */
+  get_text_edit(): TextEdit | null;
+  /**
+   * Clears then updates the {@link SyntaxHighlighter} caches. Override {@link _update_cache} for a callback.
+   * **Note:** This is called automatically when the associated {@link TextEdit} node, updates its own cache.
+   */
+  update_cache(): void;
+}