typescript-to-gdscript 0.1.0

package/typings/classes/CanvasLayer.d.ts

@@ -0,0 +1,74 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node used for independent rendering of objects within a 2D scene. */
+declare class CanvasLayer extends Node {
+  /**
+   * The custom {@link Viewport} node assigned to the {@link CanvasLayer}. If `null`, uses the default viewport instead.
+   */
+  custom_viewport: Node | null;
+  /**
+   * If enabled, the {@link CanvasLayer} maintains its position in world space. If disabled, the {@link CanvasLayer} stays in a fixed position on the screen.
+   * Together with {@link follow_viewport_scale}, this can be used for a pseudo-3D effect.
+   */
+  follow_viewport_enabled: boolean;
+  /**
+   * Scales the layer when using {@link follow_viewport_enabled}. Layers moving into the foreground should have increasing scales, while layers moving into the background should have decreasing scales.
+   */
+  follow_viewport_scale: float;
+  /**
+   * Layer index for draw order. Lower values are drawn behind higher values.
+   * **Note:** If multiple CanvasLayers have the same layer index, {@link CanvasItem} children of one CanvasLayer are drawn behind the {@link CanvasItem} children of the other CanvasLayer. Which CanvasLayer is drawn in front is non-deterministic.
+   * **Note:** The layer index should be between {@link RenderingServer.CANVAS_LAYER_MIN} and {@link RenderingServer.CANVAS_LAYER_MAX} (inclusive). Any other value will wrap around.
+   */
+  layer: int;
+  /** The layer's base offset. */
+  offset: Vector2;
+  /** The layer's rotation in radians. */
+  rotation: float;
+  /** The layer's scale. */
+  scale: Vector2;
+  /** The layer's transform. */
+  transform: Transform2D;
+  /**
+   * If `false`, any {@link CanvasItem} under this {@link CanvasLayer} will be hidden.
+   * Unlike {@link CanvasItem.visible}, visibility of a {@link CanvasLayer} isn't propagated to underlying layers.
+   */
+  visible: boolean;
+  set_custom_viewport(value: Node | null): void;
+  get_custom_viewport(): Node | null;
+  set_follow_viewport(value: boolean): void;
+  is_following_viewport(): boolean;
+  set_follow_viewport_scale(value: float): void;
+  get_follow_viewport_scale(): float;
+  set_layer(value: int): void;
+  get_layer(): int;
+  set_offset(value: Vector2 | Vector2i): void;
+  get_offset(): Vector2;
+  set_rotation(value: float): void;
+  get_rotation(): float;
+  set_scale(value: Vector2 | Vector2i): void;
+  get_scale(): Vector2;
+  set_transform(value: Transform2D): void;
+  get_transform(): Transform2D;
+  set_visible(value: boolean): void;
+  is_visible(): boolean;
+
+  /** Returns the RID of the canvas used by this layer. */
+  get_canvas(): RID;
+  /**
+   * Returns the transform from the {@link CanvasLayer}s coordinate system to the {@link Viewport}s coordinate system.
+   */
+  get_final_transform(): Transform2D;
+  /**
+   * Hides any {@link CanvasItem} under this {@link CanvasLayer}. This is equivalent to setting {@link visible} to `false`.
+   */
+  hide(): void;
+  /**
+   * Shows any {@link CanvasItem} under this {@link CanvasLayer}. This is equivalent to setting {@link visible} to `true`.
+   */
+  show(): void;
+
+  /** Emitted when visibility of the layer is changed. See {@link visible}. */
+  visibility_changed: Signal<[]>;
+}

package/typings/classes/CanvasModulate.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node that applies a color tint to a canvas. */
+declare class CanvasModulate extends Node2D {
+  /** The tint color to apply. */
+  color: Color;
+  set_color(value: Color): void;
+  get_color(): Color;
+}

package/typings/classes/CanvasTexture.d.ts

@@ -0,0 +1,42 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture with optional normal and specular maps for use in 2D rendering. */
+declare class CanvasTexture extends Texture2D {
+  /** The diffuse (color) texture to use. This is the main texture you want to set in most cases. */
+  diffuse_texture: Texture2D | null;
+  /**
+   * The normal map texture to use. Only has a visible effect if {@link Light2D}s are affecting this {@link CanvasTexture}.
+   * **Note:** Godot expects the normal map to use X+, Y+, and Z+ coordinates. See this page (http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates) for a comparison of normal map coordinates expected by popular engines.
+   */
+  normal_texture: Texture2D | null;
+  /**
+   * <member name="specular_color" type="Color" setter="set_specular_color" getter="get_specular_color" default="Color(1, 1, 1, 1)">
+   * The multiplier for specular reflection colors. The {@link Light2D}'s color is also taken into account when determining the reflection color. Only has a visible effect if {@link Light2D}s are affecting this {@link CanvasTexture}.
+   */
+  resource_local_to_scene: boolean;
+  /**
+   * The specular exponent for {@link Light2D} specular reflections. Higher values result in a more glossy/"wet" look, with reflections becoming more localized and less visible overall. The default value of `1.0` disables specular reflections entirely. Only has a visible effect if {@link Light2D}s are affecting this {@link CanvasTexture}.
+   */
+  specular_shininess: float;
+  /**
+   * The specular map to use for {@link Light2D} specular reflections. This should be a grayscale or colored texture, with brighter areas resulting in a higher {@link specular_shininess} value. Using a colored {@link specular_texture} allows controlling specular shininess on a per-channel basis. Only has a visible effect if {@link Light2D}s are affecting this {@link CanvasTexture}.
+   */
+  specular_texture: Texture2D | null;
+  /** The texture filtering mode to use when drawing this {@link CanvasTexture}. */
+  texture_filter: int;
+  /** The texture repeat mode to use when drawing this {@link CanvasTexture}. */
+  texture_repeat: int;
+  set_diffuse_texture(value: Texture2D | null): void;
+  get_diffuse_texture(): Texture2D | null;
+  set_normal_texture(value: Texture2D | null): void;
+  get_normal_texture(): Texture2D | null;
+  set_specular_shininess(value: float): void;
+  get_specular_shininess(): float;
+  set_specular_texture(value: Texture2D | null): void;
+  get_specular_texture(): Texture2D | null;
+  set_texture_filter(value: int): void;
+  get_texture_filter(): int;
+  set_texture_repeat(value: int): void;
+  get_texture_repeat(): int;
+}

package/typings/classes/CapsuleMesh.d.ts

@@ -0,0 +1,28 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Class representing a capsule-shaped {@link PrimitiveMesh}. */
+declare class CapsuleMesh extends PrimitiveMesh {
+  /**
+   * Total height of the capsule mesh (including the hemispherical ends).
+   * **Note:** The {@link height} of a capsule must be at least twice its {@link radius}. Otherwise, the capsule becomes a circle. If the {@link height} is less than twice the {@link radius}, the properties adjust to a valid value.
+   */
+  height: float;
+  /** Number of radial segments on the capsule mesh. */
+  radial_segments: int;
+  /**
+   * Radius of the capsule mesh.
+   * **Note:** The {@link radius} of a capsule cannot be greater than half of its {@link height}. Otherwise, the capsule becomes a circle. If the {@link radius} is greater than half of the {@link height}, the properties adjust to a valid value.
+   */
+  radius: float;
+  /** Number of rings along the height of the capsule. */
+  rings: int;
+  set_height(value: float): void;
+  get_height(): float;
+  set_radial_segments(value: int): void;
+  get_radial_segments(): int;
+  set_radius(value: float): void;
+  get_radius(): float;
+  set_rings(value: int): void;
+  get_rings(): int;
+}

package/typings/classes/CapsuleShape2D.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D capsule shape used for physics collision. */
+declare class CapsuleShape2D extends Shape2D {
+  /**
+   * The capsule's full height, including the semicircles.
+   * **Note:** The {@link height} of a capsule must be at least twice its {@link radius}. Otherwise, the capsule becomes a circle. If the {@link height} is less than twice the {@link radius}, the properties adjust to a valid value.
+   */
+  height: float;
+  /**
+   * The capsule's height, excluding the semicircles. This is the height of the central rectangular part in the middle of the capsule, and is the distance between the centers of the two semicircles. This is a wrapper for {@link height}.
+   */
+  mid_height: float;
+  /**
+   * The capsule's radius.
+   * **Note:** The {@link radius} of a capsule cannot be greater than half of its {@link height}. Otherwise, the capsule becomes a circle. If the {@link radius} is greater than half of the {@link height}, the properties adjust to a valid value.
+   */
+  radius: float;
+  set_height(value: float): void;
+  get_height(): float;
+  set_mid_height(value: float): void;
+  get_mid_height(): float;
+  set_radius(value: float): void;
+  get_radius(): float;
+}

package/typings/classes/CapsuleShape3D.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D capsule shape used for physics collision. */
+declare class CapsuleShape3D extends Shape3D {
+  /**
+   * The capsule's full height, including the hemispheres.
+   * **Note:** The {@link height} of a capsule must be at least twice its {@link radius}. Otherwise, the capsule becomes a sphere. If the {@link height} is less than twice the {@link radius}, the properties adjust to a valid value.
+   */
+  height: float;
+  /**
+   * The capsule's height, excluding the hemispheres. This is the height of the central cylindrical part in the middle of the capsule, and is the distance between the centers of the two hemispheres. This is a wrapper for {@link height}.
+   */
+  mid_height: float;
+  /**
+   * The capsule's radius.
+   * **Note:** The {@link radius} of a capsule cannot be greater than half of its {@link height}. Otherwise, the capsule becomes a sphere. If the {@link radius} is greater than half of the {@link height}, the properties adjust to a valid value.
+   */
+  radius: float;
+  set_height(value: float): void;
+  get_height(): float;
+  set_mid_height(value: float): void;
+  get_mid_height(): float;
+  set_radius(value: float): void;
+  get_radius(): float;
+}

package/typings/classes/CenterContainer.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container that keeps child controls in its center. */
+declare class CenterContainer extends Container {
+  /** If `true`, centers children relative to the {@link CenterContainer}'s top left corner. */
+  use_top_left: boolean;
+  set_use_top_left(value: boolean): void;
+  is_using_top_left(): boolean;
+}

package/typings/classes/ChainIK3D.d.ts

@@ -0,0 +1,50 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A {@link SkeletonModifier3D} to apply inverse kinematics to bone chains containing an arbitrary number of bones.
+ */
+declare class ChainIK3D extends IKModifier3D {
+  /** Returns the end bone index of the bone chain. */
+  get_end_bone(index: int): int;
+  /**
+   * Returns the tail direction of the end bone of the bone chain when {@link is_end_bone_extended} is `true`.
+   */
+  get_end_bone_direction(index: int): int;
+  /** Returns the end bone tail length of the bone chain when {@link is_end_bone_extended} is `true`. */
+  get_end_bone_length(index: int): float;
+  /** Returns the end bone name of the bone chain. */
+  get_end_bone_name(index: int): string;
+  /** Returns the bone index at `joint` in the bone chain's joint list. */
+  get_joint_bone(index: int, joint: int): int;
+  /** Returns the bone name at `joint` in the bone chain's joint list. */
+  get_joint_bone_name(index: int, joint: int): string;
+  /** Returns the joint count of the bone chain's joint list. */
+  get_joint_count(index: int): int;
+  /** Returns the root bone index of the bone chain. */
+  get_root_bone(index: int): int;
+  /** Returns the root bone name of the bone chain. */
+  get_root_bone_name(index: int): string;
+  /** Returns `true` if the end bone is extended to have a tail. */
+  is_end_bone_extended(index: int): boolean;
+  /** Sets the end bone index of the bone chain. */
+  set_end_bone(index: int, bone: int): void;
+  /** Sets the end bone tail direction of the bone chain when {@link is_end_bone_extended} is `true`. */
+  set_end_bone_direction(index: int, bone_direction: int): void;
+  /** Sets the end bone tail length of the bone chain when {@link is_end_bone_extended} is `true`. */
+  set_end_bone_length(index: int, length: float): void;
+  /**
+   * Sets the end bone name of the bone chain.
+   * **Note:** The end bone must be the root bone or a child of the root bone. If they are the same, the tail must be extended by {@link set_extend_end_bone} to modify the bone.
+   */
+  set_end_bone_name(index: int, bone_name: string | NodePath): void;
+  /**
+   * If `enabled` is `true`, the end bone is extended to have a tail.
+   * The extended tail config is allocated to the last element in the joint list. In other words, if you set `enabled` to `false`, the config of the last element in the joint list has no effect in the simulated result.
+   */
+  set_extend_end_bone(index: int, enabled: boolean): void;
+  /** Sets the root bone index of the bone chain. */
+  set_root_bone(index: int, bone: int): void;
+  /** Sets the root bone name of the bone chain. */
+  set_root_bone_name(index: int, bone_name: string | NodePath): void;
+}

package/typings/classes/CharFXTransform.d.ts

@@ -0,0 +1,88 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Controls how an individual character will be displayed in a {@link RichTextEffect}. */
+declare class CharFXTransform extends RefCounted {
+  /** The color the character will be drawn with. */
+  color: Color;
+  /**
+   * The time elapsed since the {@link RichTextLabel} was added to the scene tree (in seconds). Time stops when the {@link RichTextLabel} is paused (see {@link Node.process_mode}). Resets when the text in the {@link RichTextLabel} is changed.
+   * **Note:** Time still passes while the {@link RichTextLabel} is hidden.
+   */
+  elapsed_time: float;
+  /**
+   * Contains the arguments passed in the opening BBCode tag. By default, arguments are strings; if their contents match a type such as [bool], [int] or [float], they will be converted automatically. Color codes in the form `#rrggbb` or `#rgb` will be converted to an opaque {@link Color}. String arguments may not contain spaces, even if they're quoted. If present, quotes will also be present in the final string.
+   * For example, the opening BBCode tag `[example foo=hello bar=true baz=42 color=#ffffff]` will map to the following {@link Dictionary}:
+   */
+  env: Dictionary;
+  /**
+   * {@link TextServer} RID of the font used to render glyph, this value can be used with `TextServer.font_*` methods to retrieve font information.
+   * **Note:** Read-only. Setting this property won't affect drawing.
+   */
+  font: RID;
+  /**
+   * Number of glyphs in the grapheme cluster. This value is set in the first glyph of a cluster.
+   * **Note:** Read-only. Setting this property won't affect drawing.
+   */
+  glyph_count: int;
+  /**
+   * Glyph flags. See {@link TextServer.GraphemeFlag} for more info.
+   * **Note:** Read-only. Setting this property won't affect drawing.
+   */
+  glyph_flags: int;
+  /**
+   * Glyph index specific to the {@link font}. If you want to replace this glyph, use {@link TextServer.font_get_glyph_index} with {@link font} to get a new glyph index for a single character.
+   */
+  glyph_index: int;
+  /** The position offset the character will be drawn with (in pixels). */
+  offset: Vector2;
+  /**
+   * If `true`, FX transform is called for outline drawing.
+   * **Note:** Read-only. Setting this property won't affect drawing.
+   */
+  outline: boolean;
+  /**
+   * Absolute character range in the string, corresponding to the glyph.
+   * **Note:** Read-only. Setting this property won't affect drawing.
+   */
+  range: Vector2i;
+  /**
+   * The character offset of the glyph, relative to the current {@link RichTextEffect} custom block.
+   * **Note:** Read-only. Setting this property won't affect drawing.
+   */
+  relative_index: int;
+  /**
+   * The current transform of the current glyph. It can be overridden (for example, by driving the position and rotation from a curve). You can also alter the existing value to apply transforms on top of other effects.
+   */
+  transform: Transform2D;
+  /**
+   * If `true`, the character will be drawn. If `false`, the character will be hidden. Characters around hidden characters will reflow to take the space of hidden characters. If this is not desired, set their {@link color} to `Color(1, 1, 1, 0)` instead.
+   */
+  visible: boolean;
+  set_color(value: Color): void;
+  get_color(): Color;
+  set_elapsed_time(value: float): void;
+  get_elapsed_time(): float;
+  set_environment(value: Dictionary): void;
+  get_environment(): Dictionary;
+  set_font(value: RID): void;
+  get_font(): RID;
+  set_glyph_count(value: int): void;
+  get_glyph_count(): int;
+  set_glyph_flags(value: int): void;
+  get_glyph_flags(): int;
+  set_glyph_index(value: int): void;
+  get_glyph_index(): int;
+  set_offset(value: Vector2 | Vector2i): void;
+  get_offset(): Vector2;
+  set_outline(value: boolean): void;
+  is_outline(): boolean;
+  set_range(value: Vector2i | Vector2): void;
+  get_range(): Vector2i;
+  set_relative_index(value: int): void;
+  get_relative_index(): int;
+  set_transform(value: Transform2D): void;
+  get_transform(): Transform2D;
+  set_visibility(value: boolean): void;
+  is_visible(): boolean;
+}

package/typings/classes/CharacterBody2D.d.ts

@@ -0,0 +1,199 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D physics body specialized for characters moved by script. */
+declare class CharacterBody2D extends PhysicsBody2D {
+  /**
+   * If `true`, the body will be able to move on the floor only. This option avoids to be able to walk on walls, it will however allow to slide down along them.
+   */
+  floor_block_on_wall: boolean;
+  /**
+   * If `false` (by default), the body will move faster on downward slopes and slower on upward slopes.
+   * If `true`, the body will always move at the same speed on the ground no matter the slope. Note that you need to use {@link floor_snap_length} to stick along a downward slope at constant speed.
+   */
+  floor_constant_speed: boolean;
+  /**
+   * Maximum angle (in radians) where a slope is still considered a floor (or a ceiling), rather than a wall, when calling {@link move_and_slide}. The default value equals 45 degrees.
+   */
+  floor_max_angle: float;
+  /**
+   * Sets a snapping distance. When set to a value different from `0.0`, the body is kept attached to slopes when calling {@link move_and_slide}. The snapping vector is determined by the given distance along the opposite direction of the {@link up_direction}.
+   * As long as the snapping vector is in contact with the ground and the body moves against {@link up_direction}, the body will remain attached to the surface. Snapping is not applied if the body moves along {@link up_direction}, meaning it contains vertical rising velocity, so it will be able to detach from the ground when jumping or when the body is pushed up by something. If you want to apply a snap without taking into account the velocity, use {@link apply_floor_snap}.
+   */
+  floor_snap_length: float;
+  /**
+   * If `true`, the body will not slide on slopes when calling {@link move_and_slide} when the body is standing still.
+   * If `false`, the body will slide on floor's slopes when {@link velocity} applies a downward force.
+   */
+  floor_stop_on_slope: boolean;
+  /**
+   * Maximum number of times the body can change direction before it stops when calling {@link move_and_slide}. Must be greater than zero.
+   */
+  max_slides: int;
+  /** Sets the motion mode which defines the behavior of {@link move_and_slide}. */
+  motion_mode: int;
+  /**
+   * Collision layers that will be included for detecting floor bodies that will act as moving platforms to be followed by the {@link CharacterBody2D}. By default, all floor bodies are detected and propagate their velocity.
+   */
+  platform_floor_layers: int;
+  /**
+   * Sets the behavior to apply when you leave a moving platform. By default, to be physically accurate, when you leave the last platform velocity is applied.
+   */
+  platform_on_leave: int;
+  /**
+   * Collision layers that will be included for detecting wall bodies that will act as moving platforms to be followed by the {@link CharacterBody2D}. By default, all wall bodies are ignored.
+   */
+  platform_wall_layers: int;
+  /**
+   * Extra margin used for collision recovery when calling {@link move_and_slide}.
+   * If the body is at least this close to another body, it will consider them to be colliding and will be pushed away before performing the actual motion.
+   * A higher value means it's more flexible for detecting collision, which helps with consistently detecting walls and floors.
+   * A lower value forces the collision algorithm to use more exact detection, so it can be used in cases that specifically require precision, e.g at very low scale to avoid visible jittering, or for stability with a stack of character bodies.
+   */
+  safe_margin: float;
+  /**
+   * If `true`, during a jump against the ceiling, the body will slide, if `false` it will be stopped and will fall vertically.
+   */
+  slide_on_ceiling: boolean;
+  /**
+   * Vector pointing upwards, used to determine what is a wall and what is a floor (or a ceiling) when calling {@link move_and_slide}. Defaults to {@link Vector2.UP}. As the vector will be normalized it can't be equal to {@link Vector2.ZERO}, if you want all collisions to be reported as walls, consider using {@link MOTION_MODE_FLOATING} as {@link motion_mode}.
+   */
+  up_direction: Vector2;
+  /**
+   * Current velocity vector in pixels per second, used and modified during calls to {@link move_and_slide}.
+   * **Note:** A common mistake is setting this property to the desired velocity multiplied by `delta`, which produces a motion vector in pixels.
+   */
+  velocity: Vector2;
+  /**
+   * Minimum angle (in radians) where the body is allowed to slide when it encounters a wall. The default value equals 15 degrees. This property only affects movement when {@link motion_mode} is {@link MOTION_MODE_FLOATING}.
+   */
+  wall_min_slide_angle: float;
+  set_floor_block_on_wall_enabled(value: boolean): void;
+  is_floor_block_on_wall_enabled(): boolean;
+  set_floor_constant_speed_enabled(value: boolean): void;
+  is_floor_constant_speed_enabled(): boolean;
+  set_floor_max_angle(value: float): void;
+  get_floor_max_angle(): float;
+  set_floor_snap_length(value: float): void;
+  get_floor_snap_length(): float;
+  set_floor_stop_on_slope_enabled(value: boolean): void;
+  is_floor_stop_on_slope_enabled(): boolean;
+  set_max_slides(value: int): void;
+  get_max_slides(): int;
+  set_motion_mode(value: int): void;
+  get_motion_mode(): int;
+  set_platform_floor_layers(value: int): void;
+  get_platform_floor_layers(): int;
+  set_platform_on_leave(value: int): void;
+  get_platform_on_leave(): int;
+  set_platform_wall_layers(value: int): void;
+  get_platform_wall_layers(): int;
+  set_safe_margin(value: float): void;
+  get_safe_margin(): float;
+  set_slide_on_ceiling_enabled(value: boolean): void;
+  is_slide_on_ceiling_enabled(): boolean;
+  set_up_direction(value: Vector2 | Vector2i): void;
+  get_up_direction(): Vector2;
+  set_velocity(value: Vector2 | Vector2i): void;
+  get_velocity(): Vector2;
+  set_wall_min_slide_angle(value: float): void;
+  get_wall_min_slide_angle(): float;
+
+  /**
+   * Allows to manually apply a snap to the floor regardless of the body's velocity. This function does nothing when {@link is_on_floor} returns `true`.
+   */
+  apply_floor_snap(): void;
+  /**
+   * Returns the floor's collision angle at the last collision point according to `up_direction`, which is {@link Vector2.UP} by default. This value is always positive and only valid after calling {@link move_and_slide} and when {@link is_on_floor} returns `true`.
+   */
+  get_floor_angle(up_direction?: Vector2 | Vector2i): float;
+  /**
+   * Returns the collision normal of the floor at the last collision point. Only valid after calling {@link move_and_slide} and when {@link is_on_floor} returns `true`.
+   * **Warning:** The collision normal is not always the same as the surface normal.
+   */
+  get_floor_normal(): Vector2;
+  /**
+   * Returns the last motion applied to the {@link CharacterBody2D} during the last call to {@link move_and_slide}. The movement can be split into multiple motions when sliding occurs, and this method return the last one, which is useful to retrieve the current direction of the movement.
+   */
+  get_last_motion(): Vector2;
+  /**
+   * Returns a {@link KinematicCollision2D} if a collision occurred. The returned value contains information about the latest collision that occurred during the last call to {@link move_and_slide}. Returns `null` if no collision occurred. See also {@link get_slide_collision}.
+   */
+  get_last_slide_collision(): KinematicCollision2D | null;
+  /**
+   * Returns the linear velocity of the platform at the last collision point. Only valid after calling {@link move_and_slide}.
+   */
+  get_platform_velocity(): Vector2;
+  /** Returns the travel (position delta) that occurred during the last call to {@link move_and_slide}. */
+  get_position_delta(): Vector2;
+  /**
+   * Returns the current real velocity since the last call to {@link move_and_slide}. For example, when you climb a slope, you will move diagonally even though the velocity is horizontal. This method returns the diagonal movement, as opposed to {@link velocity} which returns the requested velocity.
+   */
+  get_real_velocity(): Vector2;
+  /**
+   * Returns a {@link KinematicCollision2D}, which contains information about a collision that occurred during the last call to {@link move_and_slide}. Since the body can collide several times in a single call to {@link move_and_slide}, you must specify the index of the collision in the range 0 to ({@link get_slide_collision_count} - 1). See also {@link get_last_slide_collision}.
+   * **Example:** Iterate through the collisions with a `for` loop:
+   */
+  get_slide_collision(slide_idx: int): KinematicCollision2D | null;
+  /**
+   * Returns the number of times the body collided and changed direction during the last call to {@link move_and_slide}.
+   */
+  get_slide_collision_count(): int;
+  /**
+   * Returns the collision normal of the wall at the last collision point. Only valid after calling {@link move_and_slide} and when {@link is_on_wall} returns `true`.
+   * **Warning:** The collision normal is not always the same as the surface normal.
+   */
+  get_wall_normal(): Vector2;
+  /**
+   * Returns `true` if the body collided with the ceiling on the last call of {@link move_and_slide}. Otherwise, returns `false`. The {@link up_direction} and {@link floor_max_angle} are used to determine whether a surface is "ceiling" or not.
+   */
+  is_on_ceiling(): boolean;
+  /**
+   * Returns `true` if the body collided only with the ceiling on the last call of {@link move_and_slide}. Otherwise, returns `false`. The {@link up_direction} and {@link floor_max_angle} are used to determine whether a surface is "ceiling" or not.
+   */
+  is_on_ceiling_only(): boolean;
+  /**
+   * Returns `true` if the body collided with the floor on the last call of {@link move_and_slide}. Otherwise, returns `false`. The {@link up_direction} and {@link floor_max_angle} are used to determine whether a surface is "floor" or not.
+   */
+  is_on_floor(): boolean;
+  /**
+   * Returns `true` if the body collided only with the floor on the last call of {@link move_and_slide}. Otherwise, returns `false`. The {@link up_direction} and {@link floor_max_angle} are used to determine whether a surface is "floor" or not.
+   */
+  is_on_floor_only(): boolean;
+  /**
+   * Returns `true` if the body collided with a wall on the last call of {@link move_and_slide}. Otherwise, returns `false`. The {@link up_direction} and {@link floor_max_angle} are used to determine whether a surface is "wall" or not.
+   */
+  is_on_wall(): boolean;
+  /**
+   * Returns `true` if the body collided only with a wall on the last call of {@link move_and_slide}. Otherwise, returns `false`. The {@link up_direction} and {@link floor_max_angle} are used to determine whether a surface is "wall" or not.
+   */
+  is_on_wall_only(): boolean;
+  /**
+   * Moves the body based on {@link velocity}. If the body collides with another, it will slide along the other body (by default only on floor) rather than stop immediately. If the other body is a {@link CharacterBody2D} or {@link RigidBody2D}, it will also be affected by the motion of the other body. You can use this to make moving and rotating platforms, or to make nodes push other nodes.
+   * This method should be used in {@link Node._physics_process} (or in a method called by {@link Node._physics_process}), as it uses the physics step's `delta` value automatically in calculations. Otherwise, the simulation will run at an incorrect speed.
+   * Modifies {@link velocity} if a slide collision occurred. To get the latest collision call {@link get_last_slide_collision}, for detailed information about collisions that occurred, use {@link get_slide_collision}.
+   * When the body touches a moving platform, the platform's velocity is automatically added to the body motion. If a collision occurs due to the platform's motion, it will always be first in the slide collisions.
+   * The general behavior and available properties change according to the {@link motion_mode}.
+   * Returns `true` if the body collided, otherwise, returns `false`.
+   */
+  move_and_slide(): boolean;
+
+  // enum MotionMode
+  /**
+   * Apply when notions of walls, ceiling and floor are relevant. In this mode the body motion will react to slopes (acceleration/slowdown). This mode is suitable for sided games like platformers.
+   */
+  static readonly MOTION_MODE_GROUNDED: int;
+  /**
+   * Apply when there is no notion of floor or ceiling. All collisions will be reported as `on_wall`. In this mode, when you slide, the speed will always be constant. This mode is suitable for top-down games.
+   */
+  static readonly MOTION_MODE_FLOATING: int;
+  // enum PlatformOnLeave
+  /** Add the last platform velocity to the {@link velocity} when you leave a moving platform. */
+  static readonly PLATFORM_ON_LEAVE_ADD_VELOCITY: int;
+  /**
+   * Add the last platform velocity to the {@link velocity} when you leave a moving platform, but any downward motion is ignored. It's useful to keep full jump height even when the platform is moving down.
+   */
+  static readonly PLATFORM_ON_LEAVE_ADD_UPWARD_VELOCITY: int;
+  /** Do nothing when leaving a platform. */
+  static readonly PLATFORM_ON_LEAVE_DO_NOTHING: int;
+}