@ringozz/godot 0.1.0

package/gen/classes/MissingResource.ts

@@ -0,0 +1,27 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+
+/**
+ * This is an internal editor class intended for keeping data of resources of unknown type (most likely this type was supplied by an extension that is no longer loaded). It can't be manually instantiated or placed in a scene.
+ * **Warning:** Ignore missing resources unless you know what you are doing. Existing properties on a missing resource can be freely modified in code, regardless of the type they are intended to be.
+ */
+export class MissingResource extends Resource {
+    constructor(name = 419) { super(name); }
+
+    /**
+     * The name of the class this resource was supposed to be (see {@link Object.getClass}).
+     */
+    get originalClass(): string { return _C(this, 5746) as string; }
+    set originalClass(v: string) { _C(this, 12207, v); }
+
+    /**
+     * If set to `true`, allows new properties to be added on top of the existing ones with {@link Object.set}.
+     */
+    get recordingProperties(): boolean { return _C(this, 8230) as boolean; }
+    set recordingProperties(v: boolean) { _C(this, 12486, v); }
+
+    static readonly name = _R(419, MissingResource);
+}

package/gen/classes/MobileVRInterface.ts

@@ -0,0 +1,89 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { XRInterface } from './XRInterface.ts';
+import type { Rect2 } from '../value-types/index.ts';
+
+/**
+ * This is a generic mobile VR implementation where you need to provide details about the phone and HMD used. It does not rely on any existing framework. This is the most basic interface we have. For the best effect, you need a mobile phone with a gyroscope and accelerometer.
+ * Note that even though there is no positional tracking, the camera will assume the headset is at a height of 1.85 meters. You can change this by setting {@link eyeHeight}.
+ * You can initialize this interface as follows:
+ *
+ * ```text
+ *
+ * var interface = XRServer.find_interface("Native mobile")
+ * if interface and interface.initialize():
+ * 	get_viewport().use_xr = true
+ *
+ * ```
+ *
+ * **Note:** For Android, {@link ProjectSettings.inputDevices/sensors/enableAccelerometer}, {@link ProjectSettings.inputDevices/sensors/enableGravity}, {@link ProjectSettings.inputDevices/sensors/enableGyroscope} and {@link ProjectSettings.inputDevices/sensors/enableMagnetometer} must be enabled.
+ */
+export class MobileVRInterface extends XRInterface {
+    constructor(name = 420) { super(name); }
+
+    /**
+     * The height at which the camera is placed in relation to the ground (i.e. {@link XROrigin3D} node).
+     */
+    get eyeHeight(): number { return _C(this, 4722) as number; }
+    set eyeHeight(v: number) { _C(this, 11342, v); }
+
+    /**
+     * The interocular distance, also known as the interpupillary distance. The distance between the pupils of the left and right eye.
+     */
+    get iod(): number { return _C(this, 5168) as number; }
+    set iod(v: number) { _C(this, 11751, v); }
+
+    /**
+     * The width of the display in centimeters.
+     */
+    get displayWidth(): number { return _C(this, 4522) as number; }
+    set displayWidth(v: number) { _C(this, 11132, v); }
+
+    /**
+     * The distance between the display and the lenses inside of the device in centimeters.
+     */
+    get displayToLens(): number { return _C(this, 4521) as number; }
+    set displayToLens(v: number) { _C(this, 11131, v); }
+
+    /**
+     * Set the offset rect relative to the area being rendered. A length of 1 represents the whole rendering area on that axis.
+     */
+    get offsetRect(): Rect2 { return _C(this, 5705) as Rect2; }
+    set offsetRect(v: Rect2) { _C(this, 12171, v); }
+
+    /**
+     * The oversample setting. Because of the lens distortion we have to render our buffers at a higher resolution then the screen can natively handle. A value between 1.5 and 2.0 often provides good results but at the cost of performance.
+     */
+    get oversample(): number { return _C(this, 5777) as number; }
+    set oversample(v: number) { _C(this, 12228, v); }
+
+    /**
+     * The k1 lens factor is one of the two constants that define the strength of the lens used and directly influences the lens distortion effect.
+     */
+    get k1(): number { return _C(this, 5280) as number; }
+    set k1(v: number) { _C(this, 11854, v); }
+
+    /**
+     * The k2 lens factor, see k1.
+     */
+    get k2(): number { return _C(this, 5281) as number; }
+    set k2(v: number) { _C(this, 11855, v); }
+
+    /**
+     * The minimum radius around the focal point where full quality is guaranteed if VRS is used as a percentage of screen size.
+     * **Note:** Mobile and Forward+ renderers only. Requires {@link Viewport.vrsMode} to be set to {@link Viewport.VRS_XR}.
+     */
+    get vrsMinRadius(): number { return _C(this, 7134) as number; }
+    set vrsMinRadius(v: number) { _C(this, 13359, v); }
+
+    /**
+     * The strength used to calculate the VRS density map. The greater this value, the more noticeable VRS is. This improves performance at the cost of quality.
+     * **Note:** Mobile and Forward+ renderers only. Requires {@link Viewport.vrsMode} to be set to {@link Viewport.VRS_XR}.
+     */
+    get vrsStrength(): number { return _C(this, 7137) as number; }
+    set vrsStrength(v: number) { _C(this, 13362, v); }
+
+    static readonly name = _R(420, MobileVRInterface);
+}

package/gen/classes/ModifierBoneTarget3D.ts

@@ -0,0 +1,27 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModifier3D } from './SkeletonModifier3D.ts';
+
+/**
+ * This node selects a bone in a {@link Skeleton3D} and attaches to it. This means that the {@link ModifierBoneTarget3D} node will dynamically copy the 3D transform of the selected bone.
+ * The functionality is similar to {@link BoneAttachment3D}, but this node adopts the {@link SkeletonModifier3D} cycle and is intended to be used as another {@link SkeletonModifier3D}'s target.
+ */
+export class ModifierBoneTarget3D extends SkeletonModifier3D {
+    constructor(name = 421) { super(name); }
+
+    /**
+     * The name of the attached bone.
+     */
+    get boneName(): string { return _C(this, 3972) as string; }
+    set boneName(v: string) { _C(this, 10710, v); }
+
+    /**
+     * The index of the attached bone.
+     */
+    get bone(): number { return _C(this, 3953) as number; }
+    set bone(v: number) { _C(this, 10698, v); }
+
+    static readonly name = _R(421, ModifierBoneTarget3D);
+}

package/gen/classes/MovieWriter.ts

@@ -0,0 +1,34 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedStringArray } from '../heap-types/index.ts';
+import type { Vector2i } from '../value-types/index.ts';
+import type { SpeakerMode } from './AudioServer.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * Godot can record videos with non-real-time simulation. Like the `--fixed-fps` [command line argument]($DOCS_URL/tutorials/editor/command_line_tutorial.html), this forces the reported `delta` in {@link Node.Process} functions to be identical across frames, regardless of how long it actually took to render the frame. This can be used to record high-quality videos with perfect frame pacing regardless of your hardware's capabilities.
+ * Godot has 3 built-in {@link MovieWriter}s:
+ * - OGV container with Theora for video and Vorbis for audio (`.ogv` file extension). Lossy compression, medium file sizes, fast encoding. The lossy compression quality can be adjusted by changing {@link ProjectSettings.editor/movieWriter/videoQuality} and {@link ProjectSettings.editor/movieWriter/ogv/audioQuality}. The resulting file can be viewed in Godot with {@link VideoStreamPlayer} and most video players, but not web browsers as they don't support Theora.
+ * - AVI container with MJPEG for video and uncompressed audio (`.avi` file extension). Lossy compression, medium file sizes, fast encoding. The lossy compression quality can be adjusted by changing {@link ProjectSettings.editor/movieWriter/videoQuality}. The resulting file can be viewed in most video players, but it must be converted to another format for viewing on the web or by Godot with {@link VideoStreamPlayer}. MJPEG does not support transparency. AVI output is currently limited to a file of 4 GB in size at most.
+ * - PNG image sequence for video and WAV for audio (`.png` file extension). Lossless compression, large file sizes, slow encoding. Designed to be encoded to a video file with another tool such as [FFmpeg](https://ffmpeg.org/) after recording. Transparency is currently not supported, even if the root viewport is set to be transparent.
+ * If you need to encode to a different format or pipe a stream through third-party software, you can extend the {@link MovieWriter} class to create your own movie writers. This should typically be done using GDExtension for performance reasons.
+ * **Editor usage:** A default movie file path can be specified in {@link ProjectSettings.editor/movieWriter/movieFile}. Alternatively, for running single scenes, a `movie_file` metadata can be added to the root node, specifying the path to a movie file that will be used when recording that scene. Once a path is set, click the video reel icon in the top-right corner of the editor to enable Movie Maker mode, then run any scene as usual. The engine will start recording as soon as the splash screen is finished, and it will only stop recording when the engine quits. Click the video reel icon again to disable Movie Maker mode. Note that toggling Movie Maker mode does not affect project instances that are already running.
+ * **Note:** MovieWriter is available for use in both the editor and exported projects, but it is *not* designed for use by end users to record videos while playing. Players wishing to record gameplay videos should install tools such as [OBS Studio](https://obsproject.com/) or [SimpleScreenRecorder](https://www.maartenbaert.be/simplescreenrecorder/) instead.
+ * **Note:** MJPEG support (`.avi` file extension) depends on the `jpg` module being enabled at compile time (default behavior).
+ * **Note:** OGV support (`.ogv` file extension) depends on the `theora` module being enabled at compile time (default behavior). Theora compression is only available in editor binaries.
+ */
+export class MovieWriter extends Object {
+    constructor(name = 422) { super(name); }
+
+    /**
+     * Adds a writer to be usable by the engine. The supported file extensions can be set by overriding {@link _handlesFile}.
+     * **Note:** {@link addWriter} 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 addWriter(writer: MovieWriter): void { _C(422, 1337, writer); }
+
+    static readonly name = _R(422, MovieWriter);
+}

package/gen/classes/MultiMesh.ts

@@ -0,0 +1,197 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { PackedColorArray, PackedFloat32Array, PackedVector2Array, PackedVector3Array } from '../heap-types/index.ts';
+import type { AABB, Color, Transform2D, Transform3D } from '../value-types/index.ts';
+import type { Mesh } from './Mesh.ts';
+
+/**
+ * MultiMesh provides low-level mesh instancing. Drawing thousands of {@link MeshInstance3D} nodes can be slow, since each object is submitted to the GPU then drawn individually.
+ * MultiMesh is much faster as it can draw thousands of instances with a single draw call, resulting in less API overhead.
+ * As a drawback, if the instances are too far away from each other, performance may be reduced as every single instance will always render (they are spatially indexed as one, for the whole object).
+ * Since instances may have any behavior, the AABB used for visibility must be provided by the user.
+ * **Note:** A MultiMesh is a single object, therefore the same maximum lights per object restriction applies. This means, that once the maximum lights are consumed by one or more instances, the rest of the MultiMesh instances will **not** receive any lighting.
+ * **Note:** Blend Shapes will be ignored if used in a MultiMesh.
+ */
+export class MultiMesh extends Resource {
+    constructor(name = 423) { super(name); }
+
+    /**
+     * Sets the {@link Transform3D} for a specific instance.
+     */
+    setInstanceTransform(instance: number, transform: Transform3D): void { _C(this, 11730, instance, transform); }
+
+    /**
+     * Sets the {@link Transform2D} for a specific instance.
+     */
+    setInstanceTransform2d(instance: number, transform: Transform2D): void { _C(this, 11731, instance, transform); }
+
+    /**
+     * Returns the {@link Transform3D} of a specific instance.
+     */
+    getInstanceTransform(instance: number): Transform3D { return _C(this, 5139, instance) as Transform3D; }
+
+    /**
+     * Returns the {@link Transform2D} of a specific instance.
+     */
+    getInstanceTransform2d(instance: number): Transform2D { return _C(this, 5140, instance) as Transform2D; }
+
+    /**
+     * 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 useColors} is `true` on the {@link MultiMesh} and {@link BaseMaterial3D.vertexColorUseAsAlbedo} 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)`).
+     */
+    setInstanceColor(instance: number, color: Color): void { _C(this, 11724, instance, color); }
+
+    /**
+     * Gets a specific instance's color multiplier.
+     */
+    getInstanceColor(instance: number): Color { return _C(this, 5130, instance) as Color; }
+
+    /**
+     * Sets custom data for a specific instance. `customData` 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 useCustomData} is `true`.
+     * This custom instance data has to be manually accessed in your custom shader using `INSTANCE_CUSTOM`.
+     */
+    setInstanceCustomData(instance: number, customData: Color): void { _C(this, 11726, instance, customData); }
+
+    /**
+     * Returns the custom data that has been set for a specific instance.
+     */
+    getInstanceCustomData(instance: number): Color { return _C(this, 5132, instance) as Color; }
+
+    /**
+     * 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.
+     */
+    resetInstancePhysicsInterpolation(instance: number): void { _C(this, 10068, instance); }
+
+    /**
+     * 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.
+     */
+    resetInstancesPhysicsInterpolation(): void { _C(this, 10069); }
+
+    /**
+     * Returns the visibility axis-aligned bounding box in local space.
+     */
+    getAabb(): AABB { return _C(this, 3659) as AABB; }
+
+    /**
+     * 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.
+     */
+    setBufferInterpolated(bufferCurr: PackedFloat32Array, bufferPrev: PackedFloat32Array): void { _C(this, 10741, bufferCurr, bufferPrev); }
+
+    /**
+     * Format of transform used to transform mesh, either 2D or 3D.
+     */
+    get transformFormat(): TransformFormat { return _C(this, 6879) as TransformFormat; }
+    set transformFormat(v: TransformFormat) { _C(this, 13138, v); }
+
+    /**
+     * If `true`, the {@link MultiMesh} will use color data (see {@link setInstanceColor}). Can only be set when {@link instanceCount} is `0` or less. This means that you need to call this method before setting the instance count, or temporarily reset it to `0`.
+     */
+    get useColors(): boolean { return _C(this, 8396) as boolean; }
+    set useColors(v: boolean) { _C(this, 13202, v); }
+
+    /**
+     * If `true`, the {@link MultiMesh} will use custom data (see {@link setInstanceCustomData}). Can only be set when {@link instanceCount} is `0` or less. This means that you need to call this method before setting the instance count, or temporarily reset it to `0`.
+     */
+    get useCustomData(): boolean { return _C(this, 8398) as boolean; }
+    set useCustomData(v: boolean) { _C(this, 13204, v); }
+
+    /**
+     * Custom AABB for this MultiMesh resource. Setting this manually prevents costly runtime AABB recalculations.
+     */
+    get customAabb(): AABB { return _C(this, 4375) as AABB; }
+    set customAabb(v: AABB) { _C(this, 10999, v); }
+
+    /**
+     * 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 visibleInstanceCount}.
+     */
+    get instanceCount(): number { return _C(this, 5131) as number; }
+    set instanceCount(v: number) { _C(this, 11725, v); }
+
+    /**
+     * Limits the number of instances drawn, -1 draws all instances. Changing this does not change the sizes of the buffers.
+     */
+    get visibleInstanceCount(): number { return _C(this, 7107) as number; }
+    set visibleInstanceCount(v: number) { _C(this, 13334, v); }
+
+    /**
+     * {@link Mesh} resource to be instanced.
+     * The looks of the individual instances can be modified using {@link setInstanceColor} and {@link setInstanceCustomData}.
+     */
+    get mesh(): Mesh { return _C(this, 5511) as Mesh; }
+    set mesh(v: Mesh) { _C(this, 12024, v); }
+
+    get buffer(): PackedFloat32Array { return _C(this, 4003) as PackedFloat32Array; }
+    set buffer(v: PackedFloat32Array) { _C(this, 10740, v); }
+
+    /**
+     * 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`.
+     */
+    get transformArray(): PackedVector3Array { return _C(this, 1014) as PackedVector3Array; }
+    set transformArray(v: PackedVector3Array) { _C(this, 1045, v); }
+
+    /**
+     * 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`.
+     */
+    get transform2dArray(): PackedVector2Array { return _C(this, 1013) as PackedVector2Array; }
+    set transform2dArray(v: PackedVector2Array) { _C(this, 1044, v); }
+
+    /**
+     * Array containing each {@link Color} used by all instances of this mesh.
+     */
+    get colorArray(): PackedColorArray { return _C(this, 997) as PackedColorArray; }
+    set colorArray(v: PackedColorArray) { _C(this, 1023, v); }
+
+    /**
+     * Array containing each custom data value used by all instances of this mesh, as a {@link PackedColorArray}.
+     */
+    get customDataArray(): PackedColorArray { return _C(this, 999) as PackedColorArray; }
+    set customDataArray(v: PackedColorArray) { _C(this, 1025, v); }
+
+    /**
+     * 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.
+     */
+    get physicsInterpolationQuality(): PhysicsInterpolationQuality { return _C(this, 5889) as PhysicsInterpolationQuality; }
+    set physicsInterpolationQuality(v: PhysicsInterpolationQuality) { _C(this, 12310, v); }
+
+    static readonly name = _R(423, MultiMesh);
+}
+
+export const TransformFormat = {
+    /**
+     * Use this when using 2D transforms.
+     */
+    TRANSFORM_2D: 0,
+    /**
+     * Use this when using 3D transforms.
+     */
+    TRANSFORM_3D: 1,
+} as const;
+
+export type TransformFormat = (typeof TransformFormat)[keyof typeof TransformFormat];
+
+export const PhysicsInterpolationQuality = {
+    /**
+     * Always interpolate using Basis lerping, which can produce warping artifacts in some situations.
+     */
+    INTERP_QUALITY_FAST: 0,
+    /**
+     * Attempt to interpolate using Basis slerping (spherical linear interpolation) where possible, otherwise fall back to lerping.
+     */
+    INTERP_QUALITY_HIGH: 1,
+} as const;
+
+export type PhysicsInterpolationQuality = (typeof PhysicsInterpolationQuality)[keyof typeof PhysicsInterpolationQuality];
+

package/gen/classes/MultiMeshInstance2D.ts

@@ -0,0 +1,36 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { MultiMesh } from './MultiMesh.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * {@link MultiMeshInstance2D} is a specialized node to instance a {@link MultiMesh} resource in 2D. This can be faster to render compared to displaying many {@link Sprite2D} nodes with large transparent areas, especially if the nodes take up a lot of space on screen at high viewport resolutions. This is because using a mesh designed to fit the sprites' opaque areas will reduce GPU fill rate utilization (at the cost of increased vertex processing utilization).
+ * Usage is the same as {@link MultiMeshInstance3D}.
+ */
+export class MultiMeshInstance2D extends Node2D {
+    constructor(name = 424) { super(name); }
+
+    /**
+     * The {@link MultiMesh} that will be drawn by the {@link MultiMeshInstance2D}.
+     */
+    get multimesh(): MultiMesh { return _C(this, 5598) as MultiMesh; }
+    set multimesh(v: MultiMesh) { _C(this, 12106, v); }
+
+    /**
+     * The {@link Texture2D} that will be used if using the default {@link CanvasItemMaterial}. Can be accessed as `TEXTURE` in CanvasItem shader.
+     */
+    get texture(): Texture2D { return _C(this, 6726) as Texture2D; }
+    set texture(v: Texture2D) { _C(this, 13024, v); }
+
+    /**
+     * Emitted when the {@link texture} is changed.
+     */
+    get textureChanged(): Signal<() => void> { return _G(this, 14175) as Signal<() => void>; }
+    set textureChanged(v: (() => void) | null) { _G(this, 14175, v); }
+
+    static readonly name = _R(424, MultiMeshInstance2D);
+}

package/gen/classes/MultiMeshInstance3D.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GeometryInstance3D } from './GeometryInstance3D.ts';
+import type { MultiMesh } from './MultiMesh.ts';
+
+/**
+ * {@link MultiMeshInstance3D} is a specialized node to instance {@link GeometryInstance3D}s based on a {@link MultiMesh} resource.
+ * This is useful to optimize the rendering of a high number of instances of a given mesh (for example trees in a forest or grass strands).
+ */
+export class MultiMeshInstance3D extends GeometryInstance3D {
+    constructor(name = 425) { super(name); }
+
+    /**
+     * The {@link MultiMesh} resource that will be used and shared among all instances of the {@link MultiMeshInstance3D}.
+     */
+    get multimesh(): MultiMesh { return _C(this, 5598) as MultiMesh; }
+    set multimesh(v: MultiMesh) { _C(this, 12106, v); }
+
+    static readonly name = _R(425, MultiMeshInstance3D);
+}

package/gen/classes/MultiplayerAPI.ts

@@ -0,0 +1,139 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, PackedInt32Array, Signal, StringName, Variant } from '../heap-types/index.ts';
+import type { MultiplayerPeer } from './MultiplayerPeer.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * Base class for high-level multiplayer API implementations. See also {@link MultiplayerPeer}.
+ * By default, {@link SceneTree} has a reference to an implementation of this class and uses it to provide multiplayer capabilities (i.e. RPCs) across the whole scene.
+ * It is possible to override the MultiplayerAPI instance used by specific tree branches by calling the {@link SceneTree.setMultiplayer} method, effectively allowing to run both client and server in the same scene.
+ * It is also possible to extend or replace the default implementation via scripting or native extensions. See {@link MultiplayerAPIExtension} for details about extensions, {@link SceneMultiplayer} for the details about the default implementation.
+ */
+export class MultiplayerAPI extends RefCounted {
+
+    /**
+     * Returns `true` if there is a {@link multiplayerPeer} set.
+     */
+    hasMultiplayerPeer(): boolean { return _C(this, 7419) as boolean; }
+
+    /**
+     * Returns the unique peer ID of this MultiplayerAPI's {@link multiplayerPeer}.
+     */
+    getUniqueId(): number { return _C(this, 6951) as number; }
+
+    /**
+     * Returns `true` if this MultiplayerAPI's {@link multiplayerPeer} is valid and in server mode (listening for connections).
+     */
+    isServer(): boolean { return _C(this, 8290) as boolean; }
+
+    /**
+     * 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).
+     */
+    getRemoteSenderId(): number { return _C(this, 6128) as number; }
+
+    /**
+     * Method used for polling the MultiplayerAPI. You only need to worry about this if you set {@link SceneTree.multiplayerPoll} 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(): Error { return _C(this, 9471) as Error; }
+
+    /**
+     * 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.rpcConfig}.
+     * **Note:** Prefer using {@link Node.rpc}, {@link Node.rpcId}, 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: number, object: Object, method: StringName, _arguments?: GodotArray /* = [] */): Error { return _C(this, 10172, peer, object, method, _arguments) as Error; }
+
+    /**
+     * 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}.
+     */
+    objectConfigurationAdd(object: Object, configuration: Variant): Error { return _C(this, 9119, object, configuration) as Error; }
+
+    /**
+     * 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}.
+     */
+    objectConfigurationRemove(object: Object, configuration: Variant): Error { return _C(this, 9120, object, configuration) as Error; }
+
+    /**
+     * Returns the peer IDs of all connected peers of this MultiplayerAPI's {@link multiplayerPeer}.
+     */
+    getPeers(): PackedInt32Array { return _C(this, 5873) as PackedInt32Array; }
+
+    /**
+     * 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 setDefaultInterface(interfaceName: StringName): void { _C(426, 11066, interfaceName); }
+
+    /**
+     * Returns the default MultiplayerAPI implementation class name. This is usually `"SceneMultiplayer"` when {@link SceneMultiplayer} is available. See {@link setDefaultInterface}.
+     */
+    static getDefaultInterface(): StringName { return _C(426, 4453) as StringName; }
+
+    /**
+     * Returns a new instance of the default MultiplayerAPI.
+     */
+    static createDefaultInterface(): MultiplayerAPI { return _C(426, 2519) as MultiplayerAPI; }
+
+    /**
+     * 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 isServer}) 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.
+     */
+    get multiplayerPeer(): MultiplayerPeer { return _C(this, 5601) as MultiplayerPeer; }
+    set multiplayerPeer(v: MultiplayerPeer) { _C(this, 12109, v); }
+
+    /**
+     * Emitted when this MultiplayerAPI's {@link multiplayerPeer} 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).
+     */
+    get peerConnected(): Signal<(id: number) => void> { return _G(this, 9388) as Signal<(id: number) => void>; }
+    set peerConnected(v: ((id: number) => void) | null) { _G(this, 9388, v); }
+
+    /**
+     * Emitted when this MultiplayerAPI's {@link multiplayerPeer} disconnects from a peer. Clients get notified when other clients disconnect from the same server.
+     */
+    get peerDisconnected(): Signal<(id: number) => void> { return _G(this, 9392) as Signal<(id: number) => void>; }
+    set peerDisconnected(v: ((id: number) => void) | null) { _G(this, 9392, v); }
+
+    /**
+     * Emitted when this MultiplayerAPI's {@link multiplayerPeer} successfully connected to a server. Only emitted on clients.
+     */
+    get connectedToServer(): Signal<() => void> { return _G(this, 2442) as Signal<() => void>; }
+    set connectedToServer(v: (() => void) | null) { _G(this, 2442, v); }
+
+    /**
+     * Emitted when this MultiplayerAPI's {@link multiplayerPeer} fails to establish a connection to a server. Only emitted on clients.
+     */
+    get connectionFailed(): Signal<() => void> { return _G(this, 2446) as Signal<() => void>; }
+    set connectionFailed(v: (() => void) | null) { _G(this, 2446, v); }
+
+    /**
+     * Emitted when this MultiplayerAPI's {@link multiplayerPeer} disconnects from server. Only emitted on clients.
+     */
+    get serverDisconnected(): Signal<() => void> { return _G(this, 10376) as Signal<() => void>; }
+    set serverDisconnected(v: (() => void) | null) { _G(this, 10376, v); }
+
+    static readonly name = _R(426, MultiplayerAPI);
+}
+
+export const RPCMode = {
+    /**
+     * Used with {@link Node.rpcConfig} to disable a method or property for all RPC calls, making it unavailable. Default for all methods.
+     */
+    RPC_MODE_DISABLED: 0,
+    /**
+     * Used with {@link Node.rpcConfig} 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.
+     */
+    RPC_MODE_ANY_PEER: 1,
+    /**
+     * Used with {@link Node.rpcConfig} 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.setMultiplayerAuthority}.
+     */
+    RPC_MODE_AUTHORITY: 2,
+} as const;
+
+export type RPCMode = (typeof RPCMode)[keyof typeof RPCMode];
+