typescript-to-gdscript 0.1.0

package/typings/classes/CurveTexture.d.ts

@@ -0,0 +1,30 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 1D texture where pixel brightness corresponds to points on a curve. */
+declare class CurveTexture extends Texture2D {
+  /** The {@link Curve} that is rendered onto the texture. Should be a unit {@link Curve}. */
+  curve: Curve | null;
+  /**
+   * <member name="texture_mode" type="int" setter="set_texture_mode" getter="get_texture_mode" enum="CurveTexture.TextureMode" default="0">
+   * The format the texture should be generated with. When passing a CurveTexture as an input to a {@link Shader}, this may need to be adjusted.
+   */
+  resource_local_to_scene: boolean;
+  /**
+   * The width of the texture (in pixels). Higher values make it possible to represent high-frequency data better (such as sudden direction changes), at the cost of increased generation time and memory usage.
+   */
+  width: int;
+  set_curve(value: Curve | null): void;
+  get_curve(): Curve | null;
+  set_width(value: int): void;
+
+  // enum TextureMode
+  /**
+   * Store the curve equally across the red, green and blue channels. This uses more video memory, but is more compatible with shaders that only read the green and blue values.
+   */
+  static readonly TEXTURE_MODE_RGB: int;
+  /**
+   * Store the curve only in the red channel. This saves video memory, but some custom shaders may not be able to work with this.
+   */
+  static readonly TEXTURE_MODE_RED: int;
+}

package/typings/classes/CurveXYZTexture.d.ts

@@ -0,0 +1,25 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 1D texture where the red, green, and blue color channels correspond to points on 3 curves. */
+declare class CurveXYZTexture extends Texture2D {
+  /** The {@link Curve} that is rendered onto the texture's red channel. Should be a unit {@link Curve}. */
+  curve_x: Curve | null;
+  /**
+   * The {@link Curve} that is rendered onto the texture's green channel. Should be a unit {@link Curve}.
+   */
+  curve_y: Curve | null;
+  /** The {@link Curve} that is rendered onto the texture's blue channel. Should be a unit {@link Curve}. */
+  curve_z: Curve | null;
+  /**
+   * <member name="width" type="int" setter="set_width" getter="get_width" default="256">
+   * The width of the texture (in pixels). Higher values make it possible to represent high-frequency data better (such as sudden direction changes), at the cost of increased generation time and memory usage.
+   */
+  resource_local_to_scene: boolean;
+  set_curve_x(value: Curve | null): void;
+  get_curve_x(): Curve | null;
+  set_curve_y(value: Curve | null): void;
+  get_curve_y(): Curve | null;
+  set_curve_z(value: Curve | null): void;
+  get_curve_z(): Curve | null;
+}

package/typings/classes/CylinderMesh.d.ts

@@ -0,0 +1,48 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Class representing a cylindrical {@link PrimitiveMesh}. */
+declare class CylinderMesh extends PrimitiveMesh {
+  /**
+   * Bottom radius of the cylinder. If set to `0.0`, the bottom faces will not be generated, resulting in a conic shape. See also {@link cap_bottom}.
+   */
+  bottom_radius: float;
+  /**
+   * If `true`, generates a cap at the bottom of the cylinder. This can be set to `false` to speed up generation and rendering when the cap is never seen by the camera. See also {@link bottom_radius}.
+   * **Note:** If {@link bottom_radius} is `0.0`, cap generation is always skipped even if {@link cap_bottom} is `true`.
+   */
+  cap_bottom: boolean;
+  /**
+   * If `true`, generates a cap at the top of the cylinder. This can be set to `false` to speed up generation and rendering when the cap is never seen by the camera. See also {@link top_radius}.
+   * **Note:** If {@link top_radius} is `0.0`, cap generation is always skipped even if {@link cap_top} is `true`.
+   */
+  cap_top: boolean;
+  /** Full height of the cylinder. */
+  height: float;
+  /**
+   * Number of radial segments on the cylinder. Higher values result in a more detailed cylinder/cone at the cost of performance.
+   */
+  radial_segments: int;
+  /**
+   * Number of edge rings along the height of the cylinder. Changing {@link rings} does not have any visual impact unless a shader or procedural mesh tool is used to alter the vertex data. Higher values result in more subdivisions, which can be used to create smoother-looking effects with shaders or procedural mesh tools (at the cost of performance). When not altering the vertex data using a shader or procedural mesh tool, {@link rings} should be kept to its default value.
+   */
+  rings: int;
+  /**
+   * Top radius of the cylinder. If set to `0.0`, the top faces will not be generated, resulting in a conic shape. See also {@link cap_top}.
+   */
+  top_radius: float;
+  set_bottom_radius(value: float): void;
+  get_bottom_radius(): float;
+  set_cap_bottom(value: boolean): void;
+  is_cap_bottom(): boolean;
+  set_cap_top(value: boolean): void;
+  is_cap_top(): boolean;
+  set_height(value: float): void;
+  get_height(): float;
+  set_radial_segments(value: int): void;
+  get_radial_segments(): int;
+  set_rings(value: int): void;
+  get_rings(): int;
+  set_top_radius(value: float): void;
+  get_top_radius(): float;
+}

package/typings/classes/CylinderShape3D.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D cylinder shape used for physics collision. */
+declare class CylinderShape3D extends Shape3D {
+  /** The cylinder's height. */
+  height: float;
+  /** The cylinder's radius. */
+  radius: float;
+  set_height(value: float): void;
+  get_height(): float;
+  set_radius(value: float): void;
+  get_radius(): float;
+}

package/typings/classes/DPITexture.d.ts

@@ -0,0 +1,48 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An automatically scalable {@link Texture2D} based on an SVG image. */
+declare class DPITexture extends Texture2D {
+  /** Texture scale. `1.0` is the original SVG size. Higher values result in a larger image. */
+  base_scale: float;
+  /** If set, remaps texture colors according to {@link Color}-{@link Color} map. */
+  color_map: Dictionary;
+  /**
+   * If `true`, puts pixels of the same surrounding color in transition from transparent to opaque areas. For textures displayed with bilinear filtering, this helps to reduce the outline effect when exporting images from an image editor.
+   */
+  fix_alpha_border: boolean;
+  /**
+   * An alternative to fixing darkened borders with {@link fix_alpha_border} is to use premultiplied alpha. By enabling this option, the texture will be converted to this format. A premultiplied alpha texture requires specific materials to be displayed correctly:
+   * - In 2D, a {@link CanvasItemMaterial} will need to be created and configured to use the {@link CanvasItemMaterial.BLEND_MODE_PREMULT_ALPHA} blend mode on {@link CanvasItem}s that use this texture. In custom `canvas_item` shaders, `render_mode blend_premul_alpha;` should be used.
+   * - In 3D, a {@link BaseMaterial3D} will need to be created and configured to use the {@link BaseMaterial3D.BLEND_MODE_PREMULT_ALPHA} blend mode on materials that use this texture. In custom `spatial` shaders, `render_mode blend_premul_alpha;` should be used.
+   */
+  premult_alpha: boolean;
+  /**
+   * <member name="saturation" type="float" setter="set_saturation" getter="get_saturation" default="1.0">
+   * Overrides texture saturation.
+   */
+  resource_local_to_scene: boolean;
+  set_base_scale(value: float): void;
+  get_base_scale(): float;
+  set_color_map(value: Dictionary): void;
+  get_color_map(): Dictionary;
+  set_fix_alpha_border(value: boolean): void;
+  get_fix_alpha_border(): boolean;
+  set_premult_alpha(value: boolean): void;
+  get_premult_alpha(): boolean;
+
+  /**
+   * Creates a new {@link DPITexture} and initializes it by allocating and setting the SVG data to `source`.
+   */
+  static create_from_string(source: string | NodePath, scale?: float, saturation?: float, color_map?: Dictionary): DPITexture | null;
+  /**
+   * Returns the {@link RID} of the texture rasterized to match the oversampling of the currently drawn canvas item.
+   */
+  get_scaled_rid(): RID;
+  /** Returns this SVG texture's source code. */
+  get_source(): string;
+  /** Resizes the texture to the specified dimensions. */
+  set_size_override(size: Vector2i | Vector2): void;
+  /** Sets this SVG texture's source code. */
+  set_source(source: string | NodePath): void;
+}

package/typings/classes/DTLSServer.d.ts

@@ -0,0 +1,13 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Helper class to implement a DTLS server. */
+declare class DTLSServer extends RefCounted {
+  /** Setup the DTLS server to use the given `server_options`. See {@link TLSOptions.server}. */
+  setup(server_options: TLSOptions): int;
+  /**
+   * Try to initiate the DTLS handshake with the given `udp_peer` which must be already connected (see {@link PacketPeerUDP.connect_to_host}).
+   * **Note:** You must check that the state of the return PacketPeerUDP is {@link PacketPeerDTLS.STATUS_HANDSHAKING}, as it is normal that 50% of the new connections will be invalid due to cookie exchange.
+   */
+  take_connection(udp_peer: PacketPeerUDP): PacketPeerDTLS | null;
+}

package/typings/classes/DampedSpringJoint2D.d.ts

@@ -0,0 +1,28 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A physics joint that connects two 2D physics bodies with a spring-like force. */
+declare class DampedSpringJoint2D extends Joint2D {
+  /**
+   * The spring joint's damping ratio. A value between `0` and `1`. When the two bodies move into different directions the system tries to align them to the spring axis again. A high {@link damping} value forces the attached bodies to align faster.
+   */
+  damping: float;
+  /** The spring joint's maximum length. The two attached bodies cannot stretch it past this value. */
+  length: float;
+  /**
+   * When the bodies attached to the spring joint move they stretch or squash it. The joint always tries to resize towards this length.
+   */
+  rest_length: float;
+  /**
+   * The higher the value, the less the bodies attached to the joint will deform it. The joint applies an opposing force to the bodies, the product of the stiffness multiplied by the size difference from its resting length.
+   */
+  stiffness: float;
+  set_damping(value: float): void;
+  get_damping(): float;
+  set_length(value: float): void;
+  get_length(): float;
+  set_rest_length(value: float): void;
+  get_rest_length(): float;
+  set_stiffness(value: float): void;
+  get_stiffness(): float;
+}

package/typings/classes/Decal.d.ts

@@ -0,0 +1,120 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Node that projects a texture onto a {@link MeshInstance3D}. */
+declare class Decal extends VisualInstance3D {
+  /**
+   * Blends the albedo {@link Color} of the decal with albedo {@link Color} of the underlying mesh. This can be set to `0.0` to create a decal that only affects normal or ORM. In this case, an albedo texture is still required as its alpha channel will determine where the normal and ORM will be overridden. See also {@link modulate}.
+   */
+  albedo_mix: float;
+  /**
+   * Specifies which {@link VisualInstance3D.layers} this decal will project on. By default, Decals affect all layers. This is used so you can specify which types of objects receive the Decal and which do not. This is especially useful so you can ensure that dynamic objects don't accidentally receive a Decal intended for the terrain under them.
+   */
+  cull_mask: int;
+  /** The distance from the camera at which the Decal begins to fade away (in 3D units). */
+  distance_fade_begin: float;
+  /**
+   * If `true`, decals will smoothly fade away when far from the active {@link Camera3D} starting at {@link distance_fade_begin}. The Decal will fade out over {@link distance_fade_begin} + {@link distance_fade_length}, after which it will be culled and not sent to the shader at all. Use this to reduce the number of active Decals in a scene and thus improve performance.
+   */
+  distance_fade_enabled: boolean;
+  /**
+   * The distance over which the Decal fades (in 3D units). The Decal becomes slowly more transparent over this distance and is completely invisible at the end. Higher values result in a smoother fade-out transition, which is more suited when the camera moves fast.
+   */
+  distance_fade_length: float;
+  /**
+   * Energy multiplier for the emission texture. This will make the decal emit light at a higher or lower intensity, independently of the albedo color. See also {@link modulate}.
+   */
+  emission_energy: float;
+  /**
+   * Sets the curve over which the decal will fade as the surface gets further from the center of the {@link AABB}. Only positive values are valid (negative values will be clamped to `0.0`). See also {@link upper_fade}.
+   */
+  lower_fade: float;
+  /**
+   * Changes the {@link Color} of the Decal by multiplying the albedo and emission colors with this value. The alpha component is only taken into account when multiplying the albedo color, not the emission color. See also {@link emission_energy} and {@link albedo_mix} to change the emission and albedo intensity independently of each other.
+   */
+  modulate: Color;
+  /**
+   * Fades the Decal if the angle between the Decal's {@link AABB} and the target surface becomes too large. A value of `0` projects the Decal regardless of angle, a value of `1` limits the Decal to surfaces that are nearly perpendicular.
+   * **Note:** Setting {@link normal_fade} to a value greater than `0.0` has a small performance cost due to the added normal angle computations.
+   */
+  normal_fade: float;
+  /**
+   * Sets the size of the {@link AABB} used by the decal. All dimensions must be set to a value greater than zero (they will be clamped to `0.001` if this is not the case). The AABB goes from `-size/2` to `size/2`.
+   * **Note:** To improve culling efficiency of "hard surface" decals, set their {@link upper_fade} and {@link lower_fade} to `0.0` and set the Y component of the {@link size} as low as possible. This will reduce the decals' AABB size without affecting their appearance.
+   */
+  size: Vector3;
+  /**
+   * {@link Texture2D} with the base {@link Color} of the Decal. Either this or the {@link texture_emission} must be set for the Decal to be visible. Use the alpha channel like a mask to smoothly blend the edges of the decal with the underlying object.
+   * **Note:** Unlike {@link BaseMaterial3D} whose filter mode can be adjusted on a per-material basis, the filter mode for {@link Decal} textures is set globally with {@link ProjectSettings.rendering/textures/decals/filter}.
+   */
+  texture_albedo: Texture2D | null;
+  /**
+   * {@link Texture2D} with the emission {@link Color} of the Decal. Either this or the {@link texture_albedo} must be set for the Decal to be visible. Use the alpha channel like a mask to smoothly blend the edges of the decal with the underlying object.
+   * **Note:** Unlike {@link BaseMaterial3D} whose filter mode can be adjusted on a per-material basis, the filter mode for {@link Decal} textures is set globally with {@link ProjectSettings.rendering/textures/decals/filter}.
+   */
+  texture_emission: Texture2D | null;
+  /**
+   * {@link Texture2D} with the per-pixel normal map for the decal. Use this to add extra detail to decals.
+   * **Note:** Unlike {@link BaseMaterial3D} whose filter mode can be adjusted on a per-material basis, the filter mode for {@link Decal} textures is set globally with {@link ProjectSettings.rendering/textures/decals/filter}.
+   * **Note:** Setting this texture alone will not result in a visible decal, as {@link texture_albedo} must also be set. To create a normal-only decal, load an albedo texture into {@link texture_albedo} and set {@link albedo_mix} to `0.0`. The albedo texture's alpha channel will be used to determine where the underlying surface's normal map should be overridden (and its intensity).
+   */
+  texture_normal: Texture2D | null;
+  /**
+   * {@link Texture2D} storing ambient occlusion, roughness, and metallic for the decal. Use this to add extra detail to decals.
+   * **Note:** Unlike {@link BaseMaterial3D} whose filter mode can be adjusted on a per-material basis, the filter mode for {@link Decal} textures is set globally with {@link ProjectSettings.rendering/textures/decals/filter}.
+   * **Note:** Setting this texture alone will not result in a visible decal, as {@link texture_albedo} must also be set. To create an ORM-only decal, load an albedo texture into {@link texture_albedo} and set {@link albedo_mix} to `0.0`. The albedo texture's alpha channel will be used to determine where the underlying surface's ORM map should be overridden (and its intensity).
+   * **Note:** Due to technical limitations, modifying the underlying surface's roughness using {@link texture_orm} does *not* affect screen-space reflections ({@link Environment.ssr_enabled}), reflections from {@link VoxelGI}, and reflections from SDFGI ({@link Environment.sdfgi_enabled}). Only reflections from {@link ReflectionProbe}s are affected.
+   */
+  texture_orm: Texture2D | null;
+  /**
+   * Sets the curve over which the decal will fade as the surface gets further from the center of the {@link AABB}. Only positive values are valid (negative values will be clamped to `0.0`). See also {@link lower_fade}.
+   */
+  upper_fade: float;
+  set_albedo_mix(value: float): void;
+  get_albedo_mix(): float;
+  set_cull_mask(value: int): void;
+  get_cull_mask(): int;
+  set_distance_fade_begin(value: float): void;
+  get_distance_fade_begin(): float;
+  set_enable_distance_fade(value: boolean): void;
+  is_distance_fade_enabled(): boolean;
+  set_distance_fade_length(value: float): void;
+  get_distance_fade_length(): float;
+  set_emission_energy(value: float): void;
+  get_emission_energy(): float;
+  set_lower_fade(value: float): void;
+  get_lower_fade(): float;
+  set_modulate(value: Color): void;
+  get_modulate(): Color;
+  set_normal_fade(value: float): void;
+  get_normal_fade(): float;
+  set_size(value: Vector3 | Vector3i): void;
+  get_size(): Vector3;
+  set_upper_fade(value: float): void;
+  get_upper_fade(): float;
+
+  /**
+   * Returns the {@link Texture2D} associated with the specified {@link DecalTexture}. This is a convenience method, in most cases you should access the texture directly.
+   * For example, instead of `albedo_tex = $Decal.get_texture(Decal.TEXTURE_ALBEDO)`, use `albedo_tex = $Decal.texture_albedo`.
+   * One case where this is better than accessing the texture directly is when you want to copy one Decal's textures to another. For example:
+   */
+  get_texture(type_: int): Texture2D | null;
+  /**
+   * Sets the {@link Texture2D} associated with the specified {@link DecalTexture}. This is a convenience method, in most cases you should access the texture directly.
+   * For example, instead of `$Decal.set_texture(Decal.TEXTURE_ALBEDO, albedo_tex)`, use `$Decal.texture_albedo = albedo_tex`.
+   * One case where this is better than accessing the texture directly is when you want to copy one Decal's textures to another. For example:
+   */
+  set_texture(type_: int, texture: Texture2D): void;
+
+  // enum DecalTexture
+  /** {@link Texture2D} corresponding to {@link texture_albedo}. */
+  static readonly TEXTURE_ALBEDO: int;
+  /** {@link Texture2D} corresponding to {@link texture_normal}. */
+  static readonly TEXTURE_NORMAL: int;
+  /** {@link Texture2D} corresponding to {@link texture_orm}. */
+  static readonly TEXTURE_ORM: int;
+  /** {@link Texture2D} corresponding to {@link texture_emission}. */
+  static readonly TEXTURE_EMISSION: int;
+  /** Max size of {@link DecalTexture} enum. */
+  static readonly TEXTURE_MAX: int;
+}

package/typings/classes/Dictionary.d.ts

@@ -0,0 +1,181 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A built-in data structure that holds key-value pairs. */
+declare interface Object {
+  /**
+   * Assigns elements of another `dictionary` into the dictionary. Resizes the dictionary to match `dictionary`. Performs type conversions if the dictionary is typed.
+   */
+  assign(dictionary: Dictionary): void;
+  /** Clears the dictionary, removing all entries from it. */
+  clear(): void;
+  /**
+   * Returns a new copy of the dictionary.
+   * By default, a **shallow** copy is returned: all nested {@link Array}, {@link Dictionary}, and {@link Resource} keys and values are shared with the original dictionary. Modifying any of those in one dictionary will also affect them in the other.
+   * If `deep` is `true`, a **deep** copy is returned: all nested arrays and dictionaries are also duplicated (recursively). Any {@link Resource} is still shared with the original dictionary, though.
+   */
+  duplicate(deep?: boolean): Dictionary;
+  /**
+   * Duplicates this dictionary, deeply, like {@link duplicate} when passing `true`, with extra control over how subresources are handled.
+   * `deep_subresources_mode` must be one of the values from {@link Resource.DeepDuplicateMode}. By default, only internal resources will be duplicated (recursively).
+   */
+  duplicate_deep(deep_subresources_mode?: int): Dictionary;
+  /**
+   * Removes the dictionary entry by key, if it exists. Returns `true` if the given `key` existed in the dictionary, otherwise `false`.
+   * **Note:** Do not erase entries while iterating over the dictionary. You can iterate over the {@link keys} array instead.
+   */
+  erase(key: unknown): boolean;
+  /**
+   * Finds and returns the first key whose associated value is equal to `value`, or `null` if it is not found.
+   * **Note:** `null` is also a valid key. If inside the dictionary, {@link find_key} may give misleading results.
+   */
+  find_key(value: unknown): unknown;
+  /**
+   * Returns the corresponding value for the given `key` in the dictionary. If the `key` does not exist, returns `default`, or `null` if the parameter is omitted.
+   * **Note:** If the `default` argument is computationally expensive or has unwanted side effects, consider using the {@link has} method instead:
+   */
+  get(key: unknown, default_?: unknown): unknown;
+  /**
+   * Gets a value and ensures the key is set. If the `key` exists in the dictionary, this behaves like {@link get}. Otherwise, the `default` value is inserted into the dictionary and returned.
+   */
+  get_or_add(key: unknown, default_?: unknown): unknown;
+  /**
+   * Returns the built-in {@link Variant} type of the typed dictionary's keys as a {@link Variant.Type} constant. If the keys are not typed, returns {@link TYPE_NIL}. See also {@link is_typed_key}.
+   */
+  get_typed_key_builtin(): int;
+  /**
+   * Returns the **built-in** class name of the typed dictionary's keys, if the built-in {@link Variant} type is {@link TYPE_OBJECT}. Otherwise, returns an empty {@link StringName}. See also {@link is_typed_key} and {@link Object.get_class}.
+   */
+  get_typed_key_class_name(): string;
+  /**
+   * Returns the {@link Script} instance associated with this typed dictionary's keys, or `null` if it does not exist. See also {@link is_typed_key}.
+   */
+  get_typed_key_script(): unknown;
+  /**
+   * Returns the built-in {@link Variant} type of the typed dictionary's values as a {@link Variant.Type} constant. If the values are not typed, returns {@link TYPE_NIL}. See also {@link is_typed_value}.
+   */
+  get_typed_value_builtin(): int;
+  /**
+   * Returns the **built-in** class name of the typed dictionary's values, if the built-in {@link Variant} type is {@link TYPE_OBJECT}. Otherwise, returns an empty {@link StringName}. See also {@link is_typed_value} and {@link Object.get_class}.
+   */
+  get_typed_value_class_name(): string;
+  /**
+   * Returns the {@link Script} instance associated with this typed dictionary's values, or `null` if it does not exist. See also {@link is_typed_value}.
+   */
+  get_typed_value_script(): unknown;
+  /**
+   * Returns `true` if the dictionary contains an entry with the given `key`.
+   * In GDScript, this is equivalent to the `in` operator:
+   * **Note:** This method returns `true` as long as the `key` exists, even if its corresponding value is `null`.
+   */
+  has(key: unknown): boolean;
+  /** Returns `true` if the dictionary contains all keys in the given `keys` array. */
+  has_all(keys: Array<unknown>): boolean;
+  /**
+   * Returns a hashed 32-bit integer value representing the dictionary contents.
+   * **Note:** Dictionaries with the same entries but in a different order will not have the same hash.
+   * **Note:** Dictionaries with equal hash values are *not* guaranteed to be the same, because of hash collisions. On the contrary, dictionaries with different hash values are guaranteed to be different.
+   */
+  hash(): int;
+  /** Returns `true` if the dictionary is empty (its size is `0`). See also {@link size}. */
+  is_empty(): boolean;
+  /**
+   * Returns `true` if the dictionary is read-only. See {@link make_read_only}. Dictionaries are automatically read-only if declared with `const` keyword.
+   */
+  is_read_only(): boolean;
+  /** Returns `true` if the dictionary is typed the same as `dictionary`. */
+  is_same_typed(dictionary: Dictionary): boolean;
+  /** Returns `true` if the dictionary's keys are typed the same as `dictionary`'s keys. */
+  is_same_typed_key(dictionary: Dictionary): boolean;
+  /** Returns `true` if the dictionary's values are typed the same as `dictionary`'s values. */
+  is_same_typed_value(dictionary: Dictionary): boolean;
+  /**
+   * Returns `true` if the dictionary is typed. Typed dictionaries can only store keys/values of their associated type and provide type safety for the `[]` operator. Methods of typed dictionary still return {@link Variant}.
+   */
+  is_typed(): boolean;
+  /** Returns `true` if the dictionary's keys are typed. */
+  is_typed_key(): boolean;
+  /** Returns `true` if the dictionary's values are typed. */
+  is_typed_value(): boolean;
+  /** Returns the list of keys in the dictionary. */
+  keys(): Array<unknown>;
+  /**
+   * Makes the dictionary read-only, i.e. disables modification of the dictionary's contents. Does not apply to nested content, e.g. content of nested dictionaries.
+   */
+  make_read_only(): void;
+  /**
+   * Adds entries from `dictionary` to this dictionary. By default, duplicate keys are not copied over, unless `overwrite` is `true`.
+   * **Note:** {@link merge} is *not* recursive. Nested dictionaries are considered as keys that can be overwritten or not depending on the value of `overwrite`, but they will never be merged together.
+   */
+  merge(dictionary: Dictionary, overwrite?: boolean): void;
+  /**
+   * Returns a copy of this dictionary merged with the other `dictionary`. By default, duplicate keys are not copied over, unless `overwrite` is `true`. See also {@link merge}.
+   * This method is useful for quickly making dictionaries with default values:
+   */
+  merged(dictionary: Dictionary, overwrite?: boolean): Dictionary;
+  /**
+   * Returns `true` if the two dictionaries contain the same keys and values, inner {@link Dictionary} and {@link Array} keys and values are compared recursively.
+   */
+  recursive_equal(dictionary: Dictionary, recursion_count: int): boolean;
+  /**
+   * Sets the value of the element at the given `key` to the given `value`. Returns `true` if the value is set successfully. Fails and returns `false` if the dictionary is read-only, or if `key` and `value` don't match the dictionary's types. This is the same as using the `[]` operator (`dict[key] = value`).
+   */
+  set(key: unknown, value: unknown): boolean;
+  /**
+   * Returns the number of entries in the dictionary. Empty dictionaries (`{ }`) always return `0`. See also {@link is_empty}.
+   */
+  size(): int;
+  /**
+   * Sorts the dictionary in ascending order, by key. The final order is dependent on the "less than" (`<`) comparison between keys.
+   * This method ensures that the dictionary's entries are ordered consistently when {@link keys} or {@link values} are called, or when the dictionary needs to be converted to a string through {@link @GlobalScope.str} or {@link JSON.stringify}.
+   */
+  sort(): void;
+  /** Returns the list of values in this dictionary. */
+  values(): Array<unknown>;
+
+  // Operator overloads
+  [__ops_ne]: { right: Dictionary; ret: boolean };
+  [__ops_eq]: { right: Dictionary; ret: boolean };
+
+  [__variant_converts]: Dictionary;
+}
+
+/**
+ * Override: Dictionary<K, V> — typed key/value dictionary.
+ *
+ * Extends the non-generic Object interface (which provides Dictionary methods
+ * for {} literals) with generic overloads for typed dictionaries:
+ *   var scores: Dictionary<string, int> = Dictionary();
+ *   scores.set("player", 100);    // OK — key is string, value is int
+ *   scores.get("player");         // returns int
+ *   scores.keys();                // returns Array<string>
+ */
+interface Dictionary<K = unknown, V = unknown> extends Object {
+  assign(dictionary: Dictionary<K, V>): void;
+  duplicate(deep?: boolean): Dictionary<K, V>;
+  duplicate_deep(deep_subresources_mode?: int): Dictionary<K, V>;
+  erase(key: K): boolean;
+  find_key(value: V): K | null;
+  get(key: K, default_?: V): V;
+  get_or_add(key: K, default_?: V): V;
+  has(key: K): boolean;
+  has_all(keys: Array<K>): boolean;
+  keys(): Array<K>;
+  merge(dictionary: Dictionary<K, V>, overwrite?: boolean): void;
+  merged(dictionary: Dictionary<K, V>, overwrite?: boolean): Dictionary<K, V>;
+  set(key: K, value: V): boolean;
+  values(): Array<V>;
+}
+declare interface DictionaryConstructor {
+  readonly prototype: Dictionary;
+  /** Constructs an empty {@link Dictionary}. */
+  (): Dictionary;
+  /**
+   * Creates a typed dictionary from the `base` dictionary. A typed dictionary can only contain keys and values of the given types, or that inherit from the given classes, as described by this constructor's parameters.
+   */
+  (base: Dictionary, key_type: int, key_class_name: string, key_script: unknown, value_type: int, value_class_name: string, value_script: unknown): Dictionary;
+  /** Returns the same dictionary as `from`. If you need a copy of the dictionary, use {@link duplicate}. */
+  (from_: Dictionary): Dictionary;
+}
+declare const Dictionary: DictionaryConstructor;
+declare var Object: typeof GodotObject;