typescript-to-gdscript 0.1.0

package/typings/classes/MissingNode.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An internal editor class intended for keeping the data of unrecognized nodes. */
+declare class MissingNode extends Node {
+  /** The name of the class this node was supposed to be (see {@link Object.get_class}). */
+  original_class: string;
+  /** Returns the path of the scene this node was instance of originally. */
+  original_scene: string;
+  /**
+   * If `true`, allows new properties to be set along with existing ones. If `false`, only existing properties' values can be set, and new properties cannot be added.
+   */
+  recording_properties: boolean;
+  /**
+   * If `true`, allows new signals to be connected to along with existing ones. If `false`, only existing signals can be connected to, and new signals cannot be added.
+   */
+  recording_signals: boolean;
+  set_original_class(value: string | NodePath): void;
+  get_original_class(): string;
+  set_original_scene(value: string | NodePath): void;
+  get_original_scene(): string;
+  set_recording_properties(value: boolean): void;
+  is_recording_properties(): boolean;
+  set_recording_signals(value: boolean): void;
+  is_recording_signals(): boolean;
+}

package/typings/classes/MissingResource.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An internal editor class intended for keeping the data of unrecognized resources. */
+declare class MissingResource extends Resource {
+  /** The name of the class this resource was supposed to be (see {@link Object.get_class}). */
+  original_class: string;
+  /**
+   * If set to `true`, allows new properties to be added on top of the existing ones with {@link Object.set}.
+   */
+  recording_properties: boolean;
+  set_original_class(value: string | NodePath): void;
+  get_original_class(): string;
+  set_recording_properties(value: boolean): void;
+  is_recording_properties(): boolean;
+}

package/typings/classes/ModifierBoneTarget3D.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** А node that dynamically copies the 3D transform of a bone in its parent {@link Skeleton3D}. */
+declare class ModifierBoneTarget3D extends SkeletonModifier3D {
+  /** The index of the attached bone. */
+  bone: int;
+  /** The name of the attached bone. */
+  bone_name: string;
+  set_bone(value: int): void;
+  get_bone(): int;
+  set_bone_name(value: string | NodePath): void;
+  get_bone_name(): string;
+}

package/typings/classes/MovieWriter.d.ts

@@ -0,0 +1,36 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract class for non-real-time video recording encoders. */
+declare class MovieWriter extends GodotObject {
+  /**
+   * Called when the audio sample rate used for recording the audio is requested by the engine. The value returned must be specified in Hz. Defaults to 48000 Hz if {@link _get_audio_mix_rate} is not overridden.
+   */
+  _get_audio_mix_rate(): int;
+  /**
+   * Called when the audio speaker mode used for recording the audio is requested by the engine. This can affect the number of output channels in the resulting audio file/stream. Defaults to {@link AudioServer.SPEAKER_MODE_STEREO} if {@link _get_audio_speaker_mode} is not overridden.
+   */
+  _get_audio_speaker_mode(): int;
+  /**
+   * Called when the engine determines whether this {@link MovieWriter} is able to handle the file at `path`. Must return `true` if this {@link MovieWriter} is able to handle the given file path, `false` otherwise. Typically, {@link _handles_file} is overridden as follows to allow the user to record a file at any path with a given file extension:
+   */
+  _handles_file(path: string | NodePath): boolean;
+  /**
+   * Called once before the engine starts writing video and audio data. `movie_size` is the width and height of the video to save. `fps` is the number of frames per second specified in the project settings or using the `--fixed-fps <fps>` command line argument ($DOCS_URL/tutorials/editor/command_line_tutorial.html).
+   */
+  _write_begin(movie_size: Vector2i | Vector2, fps: int, base_path: string | NodePath): int;
+  /**
+   * Called when the engine finishes writing. This occurs when the engine quits by pressing the window manager's close button, or when {@link SceneTree.quit} is called.
+   * **Note:** Pressing `Ctrl + C` on the terminal running the editor/project does *not* result in {@link _write_end} being called.
+   */
+  _write_end(): void;
+  /**
+   * Called at the end of every rendered frame. The `frame_image` and `audio_frame_block` function arguments should be written to.
+   */
+  _write_frame(frame_image: Image, audio_frame_block: void): int;
+  /**
+   * Adds a writer to be usable by the engine. The supported file extensions can be set by overriding {@link _handles_file}.
+   * **Note:** {@link add_writer} must be called early enough in the engine initialization to work, as movie writing is designed to start at the same time as the rest of the engine.
+   */
+  static add_writer(writer: MovieWriter): void;
+}

package/typings/classes/MultiMesh.d.ts

@@ -0,0 +1,138 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides high-performance drawing of a mesh multiple times using GPU instancing. */
+declare class MultiMesh extends Resource {
+  buffer: PackedFloat32Array;
+  /** Array containing each {@link Color} used by all instances of this mesh. */
+  color_array: PackedColorArray;
+  /**
+   * Custom AABB for this MultiMesh resource. Setting this manually prevents costly runtime AABB recalculations.
+   */
+  custom_aabb: AABB;
+  /**
+   * Array containing each custom data value used by all instances of this mesh, as a {@link PackedColorArray}.
+   */
+  custom_data_array: PackedColorArray;
+  /**
+   * Number of instances that will get drawn. This clears and (re)sizes the buffers. Setting data format or flags afterwards will have no effect.
+   * By default, all instances are drawn but you can limit this with {@link visible_instance_count}.
+   */
+  instance_count: int;
+  /**
+   * {@link Mesh} resource to be instanced.
+   * The looks of the individual instances can be modified using {@link set_instance_color} and {@link set_instance_custom_data}.
+   */
+  mesh: Mesh | null;
+  /**
+   * Choose whether to use an interpolation method that favors speed or quality.
+   * When using low physics tick rates (typically below 20) or high rates of object rotation, you may get better results from the high quality setting.
+   * **Note:** Fast quality does not equate to low quality. Except in the special cases mentioned above, the quality should be comparable to high quality.
+   */
+  physics_interpolation_quality: int;
+  /**
+   * Array containing each {@link Transform2D} value used by all instances of this mesh, as a {@link PackedVector2Array}. Each transform is divided into 3 {@link Vector2} values corresponding to the transforms' `x`, `y`, and `origin`.
+   */
+  transform_2d_array: PackedVector2Array;
+  /**
+   * Array containing each {@link Transform3D} value used by all instances of this mesh, as a {@link PackedVector3Array}. Each transform is divided into 4 {@link Vector3} values corresponding to the transforms' `x`, `y`, `z`, and `origin`.
+   */
+  transform_array: PackedVector3Array;
+  /** Format of transform used to transform mesh, either 2D or 3D. */
+  transform_format: int;
+  /**
+   * If `true`, the {@link MultiMesh} will use color data (see {@link set_instance_color}). Can only be set when {@link instance_count} is `0` or less. This means that you need to call this method before setting the instance count, or temporarily reset it to `0`.
+   */
+  use_colors: boolean;
+  /**
+   * If `true`, the {@link MultiMesh} will use custom data (see {@link set_instance_custom_data}). Can only be set when {@link instance_count} is `0` or less. This means that you need to call this method before setting the instance count, or temporarily reset it to `0`.
+   */
+  use_custom_data: boolean;
+  /**
+   * Limits the number of instances drawn, -1 draws all instances. Changing this does not change the sizes of the buffers.
+   */
+  visible_instance_count: int;
+  set_buffer(value: PackedFloat32Array | Array<unknown>): void;
+  get_buffer(): PackedFloat32Array;
+  _set_color_array(value: PackedColorArray | Array<unknown>): void;
+  _get_color_array(): PackedColorArray;
+  set_custom_aabb(value: AABB): void;
+  get_custom_aabb(): AABB;
+  _set_custom_data_array(value: PackedColorArray | Array<unknown>): void;
+  _get_custom_data_array(): PackedColorArray;
+  set_instance_count(value: int): void;
+  get_instance_count(): int;
+  set_mesh(value: Mesh | null): void;
+  get_mesh(): Mesh | null;
+  set_physics_interpolation_quality(value: int): void;
+  get_physics_interpolation_quality(): int;
+  _set_transform_2d_array(value: PackedVector2Array | Array<unknown>): void;
+  _get_transform_2d_array(): PackedVector2Array;
+  _set_transform_array(value: PackedVector3Array | Array<unknown>): void;
+  _get_transform_array(): PackedVector3Array;
+  set_transform_format(value: int): void;
+  get_transform_format(): int;
+  set_use_colors(value: boolean): void;
+  is_using_colors(): boolean;
+  set_use_custom_data(value: boolean): void;
+  is_using_custom_data(): boolean;
+  set_visible_instance_count(value: int): void;
+  get_visible_instance_count(): int;
+
+  /** Returns the visibility axis-aligned bounding box in local space. */
+  get_aabb(): AABB;
+  /** Gets a specific instance's color multiplier. */
+  get_instance_color(instance: int): Color;
+  /** Returns the custom data that has been set for a specific instance. */
+  get_instance_custom_data(instance: int): Color;
+  /** Returns the {@link Transform3D} of a specific instance. */
+  get_instance_transform(instance: int): Transform3D;
+  /** Returns the {@link Transform2D} of a specific instance. */
+  get_instance_transform_2d(instance: int): Transform2D;
+  /**
+   * When using *physics interpolation*, this function allows you to prevent interpolation on an instance in the current physics tick.
+   * This allows you to move instances instantaneously, and should usually be used when initially placing an instance such as a bullet to prevent graphical glitches.
+   */
+  reset_instance_physics_interpolation(instance: int): void;
+  /**
+   * When using *physics interpolation*, this function allows you to prevent interpolation for all instances in the current physics tick.
+   * This allows you to move all instances instantaneously, and should usually be used when initially placing instances to prevent graphical glitches.
+   */
+  reset_instances_physics_interpolation(): void;
+  /**
+   * An alternative to setting the {@link buffer} property, which can be used with *physics interpolation*. This method takes two arrays, and can set the data for the current and previous tick in one go. The renderer will automatically interpolate the data at each frame.
+   * This is useful for situations where the order of instances may change from physics tick to tick, such as particle systems.
+   * When the order of instances is coherent, the simpler alternative of setting {@link buffer} can still be used with interpolation.
+   */
+  set_buffer_interpolated(buffer_curr: PackedFloat32Array | Array<unknown>, buffer_prev: PackedFloat32Array | Array<unknown>): void;
+  /**
+   * Sets the color of a specific instance by *multiplying* the mesh's existing vertex colors. This allows for different color tinting per instance.
+   * **Note:** Each component is stored in 32 bits in the Forward+ and Mobile rendering methods, but is packed into 16 bits in the Compatibility rendering method.
+   * For the color to take effect, ensure that {@link use_colors} is `true` on the {@link MultiMesh} and {@link BaseMaterial3D.vertex_color_use_as_albedo} is `true` on the material. If you intend to set an absolute color instead of tinting, make sure the material's albedo color is set to pure white (`Color(1, 1, 1)`).
+   */
+  set_instance_color(instance: int, color: Color): void;
+  /**
+   * Sets custom data for a specific instance. `custom_data` is a {@link Color} type only to contain 4 floating-point numbers.
+   * **Note:** Each number is stored in 32 bits in the Forward+ and Mobile rendering methods, but is packed into 16 bits in the Compatibility rendering method.
+   * For the custom data to be used, ensure that {@link use_custom_data} is `true`.
+   * This custom instance data has to be manually accessed in your custom shader using `INSTANCE_CUSTOM`.
+   */
+  set_instance_custom_data(instance: int, custom_data: Color): void;
+  /** Sets the {@link Transform3D} for a specific instance. */
+  set_instance_transform(instance: int, transform: Transform3D | Projection): void;
+  /** Sets the {@link Transform2D} for a specific instance. */
+  set_instance_transform_2d(instance: int, transform: Transform2D): void;
+
+  // enum TransformFormat
+  /** Use this when using 2D transforms. */
+  static readonly TRANSFORM_2D: int;
+  /** Use this when using 3D transforms. */
+  static readonly TRANSFORM_3D: int;
+  // enum PhysicsInterpolationQuality
+  /** Always interpolate using Basis lerping, which can produce warping artifacts in some situations. */
+  static readonly INTERP_QUALITY_FAST: int;
+  /**
+   * Attempt to interpolate using Basis slerping (spherical linear interpolation) where possible, otherwise fall back to lerping.
+   */
+  static readonly INTERP_QUALITY_HIGH: int;
+}

package/typings/classes/MultiMeshInstance2D.d.ts

@@ -0,0 +1,19 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Node that instances a {@link MultiMesh} in 2D. */
+declare class MultiMeshInstance2D extends Node2D {
+  /** The {@link MultiMesh} that will be drawn by the {@link MultiMeshInstance2D}. */
+  multimesh: MultiMesh | null;
+  /**
+   * The {@link Texture2D} that will be used if using the default {@link CanvasItemMaterial}. Can be accessed as `TEXTURE` in CanvasItem shader.
+   */
+  texture: Texture2D | null;
+  set_multimesh(value: MultiMesh | null): void;
+  get_multimesh(): MultiMesh | null;
+  set_texture(value: Texture2D | null): void;
+  get_texture(): Texture2D | null;
+
+  /** Emitted when the {@link texture} is changed. */
+  texture_changed: Signal<[]>;
+}

package/typings/classes/MultiMeshInstance3D.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Node that instances a {@link MultiMesh}. */
+declare class MultiMeshInstance3D extends GeometryInstance3D {
+  /**
+   * The {@link MultiMesh} resource that will be used and shared among all instances of the {@link MultiMeshInstance3D}.
+   */
+  multimesh: MultiMesh | null;
+  set_multimesh(value: MultiMesh | null): void;
+  get_multimesh(): MultiMesh | null;
+}

package/typings/classes/MultiplayerAPI.d.ts

@@ -0,0 +1,93 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** High-level multiplayer API interface. */
+declare class MultiplayerAPI extends RefCounted {
+  /**
+   * The peer object to handle the RPC system (effectively enabling networking when set). Depending on the peer itself, the MultiplayerAPI will become a network server (check with {@link is_server}) and will set root node's network mode to authority, or it will become a regular client peer. All child nodes are set to inherit the network mode by default. Handling of networking-related events (connection, disconnection, new clients) is done by connecting to MultiplayerAPI's signals.
+   */
+  multiplayer_peer: MultiplayerPeer | null;
+  set_multiplayer_peer(value: MultiplayerPeer | null): void;
+  get_multiplayer_peer(): MultiplayerPeer | null;
+
+  /** Returns a new instance of the default MultiplayerAPI. */
+  static create_default_interface(): MultiplayerAPI | null;
+  /**
+   * Returns the default MultiplayerAPI implementation class name. This is usually `"SceneMultiplayer"` when {@link SceneMultiplayer} is available. See {@link set_default_interface}.
+   */
+  static get_default_interface(): string;
+  /** Returns the peer IDs of all connected peers of this MultiplayerAPI's {@link multiplayer_peer}. */
+  get_peers(): PackedInt32Array;
+  /**
+   * Returns the sender's peer ID for the RPC currently being executed.
+   * **Note:** This method returns `0` when called outside of an RPC. As such, the original peer ID may be lost when code execution is delayed (such as with GDScript's `await` keyword).
+   */
+  get_remote_sender_id(): int;
+  /** Returns the unique peer ID of this MultiplayerAPI's {@link multiplayer_peer}. */
+  get_unique_id(): int;
+  /** Returns `true` if there is a {@link multiplayer_peer} set. */
+  has_multiplayer_peer(): boolean;
+  /**
+   * Returns `true` if this MultiplayerAPI's {@link multiplayer_peer} is valid and in server mode (listening for connections).
+   */
+  is_server(): boolean;
+  /**
+   * Notifies the MultiplayerAPI of a new `configuration` for the given `object`. This method is used internally by {@link SceneTree} to configure the root path for this MultiplayerAPI (passing `null` and a valid {@link NodePath} as `configuration`). This method can be further used by MultiplayerAPI implementations to provide additional features, refer to specific implementation (e.g. {@link SceneMultiplayer}) for details on how they use it.
+   * **Note:** This method is mostly relevant when extending or overriding the MultiplayerAPI behavior via {@link MultiplayerAPIExtension}.
+   */
+  object_configuration_add(object: GodotObject, configuration: unknown): int;
+  /**
+   * Notifies the MultiplayerAPI to remove a `configuration` for the given `object`. This method is used internally by {@link SceneTree} to configure the root path for this MultiplayerAPI (passing `null` and an empty {@link NodePath} as `configuration`). This method can be further used by MultiplayerAPI implementations to provide additional features, refer to specific implementation (e.g. {@link SceneMultiplayer}) for details on how they use it.
+   * **Note:** This method is mostly relevant when extending or overriding the MultiplayerAPI behavior via {@link MultiplayerAPIExtension}.
+   */
+  object_configuration_remove(object: GodotObject, configuration: unknown): int;
+  /**
+   * Method used for polling the MultiplayerAPI. You only need to worry about this if you set {@link SceneTree.multiplayer_poll} to `false`. By default, {@link SceneTree} will poll its MultiplayerAPI(s) for you.
+   * **Note:** This method results in RPCs being called, so they will be executed in the same context of this function (e.g. `_process`, `physics`, {@link Thread}).
+   */
+  poll(): int;
+  /**
+   * Sends an RPC to the target `peer`. The given `method` will be called on the remote `object` with the provided `arguments`. The RPC may also be called locally depending on the implementation and RPC configuration. See {@link Node.rpc} and {@link Node.rpc_config}.
+   * **Note:** Prefer using {@link Node.rpc}, {@link Node.rpc_id}, or `my_method.rpc(peer, arg1, arg2, ...)` (in GDScript), since they are faster. This method is mostly useful in conjunction with {@link MultiplayerAPIExtension} when extending or replacing the multiplayer capabilities.
+   */
+  rpc(peer: int, object: GodotObject, method: string, arguments?: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): int;
+  /**
+   * Sets the default MultiplayerAPI implementation class. This method can be used by modules and extensions to configure which implementation will be used by {@link SceneTree} when the engine starts.
+   */
+  static set_default_interface(interface_name: string): void;
+
+  /**
+   * Emitted when this MultiplayerAPI's {@link multiplayer_peer} successfully connected to a server. Only emitted on clients.
+   */
+  connected_to_server: Signal<[]>;
+  /**
+   * Emitted when this MultiplayerAPI's {@link multiplayer_peer} fails to establish a connection to a server. Only emitted on clients.
+   */
+  connection_failed: Signal<[]>;
+  /**
+   * Emitted when this MultiplayerAPI's {@link multiplayer_peer} connects with a new peer. ID is the peer ID of the new peer. Clients get notified when other clients connect to the same server. Upon connecting to a server, a client also receives this signal for the server (with ID being 1).
+   */
+  peer_connected: Signal<[int]>;
+  /**
+   * Emitted when this MultiplayerAPI's {@link multiplayer_peer} disconnects from a peer. Clients get notified when other clients disconnect from the same server.
+   */
+  peer_disconnected: Signal<[int]>;
+  /**
+   * Emitted when this MultiplayerAPI's {@link multiplayer_peer} disconnects from server. Only emitted on clients.
+   */
+  server_disconnected: Signal<[]>;
+
+  // enum RPCMode
+  /**
+   * Used with {@link Node.rpc_config} to disable a method or property for all RPC calls, making it unavailable. Default for all methods.
+   */
+  static readonly RPC_MODE_DISABLED: int;
+  /**
+   * Used with {@link Node.rpc_config} to set a method to be callable remotely by any peer. Analogous to the `@rpc("any_peer")` annotation. Calls are accepted from all remote peers, no matter if they are node's authority or not.
+   */
+  static readonly RPC_MODE_ANY_PEER: int;
+  /**
+   * Used with {@link Node.rpc_config} to set a method to be callable remotely only by the current multiplayer authority (which is the server by default). Analogous to the `@rpc("authority")` annotation. See {@link Node.set_multiplayer_authority}.
+   */
+  static readonly RPC_MODE_AUTHORITY: int;
+}

package/typings/classes/MultiplayerAPIExtension.d.ts

@@ -0,0 +1,24 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class used for extending the {@link MultiplayerAPI}. */
+declare class MultiplayerAPIExtension extends MultiplayerAPI {
+  /** Called when the {@link MultiplayerAPI.multiplayer_peer} is retrieved. */
+  _get_multiplayer_peer(): MultiplayerPeer | null;
+  /** Callback for {@link MultiplayerAPI.get_peers}. */
+  _get_peer_ids(): PackedInt32Array;
+  /** Callback for {@link MultiplayerAPI.get_remote_sender_id}. */
+  _get_remote_sender_id(): int;
+  /** Callback for {@link MultiplayerAPI.get_unique_id}. */
+  _get_unique_id(): int;
+  /** Callback for {@link MultiplayerAPI.object_configuration_add}. */
+  _object_configuration_add(object: GodotObject, configuration: unknown): int;
+  /** Callback for {@link MultiplayerAPI.object_configuration_remove}. */
+  _object_configuration_remove(object: GodotObject, configuration: unknown): int;
+  /** Callback for {@link MultiplayerAPI.poll}. */
+  _poll(): int;
+  /** Callback for {@link MultiplayerAPI.rpc}. */
+  _rpc(peer: int, object: GodotObject, method: string, args: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): int;
+  /** Called when the {@link MultiplayerAPI.multiplayer_peer} is set. */
+  _set_multiplayer_peer(multiplayer_peer: MultiplayerPeer): void;
+}

package/typings/classes/MultiplayerPeer.d.ts

@@ -0,0 +1,90 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract class for specialized {@link PacketPeer}s used by the {@link MultiplayerAPI}. */
+declare class MultiplayerPeer extends PacketPeer {
+  /** If `true`, this {@link MultiplayerPeer} refuses new connections. */
+  refuse_new_connections: boolean;
+  /**
+   * The channel to use to send packets. Many network APIs such as ENet and WebRTC allow the creation of multiple independent channels which behaves, in a way, like separate connections. This means that reliable data will only block delivery of other packets on that channel, and ordering will only be in respect to the channel the packet is being sent on. Using different channels to send **different and independent** state updates is a common way to optimize network usage and decrease latency in fast-paced games.
+   * **Note:** The default channel (`0`) actually works as 3 separate channels (one for each {@link TransferMode}) so that {@link TRANSFER_MODE_RELIABLE} and {@link TRANSFER_MODE_UNRELIABLE_ORDERED} does not interact with each other by default. Refer to the specific network API documentation (e.g. ENet or WebRTC) to learn how to set up channels correctly.
+   */
+  transfer_channel: int;
+  /** The manner in which to send packets to the target peer. See the {@link set_target_peer} method. */
+  transfer_mode: int;
+  set_refuse_new_connections(value: boolean): void;
+  is_refusing_new_connections(): boolean;
+  set_transfer_channel(value: int): void;
+  get_transfer_channel(): int;
+  set_transfer_mode(value: int): void;
+  get_transfer_mode(): int;
+
+  /**
+   * Immediately close the multiplayer peer returning to the state {@link CONNECTION_DISCONNECTED}. Connected peers will be dropped without emitting {@link peer_disconnected}.
+   */
+  close(): void;
+  /**
+   * Disconnects the given `peer` from this host. If `force` is `true` the {@link peer_disconnected} signal will not be emitted for this peer.
+   */
+  disconnect_peer(peer: int, force?: boolean): void;
+  /** Returns a randomly generated integer that can be used as a network unique ID. */
+  generate_unique_id(): int;
+  /** Returns the current state of the connection. */
+  get_connection_status(): int;
+  /**
+   * Returns the channel over which the next available packet was received. See {@link PacketPeer.get_available_packet_count}.
+   */
+  get_packet_channel(): int;
+  /**
+   * Returns the transfer mode the remote peer used to send the next available packet. See {@link PacketPeer.get_available_packet_count}.
+   */
+  get_packet_mode(): int;
+  /**
+   * Returns the ID of the {@link MultiplayerPeer} who sent the next available packet. See {@link PacketPeer.get_available_packet_count}.
+   */
+  get_packet_peer(): int;
+  /** Returns the ID of this {@link MultiplayerPeer}. */
+  get_unique_id(): int;
+  /**
+   * Returns `true` if the server can act as a relay in the current configuration. That is, if the higher level {@link MultiplayerAPI} should notify connected clients of other peers, and implement a relay protocol to allow communication between them.
+   */
+  is_server_relay_supported(): boolean;
+  /** Waits up to 1 second to receive a new network event. */
+  poll(): void;
+  /**
+   * Sets the peer to which packets will be sent.
+   * The `id` can be one of: {@link TARGET_PEER_BROADCAST} to send to all connected peers, {@link TARGET_PEER_SERVER} to send to the peer acting as server, a valid peer ID to send to that specific peer, a negative peer ID to send to all peers except that one. By default, the target peer is {@link TARGET_PEER_BROADCAST}.
+   */
+  set_target_peer(id: int): void;
+
+  /** Emitted when a remote peer connects. */
+  peer_connected: Signal<[int]>;
+  /** Emitted when a remote peer has disconnected. */
+  peer_disconnected: Signal<[int]>;
+
+  // enum ConnectionStatus
+  /** The MultiplayerPeer is disconnected. */
+  static readonly CONNECTION_DISCONNECTED: int;
+  /** The MultiplayerPeer is currently connecting to a server. */
+  static readonly CONNECTION_CONNECTING: int;
+  /** This MultiplayerPeer is connected. */
+  static readonly CONNECTION_CONNECTED: int;
+  // enum TransferMode
+  /**
+   * Packets are not acknowledged, no resend attempts are made for lost packets. Packets may arrive in any order. Potentially faster than {@link TRANSFER_MODE_UNRELIABLE_ORDERED}. Use for non-critical data, and always consider whether the order matters.
+   */
+  static readonly TRANSFER_MODE_UNRELIABLE: int;
+  /**
+   * Packets are not acknowledged, no resend attempts are made for lost packets. Packets are received in the order they were sent in. Potentially faster than {@link TRANSFER_MODE_RELIABLE}. Use for non-critical data or data that would be outdated if received late due to resend attempt(s) anyway, for example movement and positional data.
+   */
+  static readonly TRANSFER_MODE_UNRELIABLE_ORDERED: int;
+  /**
+   * Packets must be received and resend attempts should be made until the packets are acknowledged. Packets must be received in the order they were sent in. Most reliable transfer mode, but potentially the slowest due to the overhead. Use for critical data that must be transmitted and arrive in order, for example an ability being triggered or a chat message. Consider carefully if the information really is critical, and use sparingly.
+   */
+  static readonly TRANSFER_MODE_RELIABLE: int;
+
+  /** Packets are sent to all connected peers. */
+  static readonly TARGET_PEER_BROADCAST: int;
+  /** Packets are sent to the remote peer acting as server. */
+  static readonly TARGET_PEER_SERVER: int;
+}

package/typings/classes/MultiplayerPeerExtension.d.ts

@@ -0,0 +1,90 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Class that can be inherited to implement custom multiplayer API networking layers via GDExtension. */
+declare class MultiplayerPeerExtension extends MultiplayerPeer {
+  /** Called when the multiplayer peer should be immediately closed (see {@link MultiplayerPeer.close}). */
+  _close(): void;
+  /**
+   * Called when the connected `p_peer` should be forcibly disconnected (see {@link MultiplayerPeer.disconnect_peer}).
+   */
+  _disconnect_peer(p_peer: int, p_force: boolean): void;
+  /** Called when the available packet count is internally requested by the {@link MultiplayerAPI}. */
+  _get_available_packet_count(): int;
+  /**
+   * Called when the connection status is requested on the {@link MultiplayerPeer} (see {@link MultiplayerPeer.get_connection_status}).
+   */
+  _get_connection_status(): int;
+  /** Called when the maximum allowed packet size (in bytes) is requested by the {@link MultiplayerAPI}. */
+  _get_max_packet_size(): int;
+  /**
+   * Called when a packet needs to be received by the {@link MultiplayerAPI}, with `r_buffer_size` being the size of the binary `r_buffer` in bytes.
+   */
+  _get_packet(r_buffer: int, r_buffer_size: int): int;
+  /**
+   * Called to get the channel over which the next available packet was received. See {@link MultiplayerPeer.get_packet_channel}.
+   */
+  _get_packet_channel(): int;
+  /**
+   * Called to get the transfer mode the remote peer used to send the next available packet. See {@link MultiplayerPeer.get_packet_mode}.
+   */
+  _get_packet_mode(): int;
+  /**
+   * Called when the ID of the {@link MultiplayerPeer} who sent the most recent packet is requested (see {@link MultiplayerPeer.get_packet_peer}).
+   */
+  _get_packet_peer(): int;
+  /**
+   * Called when a packet needs to be received by the {@link MultiplayerAPI}, if {@link _get_packet} isn't implemented. Use this when extending this class via GDScript.
+   */
+  _get_packet_script(): PackedByteArray;
+  /**
+   * Called when the transfer channel to use is read on this {@link MultiplayerPeer} (see {@link MultiplayerPeer.transfer_channel}).
+   */
+  _get_transfer_channel(): int;
+  /**
+   * Called when the transfer mode to use is read on this {@link MultiplayerPeer} (see {@link MultiplayerPeer.transfer_mode}).
+   */
+  _get_transfer_mode(): int;
+  /**
+   * Called when the unique ID of this {@link MultiplayerPeer} is requested (see {@link MultiplayerPeer.get_unique_id}). The value must be between `1` and `2147483647`.
+   */
+  _get_unique_id(): int;
+  /**
+   * Called when the "refuse new connections" status is requested on this {@link MultiplayerPeer} (see {@link MultiplayerPeer.refuse_new_connections}).
+   */
+  _is_refusing_new_connections(): boolean;
+  /**
+   * Called when the "is server" status is requested on the {@link MultiplayerAPI}. See {@link MultiplayerAPI.is_server}.
+   */
+  _is_server(): boolean;
+  /**
+   * Called to check if the server can act as a relay in the current configuration. See {@link MultiplayerPeer.is_server_relay_supported}.
+   */
+  _is_server_relay_supported(): boolean;
+  /** Called when the {@link MultiplayerAPI} is polled. See {@link MultiplayerAPI.poll}. */
+  _poll(): void;
+  /**
+   * Called when a packet needs to be sent by the {@link MultiplayerAPI}, with `p_buffer_size` being the size of the binary `p_buffer` in bytes.
+   */
+  _put_packet(p_buffer: int, p_buffer_size: int): int;
+  /**
+   * Called when a packet needs to be sent by the {@link MultiplayerAPI}, if {@link _put_packet} isn't implemented. Use this when extending this class via GDScript.
+   */
+  _put_packet_script(p_buffer: PackedByteArray | Array<unknown>): int;
+  /**
+   * Called when the "refuse new connections" status is set on this {@link MultiplayerPeer} (see {@link MultiplayerPeer.refuse_new_connections}).
+   */
+  _set_refuse_new_connections(p_enable: boolean): void;
+  /**
+   * Called when the target peer to use is set for this {@link MultiplayerPeer} (see {@link MultiplayerPeer.set_target_peer}).
+   */
+  _set_target_peer(p_peer: int): void;
+  /**
+   * Called when the channel to use is set for this {@link MultiplayerPeer} (see {@link MultiplayerPeer.transfer_channel}).
+   */
+  _set_transfer_channel(p_channel: int): void;
+  /**
+   * Called when the transfer mode is set on this {@link MultiplayerPeer} (see {@link MultiplayerPeer.transfer_mode}).
+   */
+  _set_transfer_mode(p_mode: int): void;
+}

package/typings/classes/Mutex.d.ts

@@ -0,0 +1,22 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A binary {@link Semaphore} for synchronization of multiple {@link Thread}s. */
+declare class Mutex extends RefCounted {
+  /**
+   * Locks this {@link Mutex}, blocks until it is unlocked by the current owner.
+   * **Note:** This function returns without blocking if the thread already has ownership of the mutex.
+   */
+  lock(): void;
+  /**
+   * Tries locking this {@link Mutex}, but does not block. Returns `true` on success, `false` otherwise.
+   * **Note:** This function returns `true` if the thread already has ownership of the mutex.
+   */
+  try_lock(): boolean;
+  /**
+   * Unlocks this {@link Mutex}, leaving it to other threads.
+   * **Note:** If a thread called {@link lock} or {@link try_lock} multiple times while already having ownership of the mutex, it must also call {@link unlock} the same number of times in order to unlock it correctly.
+   * **Warning:** Calling {@link unlock} more times than {@link lock} on a given thread, thus ending up trying to unlock a non-locked mutex, is wrong and may causes crashes or deadlocks.
+   */
+  unlock(): void;
+}