@ringozz/godot 4.7.2-570 → 4.7.2-579

package/gen/classes/AnimationNode.ts

@@ -107,7 +107,7 @@ export class AnimationNode extends Resource {
     set filterEnabled(v: boolean) { _C(this, 11390, v); }
 
     get filters(): GodotArray { return _C(this, 1001) as GodotArray; }
-    set filters(v: GodotArray) { _C(this, 1027, v); }
+    set filters(v: GodotArray | unknown[]) { _C(this, 1027, v); }
 
     /**
      * Emitted by nodes that inherit from this class and that have an internal tree when one of their animation nodes changes. The animation nodes that emit this signal are {@link AnimationNodeBlendSpace1D}, {@link AnimationNodeBlendSpace2D}, {@link AnimationNodeStateMachine}, {@link AnimationNodeBlendTree} and {@link AnimationNodeTransition}.

package/gen/classes/AnimationNodeBlendSpace2D.ts

@@ -97,7 +97,7 @@ export class AnimationNodeBlendSpace2D extends AnimationRootNode {
     set autoTriangles(v: boolean) { _C(this, 10583, v); }
 
     get triangles(): PackedInt32Array { return _C(this, 1015) as PackedInt32Array; }
-    set triangles(v: PackedInt32Array) { _C(this, 1046, v); }
+    set triangles(v: PackedInt32Array | number[]) { _C(this, 1046, v); }
 
     /**
      * The blend space's X and Y axes' lower limit for the points' position. See {@link addBlendPoint}.

package/gen/classes/ArrayOccluder3D.ts

@@ -4,6 +4,7 @@
 import { _C, _R } from '../../src/runtime.ts';
 import { Occluder3D } from './Occluder3D.ts';
 import type { PackedInt32Array, PackedVector3Array } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
 
 /**
  * {@link ArrayOccluder3D} stores an arbitrary 3D polygon shape that can be used by the engine's occlusion culling system. This is analogous to {@link ArrayMesh}, but for occluders.
@@ -22,14 +23,14 @@ export class ArrayOccluder3D extends Occluder3D {
      * **Note:** The occluder is always updated after setting this value. If creating occluders procedurally, consider using {@link setArrays} instead to avoid updating the occluder twice when it's created.
      */
     get vertices(): PackedVector3Array { return _C(this, 7068) as PackedVector3Array; }
-    set vertices(v: PackedVector3Array) { _C(this, 13308, v); }
+    set vertices(v: PackedVector3Array | Vector3[]) { _C(this, 13308, v); }
 
     /**
      * The occluder's index position. Indices determine which points from the {@link vertices} array should be drawn, and in which order.
      * **Note:** The occluder is always updated after setting this value. If creating occluders procedurally, consider using {@link setArrays} instead to avoid updating the occluder twice when it's created.
      */
     get indices(): PackedInt32Array { return _C(this, 5091) as PackedInt32Array; }
-    set indices(v: PackedInt32Array) { _C(this, 11692, v); }
+    set indices(v: PackedInt32Array | number[]) { _C(this, 11692, v); }
 
     static readonly name = _R(83, ArrayOccluder3D);
 }

package/gen/classes/AudioStreamMP3.ts

@@ -38,7 +38,7 @@ export class AudioStreamMP3 extends AudioStream {
      * ```
      */
     get data(): PackedByteArray { return _C(this, 4410) as PackedByteArray; }
-    set data(v: PackedByteArray) { _C(this, 11034, v); }
+    set data(v: PackedByteArray | number[]) { _C(this, 11034, v); }
 
     /**
      * The tempo of the audio track, measured in beats per minute.

package/gen/classes/AudioStreamOggVorbis.ts

@@ -53,7 +53,7 @@ export class AudioStreamOggVorbis extends AudioStream {
      * **Note:** No tag is *guaranteed* to be present in every file, so make sure to account for the keys not always existing.
      */
     get tags(): GodotDictionary { return _C(this, 6689) as GodotDictionary; }
-    set tags(v: GodotDictionary) { _C(this, 12990, v); }
+    set tags(v: GodotDictionary | Record<string, any>) { _C(this, 12990, v); }
 
     /**
      * If `true`, the stream will play again from the specified {@link loopOffset} once it reaches the end of the audio track, or once it reaches the end of the last beat according to the amount specified in {@link beatCount}. Useful for ambient sounds and background music.

package/gen/classes/AudioStreamWAV.ts

@@ -55,7 +55,7 @@ export class AudioStreamWAV extends AudioStream {
      * **Note:** If {@link format} is set to {@link FORMAT_QOA}, this property expects data from a full QOA file.
      */
     get data(): PackedByteArray { return _C(this, 4410) as PackedByteArray; }
-    set data(v: PackedByteArray) { _C(this, 11034, v); }
+    set data(v: PackedByteArray | number[]) { _C(this, 11034, v); }
 
     /**
      * Audio format.
@@ -102,7 +102,7 @@ export class AudioStreamWAV extends AudioStream {
      * **Note:** Only WAV files using a `LIST` chunk with an identifier of `INFO` to encode the tags are currently supported.
      */
     get tags(): GodotDictionary { return _C(this, 6689) as GodotDictionary; }
-    set tags(v: GodotDictionary) { _C(this, 12990, v); }
+    set tags(v: GodotDictionary | Record<string, any>) { _C(this, 12990, v); }
 
     static readonly name = _R(143, AudioStreamWAV);
 }

package/gen/classes/BitMap.ts

@@ -88,7 +88,7 @@ export class BitMap extends Resource {
     opaqueToPolygons(rect: Rect2i, epsilon?: number /* = 2.0 */): GodotArray<PackedVector2Array> { return _C(this, 9188, rect, epsilon) as GodotArray<PackedVector2Array>; }
 
     get data(): GodotDictionary { return _C(this, 1000) as GodotDictionary; }
-    set data(v: GodotDictionary) { _C(this, 1026, v); }
+    set data(v: GodotDictionary | Record<string, any>) { _C(this, 1026, v); }
 
     static readonly name = _R(148, BitMap);
 }

package/gen/classes/CPUParticles2D.ts

@@ -152,19 +152,19 @@ export class CPUParticles2D extends Node2D {
      * Sets the initial positions to spawn particles when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      */
     get emissionPoints(): PackedVector2Array { return _C(this, 4628) as PackedVector2Array; }
-    set emissionPoints(v: PackedVector2Array) { _C(this, 11245, v); }
+    set emissionPoints(v: PackedVector2Array | Vector2[]) { _C(this, 11245, v); }
 
     /**
      * Sets the direction the particles will be emitted in when using {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      */
     get emissionNormals(): PackedVector2Array { return _C(this, 4624) as PackedVector2Array; }
-    set emissionNormals(v: PackedVector2Array) { _C(this, 11241, v); }
+    set emissionNormals(v: PackedVector2Array | Vector2[]) { _C(this, 11241, v); }
 
     /**
      * Sets the {@link Color}s to modulate particles by when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      */
     get emissionColors(): PackedColorArray { return _C(this, 4618) as PackedColorArray; }
-    set emissionColors(v: PackedColorArray) { _C(this, 11235, v); }
+    set emissionColors(v: PackedColorArray | Color[]) { _C(this, 11235, v); }
 
     /**
      * The ring's inner radius if {@link emissionShape} is set to {@link EMISSION_SHAPE_RING}.

package/gen/classes/CPUParticles3D.ts

@@ -164,20 +164,20 @@ export class CPUParticles3D extends GeometryInstance3D {
      * Sets the initial positions to spawn particles when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      */
     get emissionPoints(): PackedVector3Array { return _C(this, 4628) as PackedVector3Array; }
-    set emissionPoints(v: PackedVector3Array) { _C(this, 11245, v); }
+    set emissionPoints(v: PackedVector3Array | Vector3[]) { _C(this, 11245, v); }
 
     /**
      * Sets the direction the particles will be emitted in when using {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      */
     get emissionNormals(): PackedVector3Array { return _C(this, 4624) as PackedVector3Array; }
-    set emissionNormals(v: PackedVector3Array) { _C(this, 11241, v); }
+    set emissionNormals(v: PackedVector3Array | Vector3[]) { _C(this, 11241, v); }
 
     /**
      * Sets the {@link Color}s to modulate particles by when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
      * **Note:** {@link emissionColors} multiplies the particle mesh's vertex colors. To have a visible effect on a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertexColorUseAsAlbedo} *must* be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function. Otherwise, {@link emissionColors} will have no visible effect.
      */
     get emissionColors(): PackedColorArray { return _C(this, 4618) as PackedColorArray; }
-    set emissionColors(v: PackedColorArray) { _C(this, 11235, v); }
+    set emissionColors(v: PackedColorArray | Color[]) { _C(this, 11235, v); }
 
     /**
      * The axis of the ring when using the emitter {@link EMISSION_SHAPE_RING}.

package/gen/classes/CSGPolygon3D.ts

@@ -4,6 +4,7 @@
 import { _C, _R } from '../../src/runtime.ts';
 import { CSGPrimitive3D } from './CSGPrimitive3D.ts';
 import type { NodePath, PackedVector2Array } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
 import type { Material } from './Material.ts';
 
 /**
@@ -18,7 +19,7 @@ export class CSGPolygon3D extends CSGPrimitive3D {
      * **Note:** If only 1 or 2 points are defined in {@link polygon}, no mesh will be generated.
      */
     get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
-    set polygon(v: PackedVector2Array) { _C(this, 12373, v); }
+    set polygon(v: PackedVector2Array | Vector2[]) { _C(this, 12373, v); }
 
     /**
      * The {@link mode} used to extrude the {@link polygon}.

package/gen/classes/CharFXTransform.ts

@@ -68,7 +68,7 @@ export class CharFXTransform extends RefCounted {
      * ```
      */
     get env(): GodotDictionary { return _C(this, 4678) as GodotDictionary; }
-    set env(v: GodotDictionary) { _C(this, 11301, v); }
+    set env(v: GodotDictionary | Record<string, any>) { _C(this, 11301, v); }
 
     /**
      * Glyph index specific to the {@link font}. If you want to replace this glyph, use {@link TextServer.fontGetGlyphIndex} with {@link font} to get a new glyph index for a single character.

package/gen/classes/CodeEdit.ts

@@ -402,7 +402,7 @@ export class CodeEdit extends TextEdit {
      * Draws vertical lines at the provided columns. The first entry is considered a main hard guideline and is drawn more prominently.
      */
     get lineLengthGuidelines(): GodotArray<number> { return _C(this, 5363) as GodotArray<number>; }
-    set lineLengthGuidelines(v: GodotArray<number>) { _C(this, 11925, v); }
+    set lineLengthGuidelines(v: GodotArray<number> | number[]) { _C(this, 11925, v); }
 
     /**
      * If `true`, breakpoints are drawn in the gutter. This gutter is shared with bookmarks and executing lines. Clicking the gutter will toggle the breakpoint for the line, see {@link setLineAsBreakpoint}.
@@ -450,13 +450,13 @@ export class CodeEdit extends TextEdit {
      * Sets the string delimiters. All existing string delimiters will be removed.
      */
     get delimiterStrings(): GodotArray<string> { return _C(this, 6575) as GodotArray<string>; }
-    set delimiterStrings(v: GodotArray<string>) { _C(this, 12912, v); }
+    set delimiterStrings(v: GodotArray<string> | string[]) { _C(this, 12912, v); }
 
     /**
      * Sets the comment delimiters. All existing comment delimiters will be removed.
      */
     get delimiterComments(): GodotArray<string> { return _C(this, 4245) as GodotArray<string>; }
-    set delimiterComments(v: GodotArray<string>) { _C(this, 10927, v); }
+    set delimiterComments(v: GodotArray<string> | string[]) { _C(this, 10927, v); }
 
     /**
      * If `true`, the {@link ProjectSettings.input/uiTextCompletionQuery} action requests code completion. To handle it, see {@link _requestCodeCompletion} or {@link code_completion_requested}.
@@ -468,7 +468,7 @@ export class CodeEdit extends TextEdit {
      * Sets prefixes that will trigger code completion.
      */
     get codeCompletionPrefixes(): GodotArray<string> { return _C(this, 4184) as GodotArray<string>; }
-    set codeCompletionPrefixes(v: GodotArray<string>) { _C(this, 10876, v); }
+    set codeCompletionPrefixes(v: GodotArray<string> | string[]) { _C(this, 10876, v); }
 
     /**
      * Size of the tabulation indent (one `Tab` press) in characters. If {@link indentUseSpaces} is enabled the number of spaces to use.
@@ -492,7 +492,7 @@ export class CodeEdit extends TextEdit {
      * Prefixes to trigger an automatic indent. Used when {@link indentAutomatic} is set to `true`.
      */
     get indentAutomaticPrefixes(): GodotArray<string> { return _C(this, 3838) as GodotArray<string>; }
-    set indentAutomaticPrefixes(v: GodotArray<string>) { _C(this, 10579, v); }
+    set indentAutomaticPrefixes(v: GodotArray<string> | string[]) { _C(this, 10579, v); }
 
     /**
      * If `true`, uses {@link autoBraceCompletionPairs} to automatically insert the closing brace when the opening brace is inserted by typing or autocompletion. Also automatically removes the closing brace when using backspace on the opening brace.
@@ -510,7 +510,7 @@ export class CodeEdit extends TextEdit {
      * Sets the brace pairs to be autocompleted. For each entry in the dictionary, the key is the opening brace and the value is the closing brace that matches it. A brace is a {@link String} made of symbols. See {@link autoBraceCompletionEnabled} and {@link autoBraceCompletionHighlightMatching}.
      */
     get autoBraceCompletionPairs(): GodotDictionary { return _C(this, 3827) as GodotDictionary; }
-    set autoBraceCompletionPairs(v: GodotDictionary) { _C(this, 10564, v); }
+    set autoBraceCompletionPairs(v: GodotDictionary | Record<string, any>) { _C(this, 10564, v); }
 
     /**
      * Emitted when a breakpoint is added or removed from a line. If the line is removed via backspace, a signal is emitted at the old line.

package/gen/classes/CodeHighlighter.ts

@@ -114,19 +114,19 @@ export class CodeHighlighter extends SyntaxHighlighter {
      * Sets the keyword colors. All existing keywords will be removed. The {@link Dictionary} key is the keyword. The value is the keyword color.
      */
     get keywordColors(): GodotDictionary { return _C(this, 5296) as GodotDictionary; }
-    set keywordColors(v: GodotDictionary) { _C(this, 11869, v); }
+    set keywordColors(v: GodotDictionary | Record<string, any>) { _C(this, 11869, v); }
 
     /**
      * Sets the member keyword colors. All existing member keyword will be removed. The {@link Dictionary} key is the member keyword. The value is the member keyword color.
      */
     get memberKeywordColors(): GodotDictionary { return _C(this, 5498) as GodotDictionary; }
-    set memberKeywordColors(v: GodotDictionary) { _C(this, 12017, v); }
+    set memberKeywordColors(v: GodotDictionary | Record<string, any>) { _C(this, 12017, v); }
 
     /**
      * Sets the color regions. All existing regions will be removed. The {@link Dictionary} key is the region start and end key, separated by a space. The value is the region color.
      */
     get colorRegions(): GodotDictionary { return _C(this, 4229) as GodotDictionary; }
-    set colorRegions(v: GodotDictionary) { _C(this, 10913, v); }
+    set colorRegions(v: GodotDictionary | Record<string, any>) { _C(this, 10913, v); }
 
     static readonly name = _R(201, CodeHighlighter);
 }

package/gen/classes/CollisionPolygon2D.ts

@@ -24,7 +24,7 @@ export class CollisionPolygon2D extends Node2D {
      * **Note:** The returned vertices are in the local coordinate space of the given {@link CollisionPolygon2D}.
      */
     get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
-    set polygon(v: PackedVector2Array) { _C(this, 12373, v); }
+    set polygon(v: PackedVector2Array | Vector2[]) { _C(this, 12373, v); }
 
     /**
      * If `true`, no collisions will be detected. This property should be changed with {@link Object.setDeferred}.

package/gen/classes/CollisionPolygon3D.ts

@@ -4,7 +4,7 @@
 import { _C, _R } from '../../src/runtime.ts';
 import { Node3D } from './Node3D.ts';
 import type { PackedVector2Array } from '../heap-types/index.ts';
-import type { Color } from '../value-types/index.ts';
+import type { Color, Vector2 } from '../value-types/index.ts';
 
 /**
  * A node that provides a thickened polygon shape (a prism) to a {@link CollisionObject3D} parent and allows it to be edited. The polygon can be concave or convex. This can give a detection shape to an {@link Area3D} or turn a {@link PhysicsBody3D} into a solid object.
@@ -29,7 +29,7 @@ export class CollisionPolygon3D extends Node3D {
      * Array of vertices which define the 2D polygon in the local XY plane.
      */
     get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
-    set polygon(v: PackedVector2Array) { _C(this, 12373, v); }
+    set polygon(v: PackedVector2Array | Vector2[]) { _C(this, 12373, v); }
 
     /**
      * The collision margin for the generated {@link Shape3D}. See {@link Shape3D.margin} for more details.

package/gen/classes/ColorPalette.ts

@@ -4,6 +4,7 @@
 import { _C, _R } from '../../src/runtime.ts';
 import { Resource } from './Resource.ts';
 import type { PackedColorArray } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
 
 /**
  * The {@link ColorPalette} resource is designed to store and manage a collection of colors. This resource is useful in scenarios where a predefined set of colors is required, such as for creating themes, designing user interfaces, or managing game assets. The built-in {@link ColorPicker} control can also make use of {@link ColorPalette} without additional code.
@@ -15,7 +16,7 @@ export class ColorPalette extends Resource {
      * A {@link PackedColorArray} containing the colors in the palette.
      */
     get colors(): PackedColorArray { return _C(this, 4232) as PackedColorArray; }
-    set colors(v: PackedColorArray) { _C(this, 10914, v); }
+    set colors(v: PackedColorArray | Color[]) { _C(this, 10914, v); }
 
     static readonly name = _R(208, ColorPalette);
 }

package/gen/classes/Compositor.ts

@@ -16,7 +16,7 @@ export class Compositor extends Resource {
      * The custom {@link CompositorEffect}s that are applied during rendering of viewports using this compositor.
      */
     get compositorEffects(): GodotArray<CompositorEffect> { return _C(this, 4251) as GodotArray<CompositorEffect>; }
-    set compositorEffects(v: GodotArray<CompositorEffect>) { _C(this, 10932, v); }
+    set compositorEffects(v: GodotArray<CompositorEffect> | CompositorEffect[]) { _C(this, 10932, v); }
 
     static readonly name = _R(212, Compositor);
 }

package/gen/classes/ConcavePolygonShape2D.ts

@@ -4,6 +4,7 @@
 import { _C, _R } from '../../src/runtime.ts';
 import { Shape2D } from './Shape2D.ts';
 import type { PackedVector2Array } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
 
 /**
  * A 2D polyline shape, intended for use in physics. Used internally in {@link CollisionPolygon2D} when it's in {@link CollisionPolygon2D.BUILD_SEGMENTS} mode.
@@ -19,7 +20,7 @@ export class ConcavePolygonShape2D extends Shape2D {
      * The array of points that make up the {@link ConcavePolygonShape2D}'s line segments. The array (of length divisible by two) is naturally divided into pairs (one pair for each segment); each pair consists of the starting point of a segment and the endpoint of a segment.
      */
     get segments(): PackedVector2Array { return _C(this, 6318) as PackedVector2Array; }
-    set segments(v: PackedVector2Array) { _C(this, 12683, v); }
+    set segments(v: PackedVector2Array | Vector2[]) { _C(this, 12683, v); }
 
     static readonly name = _R(220, ConcavePolygonShape2D);
 }

package/gen/classes/ConcavePolygonShape3D.ts

@@ -4,6 +4,7 @@
 import { _C, _R } from '../../src/runtime.ts';
 import { Shape3D } from './Shape3D.ts';
 import type { PackedVector3Array } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
 
 /**
  * A 3D trimesh shape, intended for use in physics. Usually used to provide a shape for a {@link CollisionShape3D}.
@@ -16,7 +17,7 @@ export class ConcavePolygonShape3D extends Shape3D {
     constructor(name = 221) { super(name); }
 
     get data(): PackedVector3Array { return _C(this, 4736) as PackedVector3Array; }
-    set data(v: PackedVector3Array) { _C(this, 11352, v); }
+    set data(v: PackedVector3Array | Vector3[]) { _C(this, 11352, v); }
 
     /**
      * If set to `true`, collisions occur on both sides of the concave shape faces. Otherwise they occur only along the face normals.

package/gen/classes/Control.ts

@@ -957,25 +957,25 @@ export class Control extends CanvasItem {
      * The paths to the nodes which are controlled by this node.
      */
     get accessibilityControlsNodes(): GodotArray<NodePath> { return _C(this, 3666) as GodotArray<NodePath>; }
-    set accessibilityControlsNodes(v: GodotArray<NodePath>) { _C(this, 10405, v); }
+    set accessibilityControlsNodes(v: GodotArray<NodePath> | NodePath[]) { _C(this, 10405, v); }
 
     /**
      * The paths to the nodes which are describing this node.
      */
     get accessibilityDescribedByNodes(): GodotArray<NodePath> { return _C(this, 3667) as GodotArray<NodePath>; }
-    set accessibilityDescribedByNodes(v: GodotArray<NodePath>) { _C(this, 10406, v); }
+    set accessibilityDescribedByNodes(v: GodotArray<NodePath> | NodePath[]) { _C(this, 10406, v); }
 
     /**
      * The paths to the nodes which label this node.
      */
     get accessibilityLabeledByNodes(): GodotArray<NodePath> { return _C(this, 3671) as GodotArray<NodePath>; }
-    set accessibilityLabeledByNodes(v: GodotArray<NodePath>) { _C(this, 10409, v); }
+    set accessibilityLabeledByNodes(v: GodotArray<NodePath> | NodePath[]) { _C(this, 10409, v); }
 
     /**
      * The paths to the nodes which this node flows into.
      */
     get accessibilityFlowToNodes(): GodotArray<NodePath> { return _C(this, 3670) as GodotArray<NodePath>; }
-    set accessibilityFlowToNodes(v: GodotArray<NodePath>) { _C(this, 10408, v); }
+    set accessibilityFlowToNodes(v: GodotArray<NodePath> | NodePath[]) { _C(this, 10408, 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.

package/gen/classes/ConvexPolygonShape2D.ts

@@ -4,6 +4,7 @@
 import { _C, _R } from '../../src/runtime.ts';
 import { Shape2D } from './Shape2D.ts';
 import type { PackedVector2Array } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
 
 /**
  * A 2D convex polygon shape, intended for use in physics. Used internally in {@link CollisionPolygon2D} when it's in {@link CollisionPolygon2D.BUILD_SOLIDS} mode.
@@ -24,7 +25,7 @@ export class ConvexPolygonShape2D extends Shape2D {
      * **Warning:** Only set this property to a list of points that actually form a convex hull. Use {@link setPointCloud} to generate the convex hull of an arbitrary set of points.
      */
     get points(): PackedVector2Array { return _C(this, 5958) as PackedVector2Array; }
-    set points(v: PackedVector2Array) { _C(this, 12369, v); }
+    set points(v: PackedVector2Array | Vector2[]) { _C(this, 12369, v); }
 
     static readonly name = _R(228, ConvexPolygonShape2D);
 }

package/gen/classes/ConvexPolygonShape3D.ts

@@ -4,6 +4,7 @@
 import { _C, _R } from '../../src/runtime.ts';
 import { Shape3D } from './Shape3D.ts';
 import type { PackedVector3Array } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
 
 /**
  * A 3D convex polyhedron shape, intended for use in physics. Usually used to provide a shape for a {@link CollisionShape3D}.
@@ -18,7 +19,7 @@ export class ConvexPolygonShape3D extends Shape3D {
      * The list of 3D points forming the convex polygon shape.
      */
     get points(): PackedVector3Array { return _C(this, 5958) as PackedVector3Array; }
-    set points(v: PackedVector3Array) { _C(this, 12369, v); }
+    set points(v: PackedVector3Array | Vector3[]) { _C(this, 12369, v); }
 
     static readonly name = _R(229, ConvexPolygonShape3D);
 }

package/gen/classes/DPITexture.ts

@@ -67,7 +67,7 @@ export class DPITexture extends Texture2D {
      * If set, remaps texture colors according to {@link Color}-{@link Color} map.
      */
     get colorMap(): GodotDictionary { return _C(this, 4226) as GodotDictionary; }
-    set colorMap(v: GodotDictionary) { _C(this, 10910, v); }
+    set colorMap(v: GodotDictionary | Record<string, any>) { _C(this, 10910, v); }
 
     static readonly name = _R(242, DPITexture);
 }

package/gen/classes/FileDialog.ts

@@ -188,7 +188,7 @@ export class FileDialog extends ConfirmationDialog {
      * **Note:** Embedded file dialogs and Windows file dialogs support only file extensions, while Android, Linux, and macOS file dialogs also support MIME types.
      */
     get filters(): PackedStringArray { return _C(this, 4789) as PackedStringArray; }
-    set filters(v: PackedStringArray) { _C(this, 11396, v); }
+    set filters(v: PackedStringArray | string[]) { _C(this, 11396, v); }
 
     /**
      * The filter for file names (case-insensitive). When set to a non-empty string, only files that contains the substring will be shown. {@link filenameFilter} can be edited by the user with the filter button at the top of the file dialog.

package/gen/classes/Font.ts

@@ -236,7 +236,7 @@ export class Font extends Resource {
      * If this array is empty in a {@link FontVariation}, the {@link FontVariation.baseFont}'s fallbacks are used instead.
      */
     get fallbacks(): GodotArray<Font> { return _C(this, 4757) as GodotArray<Font>; }
-    set fallbacks(v: GodotArray<Font>) { _C(this, 11368, v); }
+    set fallbacks(v: GodotArray<Font> | Font[]) { _C(this, 11368, v); }
 
     static readonly name = _R(272, Font);
 }

package/gen/classes/FontFile.ts

@@ -380,7 +380,7 @@ export class FontFile extends Font {
      * Contents of the dynamic font source file.
      */
     get data(): PackedByteArray { return _C(this, 4410) as PackedByteArray; }
-    set data(v: PackedByteArray) { _C(this, 11034, v); }
+    set data(v: PackedByteArray | number[]) { _C(this, 11034, v); }
 
     /**
      * If set to `true`, generate mipmaps for the font textures.
@@ -502,7 +502,7 @@ export class FontFile extends Font {
      * Font OpenType feature set override.
      */
     get opentypeFeatureOverrides(): GodotDictionary { return _C(this, 5723) as GodotDictionary; }
-    set opentypeFeatureOverrides(v: GodotDictionary) { _C(this, 12190, v); }
+    set opentypeFeatureOverrides(v: GodotDictionary | Record<string, any>) { _C(this, 12190, v); }
 
     /**
      * If set to a positive value, overrides the oversampling factor of the viewport this font is used in. See {@link Viewport.oversampling}. This value doesn't override the {@link code skip-lint}oversampling[/code] parameter of {@link code skip-lint}draw_*[/code] methods.

package/gen/classes/FontVariation.ts

@@ -4,7 +4,7 @@
 import { _C, _R } from '../../src/runtime.ts';
 import { Font } from './Font.ts';
 import type { GodotDictionary, PackedColorArray } from '../heap-types/index.ts';
-import type { Transform2D } from '../value-types/index.ts';
+import type { Color, Transform2D } from '../value-types/index.ts';
 
 /**
  * Provides OpenType variations, simulated bold / slant, and additional font settings like OpenType features and extra spacing.
@@ -49,7 +49,7 @@ export class FontVariation extends Font {
      * **Note:** To get available variation axes of a font, use {@link Font.getSupportedVariationList}.
      */
     get variationOpentype(): GodotDictionary { return _C(this, 7026) as GodotDictionary; }
-    set variationOpentype(v: GodotDictionary) { _C(this, 13275, v); }
+    set variationOpentype(v: GodotDictionary | Record<string, any>) { _C(this, 13275, v); }
 
     /**
      * Active face index in the TrueType / OpenType collection file.
@@ -75,7 +75,7 @@ export class FontVariation extends Font {
      * A set of OpenType feature tags. More info: [OpenType feature tags](https://docs.microsoft.com/en-us/typography/opentype/spec/featuretags).
      */
     get opentypeFeatures(): GodotDictionary { return _C(this, 5724) as GodotDictionary; }
-    set opentypeFeatures(v: GodotDictionary) { _C(this, 12191, v); }
+    set opentypeFeatures(v: GodotDictionary | Record<string, any>) { _C(this, 12191, v); }
 
     /**
      * Extra spacing between graphical glyphs.
@@ -117,7 +117,7 @@ export class FontVariation extends Font {
      * An array of colors to override predefined palette. Use `Color(0, 0, 0, 0)`, to keep predefined palette color at specific position.
      */
     get paletteCustomColors(): PackedColorArray { return _C(this, 5797) as PackedColorArray; }
-    set paletteCustomColors(v: PackedColorArray) { _C(this, 12238, v); }
+    set paletteCustomColors(v: PackedColorArray | Color[]) { _C(this, 12238, v); }
 
     static readonly name = _R(274, FontVariation);
 }

package/gen/classes/GLTFAccessor.ts

@@ -68,13 +68,13 @@ export class GLTFAccessor extends Resource {
      * Minimum value of each component in this accessor.
      */
     get min(): PackedFloat64Array { return _C(this, 5537) as PackedFloat64Array; }
-    set min(v: PackedFloat64Array) { _C(this, 12048, v); }
+    set min(v: PackedFloat64Array | number[]) { _C(this, 12048, v); }
 
     /**
      * Maximum value of each component in this accessor.
      */
     get max(): PackedFloat64Array { return _C(this, 5456) as PackedFloat64Array; }
-    set max(v: PackedFloat64Array) { _C(this, 11982, v); }
+    set max(v: PackedFloat64Array | number[]) { _C(this, 11982, v); }
 
     /**
      * Number of deviating accessor values stored in the sparse array.

package/gen/classes/GLTFMesh.ts

@@ -41,13 +41,13 @@ export class GLTFMesh extends Resource {
      * An array of floats representing the blend weights of the mesh.
      */
     get blendWeights(): PackedFloat32Array { return _C(this, 3944) as PackedFloat32Array; }
-    set blendWeights(v: PackedFloat32Array) { _C(this, 10688, v); }
+    set blendWeights(v: PackedFloat32Array | number[]) { _C(this, 10688, v); }
 
     /**
      * An array of Material objects representing the materials used in the mesh.
      */
     get instanceMaterials(): GodotArray<Material> { return _C(this, 5135) as GodotArray<Material>; }
-    set instanceMaterials(v: GodotArray<Material>) { _C(this, 11728, v); }
+    set instanceMaterials(v: GodotArray<Material> | Material[]) { _C(this, 11728, v); }
 
     static readonly name = _R(287, GLTFMesh);
 }

package/gen/classes/GLTFNode.ts

@@ -107,7 +107,7 @@ export class GLTFNode extends Resource {
      * The indices of the child nodes in the {@link GLTFState}. If this glTF node has no children, this will be an empty array.
      */
     get children(): PackedInt32Array { return _C(this, 4148) as PackedInt32Array; }
-    set children(v: PackedInt32Array) { _C(this, 10853, v); }
+    set children(v: PackedInt32Array | number[]) { _C(this, 10853, v); }
 
     /**
      * If this glTF node is a light, the index of the {@link GLTFLight} in the {@link GLTFState} that describes the light's properties. If -1, this node is not a light.

package/gen/classes/GLTFObjectModelProperty.ts

@@ -62,7 +62,7 @@ export class GLTFObjectModelProperty extends RefCounted {
      * In most cases {@link nodePaths} will only have one item, but in some cases a single glTF JSON pointer will map to multiple Godot properties. For example, a {@link GLTFCamera} or {@link GLTFLight} used on multiple glTF nodes will be represented by multiple Godot nodes.
      */
     get nodePaths(): GodotArray<NodePath> { return _C(this, 5656) as GodotArray<NodePath>; }
-    set nodePaths(v: GodotArray<NodePath>) { _C(this, 12138, v); }
+    set nodePaths(v: GodotArray<NodePath> | NodePath[]) { _C(this, 12138, v); }
 
     /**
      * The type of data stored in the glTF file as defined by the object model. This is a superset of the available accessor types, and determines the accessor type.
@@ -74,7 +74,7 @@ export class GLTFObjectModelProperty extends RefCounted {
      * The glTF object model JSON pointers used to identify the property in the glTF object model. In most cases, there will be only one item in this array, but specific cases may require multiple pointers. The items are themselves arrays which represent the JSON pointer split into its components.
      */
     get jsonPointers(): GodotArray<PackedStringArray> { return _C(this, 5278) as GodotArray<PackedStringArray>; }
-    set jsonPointers(v: GodotArray<PackedStringArray>) { _C(this, 11851, v); }
+    set jsonPointers(v: GodotArray<PackedStringArray> | PackedStringArray[]) { _C(this, 11851, v); }
 
     /**
      * The type of data stored in the Godot property. This is the type of the property that the {@link nodePaths} point to.

package/gen/classes/GLTFSkeleton.ts

@@ -17,16 +17,16 @@ export class GLTFSkeleton extends Resource {
     getBoneAttachment(idx: number): BoneAttachment3D { return _C(this, 3958, idx) as BoneAttachment3D; }
 
     get joints(): PackedInt32Array { return _C(this, 5261) as PackedInt32Array; }
-    set joints(v: PackedInt32Array) { _C(this, 11843, v); }
+    set joints(v: PackedInt32Array | number[]) { _C(this, 11843, v); }
 
     get roots(): PackedInt32Array { return _C(this, 6203) as PackedInt32Array; }
-    set roots(v: PackedInt32Array) { _C(this, 12575, v); }
+    set roots(v: PackedInt32Array | number[]) { _C(this, 12575, v); }
 
     get uniqueNames(): GodotArray<string> { return _C(this, 6952) as GodotArray<string>; }
-    set uniqueNames(v: GodotArray<string>) { _C(this, 13173, v); }
+    set uniqueNames(v: GodotArray<string> | string[]) { _C(this, 13173, v); }
 
     get godotBoneNode(): GodotDictionary { return _C(this, 4964) as GodotDictionary; }
-    set godotBoneNode(v: GodotDictionary) { _C(this, 11547, v); }
+    set godotBoneNode(v: GodotDictionary | Record<string, any>) { _C(this, 11547, v); }
 
     static readonly name = _R(292, GLTFSkeleton);
 }

package/gen/classes/GLTFSkin.ts

@@ -14,28 +14,28 @@ export class GLTFSkin extends Resource {
     set skinRoot(v: number) { _C(this, 12764, v); }
 
     get jointsOriginal(): PackedInt32Array { return _C(this, 5262) as PackedInt32Array; }
-    set jointsOriginal(v: PackedInt32Array) { _C(this, 11844, v); }
+    set jointsOriginal(v: PackedInt32Array | number[]) { _C(this, 11844, v); }
 
     get inverseBinds(): GodotArray<Transform3D> { return _C(this, 5160) as GodotArray<Transform3D>; }
-    set inverseBinds(v: GodotArray<Transform3D>) { _C(this, 11746, v); }
+    set inverseBinds(v: GodotArray<Transform3D> | Transform3D[]) { _C(this, 11746, v); }
 
     get joints(): PackedInt32Array { return _C(this, 5261) as PackedInt32Array; }
-    set joints(v: PackedInt32Array) { _C(this, 11843, v); }
+    set joints(v: PackedInt32Array | number[]) { _C(this, 11843, v); }
 
     get nonJoints(): PackedInt32Array { return _C(this, 5672) as PackedInt32Array; }
-    set nonJoints(v: PackedInt32Array) { _C(this, 12143, v); }
+    set nonJoints(v: PackedInt32Array | number[]) { _C(this, 12143, v); }
 
     get roots(): PackedInt32Array { return _C(this, 6203) as PackedInt32Array; }
-    set roots(v: PackedInt32Array) { _C(this, 12575, v); }
+    set roots(v: PackedInt32Array | number[]) { _C(this, 12575, v); }
 
     get skeleton(): number { return _C(this, 6405) as number; }
     set skeleton(v: number) { _C(this, 12757, v); }
 
     get jointIToBoneI(): GodotDictionary { return _C(this, 5241) as GodotDictionary; }
-    set jointIToBoneI(v: GodotDictionary) { _C(this, 11823, v); }
+    set jointIToBoneI(v: GodotDictionary | Record<string, any>) { _C(this, 11823, v); }
 
     get jointIToName(): GodotDictionary { return _C(this, 5242) as GodotDictionary; }
-    set jointIToName(v: GodotDictionary) { _C(this, 11824, v); }
+    set jointIToName(v: GodotDictionary | Record<string, any>) { _C(this, 11824, v); }
 
     get godotSkin(): Skin { return _C(this, 4966) as Skin; }
     set godotSkin(v: Skin) { _C(this, 11548, v); }