typescript-to-gdscript 0.1.0

package/typings/classes/StaticBody3D.d.ts

@@ -0,0 +1,27 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A 3D physics body that can't be moved by external forces. When moved manually, it doesn't affect other bodies in its path.
+ */
+declare class StaticBody3D extends PhysicsBody3D {
+  /**
+   * The body's constant angular velocity. This does not rotate the body, but affects touching bodies, as if it were rotating.
+   */
+  constant_angular_velocity: Vector3;
+  /**
+   * The body's constant linear velocity. This does not move the body, but affects touching bodies, as if it were moving.
+   */
+  constant_linear_velocity: Vector3;
+  /**
+   * The physics material override for the body.
+   * If a material is assigned to this property, it will be used instead of any other physics material, such as an inherited one.
+   */
+  physics_material_override: PhysicsMaterial | null;
+  set_constant_angular_velocity(value: Vector3 | Vector3i): void;
+  get_constant_angular_velocity(): Vector3;
+  set_constant_linear_velocity(value: Vector3 | Vector3i): void;
+  get_constant_linear_velocity(): Vector3;
+  set_physics_material_override(value: PhysicsMaterial | null): void;
+  get_physics_material_override(): PhysicsMaterial | null;
+}

package/typings/classes/StatusIndicator.d.ts

@@ -0,0 +1,36 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Application status indicator (aka notification area icon).
+ * **Note:** Status indicator is implemented on macOS and Windows.
+ */
+declare class StatusIndicator extends Node {
+  /** Status indicator icon. */
+  icon: Texture2D | null;
+  /**
+   * Status indicator native popup menu. If this is set, the {@link pressed} signal is not emitted.
+   * **Note:** Native popup is only supported if {@link NativeMenu} supports {@link NativeMenu.FEATURE_POPUP_MENU} feature.
+   */
+  menu: NodePath;
+  /** Status indicator tooltip. */
+  tooltip: string;
+  /** If `true`, the status indicator is visible. */
+  visible: boolean;
+  set_icon(value: Texture2D | null): void;
+  get_icon(): Texture2D | null;
+  set_menu(value: NodePath | string): void;
+  get_menu(): NodePath;
+  set_tooltip(value: string | NodePath): void;
+  get_tooltip(): string;
+  set_visible(value: boolean): void;
+  is_visible(): boolean;
+
+  /**
+   * Returns the status indicator rectangle in screen coordinates. If this status indicator is not visible, returns an empty {@link Rect2}.
+   */
+  get_rect(): Rect2;
+
+  /** Emitted when the status indicator is pressed. */
+  pressed: Signal<[int, Vector2i]>;
+}

package/typings/classes/StreamPeer.d.ts

@@ -0,0 +1,102 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for interacting with streams. */
+declare class StreamPeer extends RefCounted {
+  /** If `true`, this {@link StreamPeer} will using big-endian format for encoding and decoding. */
+  big_endian: boolean;
+  set_big_endian(value: boolean): void;
+  is_big_endian_enabled(): boolean;
+
+  /** Gets a signed byte from the stream. */
+  get_8(): int;
+  /** Gets a signed 16-bit value from the stream. */
+  get_16(): int;
+  /** Gets a signed 32-bit value from the stream. */
+  get_32(): int;
+  /** Gets a signed 64-bit value from the stream. */
+  get_64(): int;
+  /** Returns the number of bytes this {@link StreamPeer} has available. */
+  get_available_bytes(): int;
+  /**
+   * Returns a chunk data with the received bytes, as an {@link Array} containing two elements: an {@link Error} constant and a {@link PackedByteArray}. `bytes` is the number of bytes to be received. If not enough bytes are available, the function will block until the desired amount is received.
+   */
+  get_data(bytes: int): Array<unknown>;
+  /** Gets a double-precision float from the stream. */
+  get_double(): float;
+  /** Gets a single-precision float from the stream. */
+  get_float(): float;
+  /** Gets a half-precision float from the stream. */
+  get_half(): float;
+  /**
+   * Returns a chunk data with the received bytes, as an {@link Array} containing two elements: an {@link Error} constant and a {@link PackedByteArray}. `bytes` is the number of bytes to be received. If not enough bytes are available, the function will return how many were actually received.
+   */
+  get_partial_data(bytes: int): Array<unknown>;
+  /**
+   * Gets an ASCII string with byte-length `bytes` from the stream. If `bytes` is negative (default) the length will be read from the stream using the reverse process of {@link put_string}.
+   */
+  get_string(bytes?: int): string;
+  /** Gets an unsigned byte from the stream. */
+  get_u8(): int;
+  /** Gets an unsigned 16-bit value from the stream. */
+  get_u16(): int;
+  /** Gets an unsigned 32-bit value from the stream. */
+  get_u32(): int;
+  /** Gets an unsigned 64-bit value from the stream. */
+  get_u64(): int;
+  /**
+   * Gets a UTF-8 string with byte-length `bytes` from the stream (this decodes the string sent as UTF-8). If `bytes` is negative (default) the length will be read from the stream using the reverse process of {@link put_utf8_string}.
+   */
+  get_utf8_string(bytes?: int): string;
+  /**
+   * Gets a Variant from the stream. If `allow_objects` is `true`, decoding objects is allowed.
+   * Internally, this uses the same decoding mechanism as the {@link @GlobalScope.bytes_to_var} method.
+   * **Warning:** Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution.
+   */
+  get_var(allow_objects?: boolean): unknown;
+  /** Puts a signed byte into the stream. */
+  put_8(value: int): void;
+  /** Puts a signed 16-bit value into the stream. */
+  put_16(value: int): void;
+  /** Puts a signed 32-bit value into the stream. */
+  put_32(value: int): void;
+  /** Puts a signed 64-bit value into the stream. */
+  put_64(value: int): void;
+  /**
+   * Sends a chunk of data through the connection, blocking if necessary until the data is done sending. This function returns an {@link Error} code.
+   */
+  put_data(data: PackedByteArray | Array<unknown>): int;
+  /** Puts a double-precision float into the stream. */
+  put_double(value: float): void;
+  /** Puts a single-precision float into the stream. */
+  put_float(value: float): void;
+  /** Puts a half-precision float into the stream. */
+  put_half(value: float): void;
+  /**
+   * Sends a chunk of data through the connection. If all the data could not be sent at once, only part of it will. This function returns two values, an {@link Error} code and an integer, describing how much data was actually sent.
+   */
+  put_partial_data(data: PackedByteArray | Array<unknown>): Array<unknown>;
+  /**
+   * Puts a zero-terminated ASCII string into the stream prepended by a 32-bit unsigned integer representing its size.
+   * **Note:** To put an ASCII string without prepending its size, you can use {@link put_data}:
+   */
+  put_string(value: string | NodePath): void;
+  /** Puts an unsigned byte into the stream. */
+  put_u8(value: int): void;
+  /** Puts an unsigned 16-bit value into the stream. */
+  put_u16(value: int): void;
+  /** Puts an unsigned 32-bit value into the stream. */
+  put_u32(value: int): void;
+  /** Puts an unsigned 64-bit value into the stream. */
+  put_u64(value: int): void;
+  /**
+   * Puts a zero-terminated UTF-8 string into the stream prepended by a 32 bits unsigned integer representing its size.
+   * **Note:** To put a UTF-8 string without prepending its size, you can use {@link put_data}:
+   */
+  put_utf8_string(value: string | NodePath): void;
+  /**
+   * Puts a Variant into the stream. If `full_objects` is `true` encoding objects is allowed (and can potentially include code).
+   * Internally, this uses the same encoding mechanism as the {@link @GlobalScope.var_to_bytes} method.
+   */
+  put_var(value: unknown, full_objects?: boolean): void;
+}

package/typings/classes/StreamPeerBuffer.d.ts

@@ -0,0 +1,23 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A stream peer used to handle binary data streams. */
+declare class StreamPeerBuffer extends StreamPeer {
+  /** The underlying data buffer. Setting this value resets the cursor. */
+  data_array: PackedByteArray;
+  set_data_array(value: PackedByteArray | Array<unknown>): void;
+  get_data_array(): PackedByteArray;
+
+  /** Clears the {@link data_array} and resets the cursor. */
+  clear(): void;
+  /** Returns a new {@link StreamPeerBuffer} with the same {@link data_array} content. */
+  duplicate(): StreamPeerBuffer;
+  /** Returns the current cursor position. */
+  get_position(): int;
+  /** Returns the size of {@link data_array}. */
+  get_size(): int;
+  /** Resizes the {@link data_array}. This *doesn't* update the cursor. */
+  resize(size: int): void;
+  /** Moves the cursor to the specified position. `position` must be a valid index of {@link data_array}. */
+  seek(position: int): void;
+}

package/typings/classes/StreamPeerExtension.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+declare class StreamPeerExtension extends StreamPeer {
+  _get_available_bytes(): int;
+  _get_data(r_buffer: int, r_bytes: int, r_received: int): int;
+  _get_partial_data(r_buffer: int, r_bytes: int, r_received: int): int;
+  _put_data(p_data: int, p_bytes: int, r_sent: int): int;
+  _put_partial_data(p_data: int, p_bytes: int, r_sent: int): int;
+}

package/typings/classes/StreamPeerGZIP.d.ts

@@ -0,0 +1,21 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A stream peer that handles GZIP and deflate compression/decompression. */
+declare class StreamPeerGZIP extends StreamPeer {
+  /** Clears this stream, resetting the internal state. */
+  clear(): void;
+  /**
+   * Finalizes the stream, compressing any buffered chunk left.
+   * You must call it only when you are compressing.
+   */
+  finish(): int;
+  /**
+   * Start the stream in compression mode with the given `buffer_size`, if `use_deflate` is `true` uses deflate instead of GZIP.
+   */
+  start_compression(use_deflate?: boolean, buffer_size?: int): int;
+  /**
+   * Start the stream in decompression mode with the given `buffer_size`, if `use_deflate` is `true` uses deflate instead of GZIP.
+   */
+  start_decompression(use_deflate?: boolean, buffer_size?: int): int;
+}

package/typings/classes/StreamPeerSocket.d.ts

@@ -0,0 +1,22 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for interacting with socket streams. */
+declare class StreamPeerSocket extends StreamPeer {
+  /** Disconnects from host. */
+  disconnect_from_host(): void;
+  /** Returns the status of the connection. */
+  get_status(): int;
+  /** Polls the socket, updating its state. See {@link get_status}. */
+  poll(): int;
+
+  // enum Status
+  /** The initial status of the {@link StreamPeerSocket}. This is also the status after disconnecting. */
+  static readonly STATUS_NONE: int;
+  /** A status representing a {@link StreamPeerSocket} that is connecting to a host. */
+  static readonly STATUS_CONNECTING: int;
+  /** A status representing a {@link StreamPeerSocket} that is connected to a host. */
+  static readonly STATUS_CONNECTED: int;
+  /** A status representing a {@link StreamPeerSocket} in error state. */
+  static readonly STATUS_ERROR: int;
+}

package/typings/classes/StreamPeerTCP.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A stream peer that handles TCP connections. */
+declare class StreamPeerTCP extends StreamPeerSocket {
+  /**
+   * Opens the TCP socket, and binds it to the specified local address.
+   * This method is generally not needed, and only used to force the subsequent call to {@link connect_to_host} to use the specified `host` and `port` as source address. This can be desired in some NAT punchthrough techniques, or when forcing the source network interface.
+   */
+  bind(port: int, host?: string | NodePath): int;
+  /**
+   * Connects to the specified `host:port` pair. A hostname will be resolved if valid. Returns {@link OK} on success.
+   */
+  connect_to_host(host: string | NodePath, port: int): int;
+  /** Returns the IP of this peer. */
+  get_connected_host(): string;
+  /** Returns the port of this peer. */
+  get_connected_port(): int;
+  /** Returns the local port to which this peer is bound. */
+  get_local_port(): int;
+  /**
+   * If `enabled` is `true`, packets will be sent immediately. If `enabled` is `false` (the default), packet transfers will be delayed and combined using Nagle's algorithm (https://en.wikipedia.org/wiki/Nagle%27s_algorithm).
+   * **Note:** It's recommended to leave this disabled for applications that send large packets or need to transfer a lot of data, as enabling this can decrease the total available bandwidth.
+   */
+  set_no_delay(enabled: boolean): void;
+}

package/typings/classes/StreamPeerTLS.d.ts

@@ -0,0 +1,40 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A stream peer that handles TLS connections. */
+declare class StreamPeerTLS extends StreamPeer {
+  /**
+   * Accepts a peer connection as a server using the given `server_options`. See {@link TLSOptions.server}.
+   */
+  accept_stream(stream: StreamPeer, server_options: TLSOptions): int;
+  /**
+   * Connects to a peer using an underlying {@link StreamPeer} `stream` and verifying the remote certificate is correctly signed for the given `common_name`. You can pass the optional `client_options` parameter to customize the trusted certification authorities, or disable the common name verification. See {@link TLSOptions.client} and {@link TLSOptions.client_unsafe}.
+   */
+  connect_to_stream(stream: StreamPeer, common_name: string | NodePath, client_options?: TLSOptions): int;
+  /** Disconnects from host. */
+  disconnect_from_stream(): void;
+  /** Returns the status of the connection. */
+  get_status(): int;
+  /**
+   * Returns the underlying {@link StreamPeer} connection, used in {@link accept_stream} or {@link connect_to_stream}.
+   */
+  get_stream(): StreamPeer | null;
+  /**
+   * Poll the connection to check for incoming bytes. Call this right before {@link StreamPeer.get_available_bytes} for it to work properly.
+   */
+  poll(): void;
+
+  // enum Status
+  /** A status representing a {@link StreamPeerTLS} that is disconnected. */
+  static readonly STATUS_DISCONNECTED: int;
+  /** A status representing a {@link StreamPeerTLS} during handshaking. */
+  static readonly STATUS_HANDSHAKING: int;
+  /** A status representing a {@link StreamPeerTLS} that is connected to a host. */
+  static readonly STATUS_CONNECTED: int;
+  /** A status representing a {@link StreamPeerTLS} in error state. */
+  static readonly STATUS_ERROR: int;
+  /**
+   * An error status that shows a mismatch in the TLS certificate domain presented by the host and the domain requested for validation.
+   */
+  static readonly STATUS_ERROR_HOSTNAME_MISMATCH: int;
+}

package/typings/classes/StreamPeerUDS.d.ts

@@ -0,0 +1,15 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A stream peer that handles UNIX Domain Socket (UDS) connections. */
+declare class StreamPeerUDS extends StreamPeerSocket {
+  /**
+   * Opens the UDS socket, and binds it to the specified socket path.
+   * This method is generally not needed, and only used to force the subsequent call to {@link connect_to_host} to use the specified `path` as the source address.
+   */
+  bind(path: string | NodePath): int;
+  /** Connects to the specified UNIX Domain Socket path. Returns {@link OK} on success. */
+  connect_to_host(path: string | NodePath): int;
+  /** Returns the socket path of this peer. */
+  get_connected_path(): string;
+}