typescript-to-gdscript 0.1.0

package/typings/classes/Time.d.ts

@@ -0,0 +1,149 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A singleton for working with time data. */
+declare interface Time extends GodotObject {
+  /**
+   * Returns the current date as a dictionary of keys: `year`, `month`, `day`, and `weekday`.
+   * The returned values are in the system's local time when `utc` is `false`, otherwise they are in UTC.
+   */
+  get_date_dict_from_system(utc?: boolean): Dictionary;
+  /** Converts the given Unix timestamp to a dictionary of keys: `year`, `month`, `day`, and `weekday`. */
+  get_date_dict_from_unix_time(unix_time_val: int): Dictionary;
+  /**
+   * Returns the current date as an ISO 8601 date string (YYYY-MM-DD).
+   * The returned values are in the system's local time when `utc` is `false`, otherwise they are in UTC.
+   */
+  get_date_string_from_system(utc?: boolean): string;
+  /** Converts the given Unix timestamp to an ISO 8601 date string (YYYY-MM-DD). */
+  get_date_string_from_unix_time(unix_time_val: int): string;
+  /**
+   * Converts the given ISO 8601 date and time string (YYYY-MM-DDTHH:MM:SS) to a dictionary of keys: `year`, `month`, `day`, [code skip-lint]weekday[/code], `hour`, `minute`, and `second`.
+   * If `weekday` is `false`, then the [code skip-lint]weekday[/code] entry is excluded (the calculation is relatively expensive).
+   * **Note:** Any decimal fraction in the time string will be ignored silently.
+   */
+  get_datetime_dict_from_datetime_string(datetime: string | NodePath, weekday: boolean): Dictionary;
+  /**
+   * Returns the current date as a dictionary of keys: `year`, `month`, `day`, `weekday`, `hour`, `minute`, `second`, and `dst` (Daylight Savings Time).
+   */
+  get_datetime_dict_from_system(utc?: boolean): Dictionary;
+  /**
+   * Converts the given Unix timestamp to a dictionary of keys: `year`, `month`, `day`, `weekday`, `hour`, `minute`, and `second`.
+   * The returned Dictionary's values will be the same as the {@link get_datetime_dict_from_system} if the Unix timestamp is the current time, with the exception of Daylight Savings Time as it cannot be determined from the epoch.
+   */
+  get_datetime_dict_from_unix_time(unix_time_val: int): Dictionary;
+  /**
+   * Converts the given dictionary of keys to an ISO 8601 date and time string (YYYY-MM-DDTHH:MM:SS).
+   * The given dictionary can be populated with the following keys: `year`, `month`, `day`, `hour`, `minute`, and `second`. Any other entries (including `dst`) are ignored.
+   * If the dictionary is empty, `0` is returned. If some keys are omitted, they default to the equivalent values for the Unix epoch timestamp 0 (1970-01-01 at 00:00:00).
+   * If `use_space` is `true`, the date and time bits are separated by an empty space character instead of the letter T.
+   */
+  get_datetime_string_from_datetime_dict(datetime: Dictionary, use_space: boolean): string;
+  /**
+   * Returns the current date and time as an ISO 8601 date and time string (YYYY-MM-DDTHH:MM:SS).
+   * The returned values are in the system's local time when `utc` is `false`, otherwise they are in UTC.
+   * If `use_space` is `true`, the date and time bits are separated by an empty space character instead of the letter T.
+   */
+  get_datetime_string_from_system(utc?: boolean, use_space?: boolean): string;
+  /**
+   * Converts the given Unix timestamp to an ISO 8601 date and time string (YYYY-MM-DDTHH:MM:SS).
+   * If `use_space` is `true`, the date and time bits are separated by an empty space character instead of the letter T.
+   */
+  get_datetime_string_from_unix_time(unix_time_val: int, use_space?: boolean): string;
+  /**
+   * Converts the given timezone offset in minutes to a timezone offset string. For example, -480 returns "-08:00", 345 returns "+05:45", and 0 returns "+00:00".
+   */
+  get_offset_string_from_offset_minutes(offset_minutes: int): string;
+  /**
+   * Returns the amount of time passed in milliseconds since the engine started.
+   * Will always be positive or 0 and uses a 64-bit value (it will wrap after roughly 500 million years).
+   */
+  get_ticks_msec(): int;
+  /**
+   * Returns the amount of time passed in microseconds since the engine started.
+   * Will always be positive or 0 and uses a 64-bit value (it will wrap after roughly half a million years).
+   */
+  get_ticks_usec(): int;
+  /**
+   * Returns the current time as a dictionary of keys: `hour`, `minute`, and `second`.
+   * The returned values are in the system's local time when `utc` is `false`, otherwise they are in UTC.
+   */
+  get_time_dict_from_system(utc?: boolean): Dictionary;
+  /** Converts the given time to a dictionary of keys: `hour`, `minute`, and `second`. */
+  get_time_dict_from_unix_time(unix_time_val: int): Dictionary;
+  /**
+   * Returns the current time as an ISO 8601 time string (HH:MM:SS).
+   * The returned values are in the system's local time when `utc` is `false`, otherwise they are in UTC.
+   */
+  get_time_string_from_system(utc?: boolean): string;
+  /** Converts the given Unix timestamp to an ISO 8601 time string (HH:MM:SS). */
+  get_time_string_from_unix_time(unix_time_val: int): string;
+  /**
+   * Returns the current time zone as a dictionary of keys: `bias` and `name`.
+   * - `bias` is the offset from UTC in minutes, since not all time zones are multiples of an hour from UTC.
+   * - `name` is the localized name of the time zone, according to the OS locale settings of the current user.
+   */
+  get_time_zone_from_system(): Dictionary;
+  /**
+   * Converts a dictionary of time values to a Unix timestamp.
+   * The given dictionary can be populated with the following keys: `year`, `month`, `day`, `hour`, `minute`, and `second`. Any other entries (including `dst`) are ignored.
+   * If the dictionary is empty, `0` is returned. If some keys are omitted, they default to the equivalent values for the Unix epoch timestamp 0 (1970-01-01 at 00:00:00).
+   * You can pass the output from {@link get_datetime_dict_from_unix_time} directly into this function and get the same as what was put in.
+   * **Note:** Unix timestamps are often in UTC. This method does not do any timezone conversion, so the timestamp will be in the same timezone as the given datetime dictionary.
+   */
+  get_unix_time_from_datetime_dict(datetime: Dictionary): int;
+  /**
+   * Converts the given ISO 8601 date and/or time string to a Unix timestamp. The string can contain a date only, a time only, or both.
+   * **Note:** Unix timestamps are often in UTC. This method does not do any timezone conversion, so the timestamp will be in the same timezone as the given datetime string.
+   * **Note:** Any decimal fraction in the time string will be ignored silently.
+   */
+  get_unix_time_from_datetime_string(datetime: string | NodePath): int;
+  /**
+   * Returns the current Unix timestamp in seconds based on the system time in UTC. This method is implemented by the operating system and always returns the time in UTC. The Unix timestamp is the number of seconds passed since 1970-01-01 at 00:00:00, the Unix epoch (https://en.wikipedia.org/wiki/Unix_time).
+   * **Note:** Unlike other methods that use integer timestamps, this method returns the timestamp as a [float] for sub-second precision.
+   */
+  get_unix_time_from_system(): float;
+
+  // enum Month
+  /** The month of January, represented numerically as `01`. */
+  readonly MONTH_JANUARY: int;
+  /** The month of February, represented numerically as `02`. */
+  readonly MONTH_FEBRUARY: int;
+  /** The month of March, represented numerically as `03`. */
+  readonly MONTH_MARCH: int;
+  /** The month of April, represented numerically as `04`. */
+  readonly MONTH_APRIL: int;
+  /** The month of May, represented numerically as `05`. */
+  readonly MONTH_MAY: int;
+  /** The month of June, represented numerically as `06`. */
+  readonly MONTH_JUNE: int;
+  /** The month of July, represented numerically as `07`. */
+  readonly MONTH_JULY: int;
+  /** The month of August, represented numerically as `08`. */
+  readonly MONTH_AUGUST: int;
+  /** The month of September, represented numerically as `09`. */
+  readonly MONTH_SEPTEMBER: int;
+  /** The month of October, represented numerically as `10`. */
+  readonly MONTH_OCTOBER: int;
+  /** The month of November, represented numerically as `11`. */
+  readonly MONTH_NOVEMBER: int;
+  /** The month of December, represented numerically as `12`. */
+  readonly MONTH_DECEMBER: int;
+  // enum Weekday
+  /** The day of the week Sunday, represented numerically as `0`. */
+  readonly WEEKDAY_SUNDAY: int;
+  /** The day of the week Monday, represented numerically as `1`. */
+  readonly WEEKDAY_MONDAY: int;
+  /** The day of the week Tuesday, represented numerically as `2`. */
+  readonly WEEKDAY_TUESDAY: int;
+  /** The day of the week Wednesday, represented numerically as `3`. */
+  readonly WEEKDAY_WEDNESDAY: int;
+  /** The day of the week Thursday, represented numerically as `4`. */
+  readonly WEEKDAY_THURSDAY: int;
+  /** The day of the week Friday, represented numerically as `5`. */
+  readonly WEEKDAY_FRIDAY: int;
+  /** The day of the week Saturday, represented numerically as `6`. */
+  readonly WEEKDAY_SATURDAY: int;
+}
+declare const Time: Time;
+

package/typings/classes/Timer.d.ts

@@ -0,0 +1,71 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A countdown timer. */
+declare class Timer extends Node {
+  /**
+   * If `true`, the timer will start immediately when it enters the scene tree.
+   * **Note:** After the timer enters the tree, this property is automatically set to `false`.
+   * **Note:** This property does nothing when the timer is running in the editor.
+   */
+  autostart: boolean;
+  /** If `true`, the timer will ignore {@link Engine.time_scale} and update with the real, elapsed time. */
+  ignore_time_scale: boolean;
+  /**
+   * If `true`, the timer will stop after reaching the end. Otherwise, as by default, the timer will automatically restart.
+   */
+  one_shot: boolean;
+  /**
+   * If `true`, the timer is paused. A paused timer does not process until this property is set back to `false`, even when {@link start} is called. See also {@link stop}.
+   */
+  paused: boolean;
+  /** Specifies when the timer is updated during the main loop. */
+  process_callback: int;
+  /**
+   * The timer's remaining time in seconds. This is always `0` if the timer is stopped.
+   * **Note:** This property is read-only and cannot be modified. It is based on {@link wait_time}.
+   */
+  time_left: float;
+  /**
+   * The time required for the timer to end, in seconds. This property can also be set every time {@link start} is called.
+   * **Note:** Timers can only process once per physics or process frame (depending on the {@link process_callback}). An unstable framerate may cause the timer to end inconsistently, which is especially noticeable if the wait time is lower than roughly `0.05` seconds. For very short timers, it is recommended to write your own code instead of using a {@link Timer} node. Timers are also affected by {@link Engine.time_scale}.
+   */
+  wait_time: float;
+  set_autostart(value: boolean): void;
+  has_autostart(): boolean;
+  set_ignore_time_scale(value: boolean): void;
+  is_ignoring_time_scale(): boolean;
+  set_one_shot(value: boolean): void;
+  is_one_shot(): boolean;
+  set_paused(value: boolean): void;
+  is_paused(): boolean;
+  set_timer_process_callback(value: int): void;
+  get_timer_process_callback(): int;
+  get_time_left(): float;
+  set_wait_time(value: float): void;
+  get_wait_time(): float;
+
+  /** Returns `true` if the timer is stopped or has not started. */
+  is_stopped(): boolean;
+  /**
+   * Starts the timer, or resets the timer if it was started already. Fails if the timer is not inside the scene tree. If `time_sec` is greater than `0`, this value is used for the {@link wait_time}.
+   * **Note:** This method does not resume a paused timer. See {@link paused}.
+   */
+  start(time_sec?: float): void;
+  /**
+   * Stops the timer. See also {@link paused}. Unlike {@link start}, this can safely be called if the timer is not inside the scene tree.
+   * **Note:** Calling {@link stop} does not emit the {@link timeout} signal, as the timer is not considered to have timed out. If this is desired, use `$Timer.timeout.emit()` after calling {@link stop} to manually emit the signal.
+   */
+  stop(): void;
+
+  /** Emitted when the timer reaches the end. */
+  timeout: Signal<[]>;
+
+  // enum TimerProcessCallback
+  /**
+   * Update the timer every physics process frame (see {@link Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS}).
+   */
+  static readonly TIMER_PROCESS_PHYSICS: int;
+  /** Update the timer every process (rendered) frame (see {@link Node.NOTIFICATION_INTERNAL_PROCESS}). */
+  static readonly TIMER_PROCESS_IDLE: int;
+}

package/typings/classes/TorusMesh.d.ts

@@ -0,0 +1,22 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Class representing a torus {@link PrimitiveMesh}. */
+declare class TorusMesh extends PrimitiveMesh {
+  /** The inner radius of the torus. */
+  inner_radius: float;
+  /** The outer radius of the torus. */
+  outer_radius: float;
+  /** The number of edges each ring of the torus is constructed of. */
+  ring_segments: int;
+  /** The number of slices the torus is constructed of. */
+  rings: int;
+  set_inner_radius(value: float): void;
+  get_inner_radius(): float;
+  set_outer_radius(value: float): void;
+  get_outer_radius(): float;
+  set_ring_segments(value: int): void;
+  get_ring_segments(): int;
+  set_rings(value: int): void;
+  get_rings(): int;
+}

package/typings/classes/TouchScreenButton.d.ts

@@ -0,0 +1,61 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Button for touch screen devices for gameplay use. */
+declare class TouchScreenButton extends Node2D {
+  /** The button's action. Actions can be handled with {@link InputEventAction}. */
+  action: string;
+  /** The button's bitmask. */
+  bitmask: BitMap | null;
+  /**
+   * If `true`, the {@link pressed} and {@link released} signals are emitted whenever a pressed finger goes in and out of the button, even if the pressure started outside the active area of the button.
+   * **Note:** This is a "pass-by" (not "bypass") press mode.
+   */
+  passby_press: boolean;
+  /** The button's shape. */
+  shape: Shape2D | null;
+  /**
+   * If `true`, the button's shape is centered in the provided texture. If no texture is used, this property has no effect.
+   */
+  shape_centered: boolean;
+  /** If `true`, the button's shape is visible in the editor. */
+  shape_visible: boolean;
+  /** The button's texture for the normal state. */
+  texture_normal: Texture2D | null;
+  /** The button's texture for the pressed state. */
+  texture_pressed: Texture2D | null;
+  /** The button's visibility mode. */
+  visibility_mode: int;
+  set_action(value: string | NodePath): void;
+  get_action(): string;
+  set_bitmask(value: BitMap | null): void;
+  get_bitmask(): BitMap | null;
+  set_passby_press(value: boolean): void;
+  is_passby_press_enabled(): boolean;
+  set_shape(value: Shape2D | null): void;
+  get_shape(): Shape2D | null;
+  set_shape_centered(value: boolean): void;
+  is_shape_centered(): boolean;
+  set_shape_visible(value: boolean): void;
+  is_shape_visible(): boolean;
+  set_texture_normal(value: Texture2D | null): void;
+  get_texture_normal(): Texture2D | null;
+  set_texture_pressed(value: Texture2D | null): void;
+  get_texture_pressed(): Texture2D | null;
+  set_visibility_mode(value: int): void;
+  get_visibility_mode(): int;
+
+  /** Returns `true` if this button is currently pressed. */
+  is_pressed(): boolean;
+
+  /** Emitted when the button is pressed (down). */
+  pressed: Signal<[]>;
+  /** Emitted when the button is released (up). */
+  released: Signal<[]>;
+
+  // enum VisibilityMode
+  /** Always visible. */
+  static readonly VISIBILITY_ALWAYS: int;
+  /** Visible on touch screens only. */
+  static readonly VISIBILITY_TOUCHSCREEN_ONLY: int;
+}

package/typings/classes/Transform2D.d.ts

@@ -0,0 +1,207 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2×3 matrix representing a 2D transformation. */
+declare interface Transform2D {
+  /**
+   * The translation offset of this transform, and the column `2` of the matrix. In 2D space, this can be seen as the position.
+   */
+  origin: Vector2;
+  /**
+   * The transform basis's X axis, and the column `0` of the matrix. Combined with {@link y}, this represents the transform's rotation, scale, and skew.
+   * On the identity transform, this vector points right ({@link Vector2.RIGHT}).
+   */
+  x: Vector2;
+  /**
+   * The transform basis's Y axis, and the column `1` of the matrix. Combined with {@link x}, this represents the transform's rotation, scale, and skew.
+   * On the identity transform, this vector points down ({@link Vector2.DOWN}).
+   */
+  y: Vector2;
+
+  /**
+   * Returns the inverted version of this transform. Unlike {@link inverse}, this method works with almost any basis, including non-uniform ones, but is slower.
+   * **Note:** For this method to return correctly, the transform's basis needs to have a determinant that is not exactly `0.0` (see {@link determinant}).
+   */
+  affine_inverse(): Transform2D;
+  /**
+   * Returns a copy of the `v` vector, transformed (multiplied) by the transform basis's matrix. Unlike the multiplication operator (`*`), this method ignores the {@link origin}.
+   */
+  basis_xform(v: Vector2 | Vector2i): Vector2;
+  /**
+   * Returns a copy of the `v` vector, transformed (multiplied) by the inverse transform basis's matrix (see {@link inverse}). This method ignores the {@link origin}.
+   * **Note:** This method assumes that this transform's basis is *orthonormal* (see {@link orthonormalized}). If the basis is not orthonormal, `transform.affine_inverse().basis_xform(vector)` should be used instead (see {@link affine_inverse}).
+   */
+  basis_xform_inv(v: Vector2 | Vector2i): Vector2;
+  /**
+   * Returns the determinant (https://en.wikipedia.org/wiki/Determinant) of this transform basis's matrix. For advanced math, this number can be used to determine a few attributes:
+   * - If the determinant is exactly `0.0`, the basis is not invertible (see {@link inverse}).
+   * - If the determinant is a negative number, the basis represents a negative scale.
+   * **Note:** If the basis's scale is the same for every axis, its determinant is always that scale by the power of 2.
+   */
+  determinant(): float;
+  /** Returns this transform's translation. Equivalent to {@link origin}. */
+  get_origin(): Vector2;
+  /**
+   * Returns this transform's rotation (in radians). This is equivalent to {@link x}'s angle (see {@link Vector2.angle}).
+   */
+  get_rotation(): float;
+  /**
+   * Returns the length of both {@link x} and {@link y}, as a {@link Vector2}. If this transform's basis is not skewed, this value is the scaling factor. It is not affected by rotation.
+   * **Note:** If the value returned by {@link determinant} is negative, the scale is also negative.
+   */
+  get_scale(): Vector2;
+  /** Returns this transform's skew (in radians). */
+  get_skew(): float;
+  /**
+   * Returns the result of the linear interpolation between this transform and `xform` by the given `weight`.
+   * The `weight` should be between `0.0` and `1.0` (inclusive). Values outside this range are allowed and can be used to perform *extrapolation* instead.
+   */
+  interpolate_with(xform: Transform2D, weight: float): Transform2D;
+  /**
+   * Returns the inverted version of this transform (https://en.wikipedia.org/wiki/Invertible_matrix).
+   * **Note:** For this method to return correctly, the transform's basis needs to be *orthonormal* (see {@link orthonormalized}). That means the basis should only represent a rotation. If it does not, use {@link affine_inverse} instead.
+   */
+  inverse(): Transform2D;
+  /**
+   * Returns `true` if this transform's basis is conformal. A conformal basis is both *orthogonal* (the axes are perpendicular to each other) and *uniform* (the axes share the same length). This method can be especially useful during physics calculations.
+   */
+  is_conformal(): boolean;
+  /**
+   * Returns `true` if this transform and `xform` are approximately equal, by running {@link @GlobalScope.is_equal_approx} on each component.
+   */
+  is_equal_approx(xform: Transform2D): boolean;
+  /**
+   * Returns `true` if this transform is finite, by calling {@link @GlobalScope.is_finite} on each component.
+   */
+  is_finite(): boolean;
+  /**
+   * Returns a copy of the transform rotated such that the rotated X-axis points towards the `target` position, in global space.
+   */
+  looking_at(target?: Vector2 | Vector2i): Transform2D;
+  /**
+   * Returns a copy of this transform with its basis orthonormalized. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the axes have a length of `1.0`), which also means it can only represent a rotation.
+   */
+  orthonormalized(): Transform2D;
+  /**
+   * Returns a copy of this transform rotated by the given `angle` (in radians).
+   * If `angle` is positive, the transform is rotated clockwise.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding rotation transform `R` from the left, i.e., `R * X`.
+   * This can be seen as transforming with respect to the global/parent frame.
+   */
+  rotated(angle: float): Transform2D;
+  /**
+   * Returns a copy of the transform rotated by the given `angle` (in radians).
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding rotation transform `R` from the right, i.e., `X * R`.
+   * This can be seen as transforming with respect to the local frame.
+   */
+  rotated_local(angle: float): Transform2D;
+  /**
+   * Returns a copy of the transform scaled by the given `scale` factor.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding scaling transform `S` from the left, i.e., `S * X`.
+   * This can be seen as transforming with respect to the global/parent frame.
+   */
+  scaled(scale: Vector2 | Vector2i): Transform2D;
+  /**
+   * Returns a copy of the transform scaled by the given `scale` factor.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding scaling transform `S` from the right, i.e., `X * S`.
+   * This can be seen as transforming with respect to the local frame.
+   */
+  scaled_local(scale: Vector2 | Vector2i): Transform2D;
+  /**
+   * Returns a copy of the transform translated by the given `offset`.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding translation transform `T` from the left, i.e., `T * X`.
+   * This can be seen as transforming with respect to the global/parent frame.
+   */
+  translated(offset: Vector2 | Vector2i): Transform2D;
+  /**
+   * Returns a copy of the transform translated by the given `offset`.
+   * This method is an optimized version of multiplying the given transform `X` with a corresponding translation transform `T` from the right, i.e., `X * T`.
+   * This can be seen as transforming with respect to the local frame.
+   */
+  translated_local(offset: Vector2 | Vector2i): Transform2D;
+
+  // Operator overloads
+  [__ops_ne]: { right: Transform2D; ret: boolean };
+  [__ops_mul]: { right: PackedVector2Array; ret: PackedVector2Array } | { right: Rect2; ret: Rect2 } | { right: Transform2D; ret: Transform2D } | { right: Vector2; ret: Vector2 } | { right: float; ret: Transform2D } | { right: int; ret: Transform2D };
+  [__ops_div]: { right: float; ret: Transform2D } | { right: int; ret: Transform2D };
+  [__ops_eq]: { right: Transform2D; ret: boolean };
+
+  [__variant_converts]: Transform2D;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  clear: never;
+  duplicate: never;
+  duplicate_deep: never;
+  erase: never;
+  find_key: never;
+  get: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has: never;
+  has_all: never;
+  hash: never;
+  is_empty: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  set: never;
+  size: never;
+  sort: never;
+  values: never;
+}
+
+declare interface Transform2DConstructor {
+  readonly prototype: Transform2D;
+  /**
+   * Constructs a {@link Transform2D} identical to {@link IDENTITY}.
+   * **Note:** In C#, this constructs a {@link Transform2D} with all of its components set to {@link Vector2.ZERO}.
+   */
+  (): Transform2D;
+  /** Constructs a {@link Transform2D} as a copy of the given {@link Transform2D}. */
+  (from_: Transform2D): Transform2D;
+  /** Constructs a {@link Transform2D} from a given angle (in radians) and position. */
+  (rotation: float, position: Vector2): Transform2D;
+  /**
+   * Constructs a {@link Transform2D} from a given angle (in radians), scale, skew (in radians), and position.
+   */
+  (rotation: float, scale: Vector2, skew: float, position: Vector2): Transform2D;
+  /**
+   * Constructs a {@link Transform2D} from 3 {@link Vector2} values representing {@link x}, {@link y}, and the {@link origin} (the three matrix columns).
+   */
+  (x_axis: Vector2, y_axis: Vector2, origin: Vector2): Transform2D;
+
+  /**
+   * The identity {@link Transform2D}. This is a transform with no translation, no rotation, and a scale of {@link Vector2.ONE}. This also means that:
+   * - The {@link x} points right ({@link Vector2.RIGHT});
+   * - The {@link y} points down ({@link Vector2.DOWN}).
+   * If a {@link Vector2}, a {@link Rect2}, a {@link PackedVector2Array}, or another {@link Transform2D} is transformed (multiplied) by this constant, no transformation occurs.
+   * **Note:** In GDScript, this constant is equivalent to creating a [constructor Transform2D] without any arguments. It can be used to make your code clearer, and for consistency with C#.
+   */
+  readonly IDENTITY: Transform2D;
+  /**
+   * When any transform is multiplied by {@link FLIP_X}, it negates all components of the {@link x} axis (the X column).
+   * When {@link FLIP_X} is multiplied by any transform, it negates the {@link Vector2.x} component of all axes (the X row).
+   */
+  readonly FLIP_X: Transform2D;
+  /**
+   * When any transform is multiplied by {@link FLIP_Y}, it negates all components of the {@link y} axis (the Y column).
+   * When {@link FLIP_Y} is multiplied by any transform, it negates the {@link Vector2.y} component of all axes (the Y row).
+   */
+  readonly FLIP_Y: Transform2D;
+}
+declare const Transform2D: Transform2DConstructor;