typescript-to-gdscript 0.1.0

package/typings/classes/LookAtModifier3D.d.ts

@@ -0,0 +1,196 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** The {@link LookAtModifier3D} rotates a bone to look at a target. */
+declare class LookAtModifier3D extends SkeletonModifier3D {
+  /** Index of the {@link bone_name} in the parent {@link Skeleton3D}. */
+  bone: int;
+  /** The bone name of the {@link Skeleton3D} that the modification will operate on. */
+  bone_name: string;
+  /**
+   * The duration of the time-based interpolation. Interpolation is triggered at the following cases:
+   * - When the target node is changed
+   * - When an axis is flipped due to angle limitation
+   * **Note:** The flipping occurs when the target is outside the angle limitation and the internally computed secondary rotation axis of the forward vector is flipped. Visually, it occurs when the target is outside the angle limitation and crosses the plane of the {@link forward_axis} and {@link primary_rotation_axis}.
+   */
+  duration: float;
+  /** The ease type of the time-based interpolation. See also {@link Tween.EaseType}. */
+  ease_type: int;
+  /**
+   * The forward axis of the bone. This {@link SkeletonModifier3D} modifies the bone so that this axis points toward the {@link target_node}.
+   */
+  forward_axis: int;
+  /** Index of the {@link origin_bone_name} in the parent {@link Skeleton3D}. */
+  origin_bone: int;
+  /**
+   * If {@link origin_from} is {@link ORIGIN_FROM_SPECIFIC_BONE}, the bone global pose position specified for this is used as origin.
+   */
+  origin_bone_name: string;
+  /**
+   * If {@link origin_from} is {@link ORIGIN_FROM_EXTERNAL_NODE}, the global position of the {@link Node3D} specified for this is used as origin.
+   */
+  origin_external_node: NodePath;
+  /**
+   * This value determines from what origin is retrieved for use in the calculation of the forward vector.
+   */
+  origin_from: int;
+  /**
+   * The offset of the bone pose origin. Matching the origins by offset is useful for cases where multiple bones must always face the same direction, such as the eyes.
+   * **Note:** This value indicates the local position of the object set in {@link origin_from}.
+   */
+  origin_offset: Vector3;
+  /**
+   * If the target passes through too close to the origin than this value, time-based interpolation is used even if the target is within the angular limitations, to prevent the angular velocity from becoming too high.
+   */
+  origin_safe_margin: float;
+  /**
+   * The threshold to start damping for {@link primary_limit_angle}. It provides non-linear (b-spline) interpolation, let it feel more resistance the more it rotate to the edge limit. This is useful for simulating the limits of human motion.
+   * If `1.0`, no damping is performed. If `0.0`, damping is always performed.
+   */
+  primary_damp_threshold: float;
+  /** The limit angle of the primary rotation when {@link symmetry_limitation} is `true`, in radians. */
+  primary_limit_angle: float;
+  /** The threshold to start damping for {@link primary_negative_limit_angle}. */
+  primary_negative_damp_threshold: float;
+  /**
+   * The limit angle of negative side of the primary rotation when {@link symmetry_limitation} is `false`, in radians.
+   */
+  primary_negative_limit_angle: float;
+  /** The threshold to start damping for {@link primary_positive_limit_angle}. */
+  primary_positive_damp_threshold: float;
+  /**
+   * The limit angle of positive side of the primary rotation when {@link symmetry_limitation} is `false`, in radians.
+   */
+  primary_positive_limit_angle: float;
+  /**
+   * The axis of the first rotation. This {@link SkeletonModifier3D} works by compositing the rotation by Euler angles to prevent to rotate the {@link forward_axis}.
+   */
+  primary_rotation_axis: int;
+  /**
+   * The relative option. If `true`, the rotation is applied relative to the pose. If `false`, the rotation is applied relative to the rest. It means to replace the current pose with the {@link LookAtModifier3D}'s result.
+   * **Note:** This option affects the base angle for {@link use_angle_limitation} unlike {@link IterateIK3D}'s {@link JointLimitation3D}. Since the {@link LookAtModifier3D} relies strongly on Euler rotation, the axis that determines the limitation and the actual rotation are strongly tied together.
+   */
+  relative: boolean;
+  /** The threshold to start damping for {@link secondary_limit_angle}. */
+  secondary_damp_threshold: float;
+  /** The limit angle of the secondary rotation when {@link symmetry_limitation} is `true`, in radians. */
+  secondary_limit_angle: float;
+  /** The threshold to start damping for {@link secondary_negative_limit_angle}. */
+  secondary_negative_damp_threshold: float;
+  /**
+   * The limit angle of negative side of the secondary rotation when {@link symmetry_limitation} is `false`, in radians.
+   */
+  secondary_negative_limit_angle: float;
+  /** The threshold to start damping for {@link secondary_positive_limit_angle}. */
+  secondary_positive_damp_threshold: float;
+  /**
+   * The limit angle of positive side of the secondary rotation when {@link symmetry_limitation} is `false`, in radians.
+   */
+  secondary_positive_limit_angle: float;
+  /**
+   * If `true`, the limitations are spread from the bone symmetrically.
+   * If `false`, the limitation can be specified separately for each side of the bone rest.
+   */
+  symmetry_limitation: boolean;
+  /**
+   * The {@link NodePath} to the node that is the target for the look at modification. This node is what the modification will rotate the bone to.
+   */
+  target_node: NodePath;
+  /** The transition type of the time-based interpolation. See also {@link Tween.TransitionType}. */
+  transition_type: int;
+  /**
+   * If `true`, limits the amount of rotation. For example, this helps to prevent a character's neck from rotating 360 degrees.
+   * **Note:** As with {@link AnimationTree} blending, interpolation is provided that favors {@link Skeleton3D.get_bone_rest} or {@link Skeleton3D.get_bone_pose} depends on the {@link relative} option. This means that interpolation does not select the shortest path in some cases.
+   * **Note:** Some values for {@link transition_type} (such as {@link Tween.TRANS_BACK}, {@link Tween.TRANS_ELASTIC}, and {@link Tween.TRANS_SPRING}) may exceed the limitations. If interpolation occurs while overshooting the limitations, the result might not respect the bone rest.
+   */
+  use_angle_limitation: boolean;
+  /** If `true`, provides rotation by two axes. */
+  use_secondary_rotation: boolean;
+  set_bone(value: int): void;
+  get_bone(): int;
+  set_bone_name(value: string | NodePath): void;
+  get_bone_name(): string;
+  set_duration(value: float): void;
+  get_duration(): float;
+  set_ease_type(value: int): void;
+  get_ease_type(): int;
+  set_forward_axis(value: int): void;
+  get_forward_axis(): int;
+  set_origin_bone(value: int): void;
+  get_origin_bone(): int;
+  set_origin_bone_name(value: string | NodePath): void;
+  get_origin_bone_name(): string;
+  set_origin_external_node(value: NodePath | string): void;
+  get_origin_external_node(): NodePath;
+  set_origin_from(value: int): void;
+  get_origin_from(): int;
+  set_origin_offset(value: Vector3 | Vector3i): void;
+  get_origin_offset(): Vector3;
+  set_origin_safe_margin(value: float): void;
+  get_origin_safe_margin(): float;
+  set_primary_damp_threshold(value: float): void;
+  get_primary_damp_threshold(): float;
+  set_primary_limit_angle(value: float): void;
+  get_primary_limit_angle(): float;
+  set_primary_negative_damp_threshold(value: float): void;
+  get_primary_negative_damp_threshold(): float;
+  set_primary_negative_limit_angle(value: float): void;
+  get_primary_negative_limit_angle(): float;
+  set_primary_positive_damp_threshold(value: float): void;
+  get_primary_positive_damp_threshold(): float;
+  set_primary_positive_limit_angle(value: float): void;
+  get_primary_positive_limit_angle(): float;
+  set_primary_rotation_axis(value: int): void;
+  get_primary_rotation_axis(): int;
+  set_relative(value: boolean): void;
+  is_relative(): boolean;
+  set_secondary_damp_threshold(value: float): void;
+  get_secondary_damp_threshold(): float;
+  set_secondary_limit_angle(value: float): void;
+  get_secondary_limit_angle(): float;
+  set_secondary_negative_damp_threshold(value: float): void;
+  get_secondary_negative_damp_threshold(): float;
+  set_secondary_negative_limit_angle(value: float): void;
+  get_secondary_negative_limit_angle(): float;
+  set_secondary_positive_damp_threshold(value: float): void;
+  get_secondary_positive_damp_threshold(): float;
+  set_secondary_positive_limit_angle(value: float): void;
+  get_secondary_positive_limit_angle(): float;
+  set_symmetry_limitation(value: boolean): void;
+  is_limitation_symmetry(): boolean;
+  set_target_node(value: NodePath | string): void;
+  get_target_node(): NodePath;
+  set_transition_type(value: int): void;
+  get_transition_type(): int;
+  set_use_angle_limitation(value: boolean): void;
+  is_using_angle_limitation(): boolean;
+  set_use_secondary_rotation(value: boolean): void;
+  is_using_secondary_rotation(): boolean;
+
+  /** Returns the remaining seconds of the time-based interpolation. */
+  get_interpolation_remaining(): float;
+  /**
+   * Returns `true` if time-based interpolation is running. If `true`, it is equivalent to {@link get_interpolation_remaining} returning `0.0`.
+   * This is useful to determine whether a {@link LookAtModifier3D} can be removed safely.
+   */
+  is_interpolating(): boolean;
+  /**
+   * Returns whether the target is within the angle limitations. It is useful for unsetting the {@link target_node} when the target is outside of the angle limitations.
+   * **Note:** The value is updated after {@link SkeletonModifier3D._process_modification}. To retrieve this value correctly, we recommend using the signal {@link SkeletonModifier3D.modification_processed}.
+   */
+  is_target_within_limitation(): boolean;
+
+  // enum OriginFrom
+  /** The bone rest position of the bone specified in {@link bone} is used as origin. */
+  static readonly ORIGIN_FROM_SELF: int;
+  /**
+   * The bone global pose position of the bone specified in {@link origin_bone} is used as origin.
+   * **Note:** It is recommended that you select only the parent bone unless you are familiar with the bone processing process. The specified bone pose at the time the {@link LookAtModifier3D} is processed is used as a reference. In other words, if you specify a child bone and the {@link LookAtModifier3D} causes the child bone to move, the rendered result and direction will not match.
+   */
+  static readonly ORIGIN_FROM_SPECIFIC_BONE: int;
+  /**
+   * The global position of the {@link Node3D} specified in {@link origin_external_node} is used as origin.
+   * **Note:** Same as {@link ORIGIN_FROM_SPECIFIC_BONE}, when specifying a {@link BoneAttachment3D} with a child bone assigned, the rendered result and direction will not match.
+   */
+  static readonly ORIGIN_FROM_EXTERNAL_NODE: int;
+}

package/typings/classes/MainLoop.d.ts

@@ -0,0 +1,80 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for the game's main loop. */
+declare class MainLoop extends GodotObject {
+  /** Called before the program exits. */
+  _finalize(): void;
+  /** Called once during initialization. */
+  _initialize(): void;
+  /**
+   * Called each physics tick. `delta` is the logical time between physics ticks in seconds and is equal to {@link Engine.time_scale} / {@link Engine.physics_ticks_per_second}. Equivalent to {@link Node._physics_process}.
+   * If implemented, the method must return a boolean value. `true` ends the main loop, while `false` lets it proceed to the next step.
+   * **Note:** {@link _physics_process} may be called up to {@link Engine.max_physics_steps_per_frame} times per (idle) frame. This step limit may be reached when the engine is suffering performance issues.
+   * **Note:** Accumulated `delta` may diverge from real world seconds.
+   */
+  _physics_process(delta: float): boolean;
+  /**
+   * Called on each idle frame, prior to rendering, and after physics ticks have been processed. `delta` is the time between frames in seconds. Equivalent to {@link Node._process}.
+   * If implemented, the method must return a boolean value. `true` ends the main loop, while `false` lets it proceed to the next frame.
+   * **Note:** When the engine is struggling and the frame rate is lowered, `delta` will increase. When `delta` is increased, it's capped at a maximum of {@link Engine.time_scale} * {@link Engine.max_physics_steps_per_frame} / {@link Engine.physics_ticks_per_second}. As a result, accumulated `delta` may not represent real world time.
+   * **Note:** When `--fixed-fps` is enabled or the engine is running in Movie Maker mode (see {@link MovieWriter}), process `delta` will always be the same for every frame, regardless of how much time the frame took to render.
+   * **Note:** Frame delta may be post-processed by {@link OS.delta_smoothing} if this is enabled for the project.
+   */
+  _process(delta: float): boolean;
+
+  /** Emitted when a user responds to a permission request. */
+  on_request_permissions_result: Signal<[string, boolean]>;
+
+  /**
+   * Notification received from the OS when the application is exceeding its allocated memory.
+   * Specific to the iOS platform.
+   */
+  static readonly NOTIFICATION_OS_MEMORY_WARNING: int;
+  /**
+   * Notification received when translations may have changed. Can be triggered by the user changing the locale. Can be used to respond to language changes, for example to change the UI strings on the fly. Useful when working with the built-in translation support, like {@link Object.tr}.
+   */
+  static readonly NOTIFICATION_TRANSLATION_CHANGED: int;
+  /**
+   * Notification received from the OS when a request for "About" information is sent.
+   * Specific to the macOS platform.
+   */
+  static readonly NOTIFICATION_WM_ABOUT: int;
+  /**
+   * Notification received from Godot's crash handler when the engine is about to crash.
+   * Implemented on desktop platforms if the crash handler is enabled.
+   */
+  static readonly NOTIFICATION_CRASH: int;
+  /**
+   * Notification received from the OS when an update of the Input Method Engine occurs (e.g. change of IME cursor position or composition string).
+   * Implemented on desktop and web platforms.
+   */
+  static readonly NOTIFICATION_OS_IME_UPDATE: int;
+  /**
+   * Notification received from the OS when the application is resumed.
+   * Specific to the Android and iOS platforms.
+   */
+  static readonly NOTIFICATION_APPLICATION_RESUMED: int;
+  /**
+   * Notification received from the OS when the application is paused.
+   * Specific to the Android and iOS platforms.
+   * **Note:** On iOS, you only have approximately 5 seconds to finish a task started by this signal. If you go over this allotment, iOS will kill the app instead of pausing it.
+   */
+  static readonly NOTIFICATION_APPLICATION_PAUSED: int;
+  /**
+   * Notification received from the OS when the application is focused, i.e. when changing the focus from the OS desktop or a thirdparty application to any open window of the Godot instance.
+   * Implemented on desktop and mobile platforms.
+   */
+  static readonly NOTIFICATION_APPLICATION_FOCUS_IN: int;
+  /**
+   * Notification received from the OS when the application is defocused, i.e. when changing the focus from any open window of the Godot instance to the OS desktop or a thirdparty application.
+   * Implemented on desktop and mobile platforms.
+   */
+  static readonly NOTIFICATION_APPLICATION_FOCUS_OUT: int;
+  /** Notification received when text server is changed. */
+  static readonly NOTIFICATION_TEXT_SERVER_CHANGED: int;
+  /** Notification received when the application enters picture-in-picture mode. */
+  static readonly NOTIFICATION_APPLICATION_PIP_MODE_ENTERED: int;
+  /** Notification received when the application exits picture-in-picture mode. */
+  static readonly NOTIFICATION_APPLICATION_PIP_MODE_EXITED: int;
+}

package/typings/classes/MarginContainer.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container that keeps a margin around its child controls. */
+declare class MarginContainer extends Container {
+}

package/typings/classes/Marker2D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Generic 2D position hint for editing. */
+declare class Marker2D extends Node2D {
+  /** Size of the gizmo cross that appears in the editor. */
+  gizmo_extents: float;
+  set_gizmo_extents(value: float): void;
+  get_gizmo_extents(): float;
+}

package/typings/classes/Marker3D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Generic 3D position hint for editing. */
+declare class Marker3D extends Node3D {
+  /** Size of the gizmo cross that appears in the editor. */
+  gizmo_extents: float;
+  set_gizmo_extents(value: float): void;
+  get_gizmo_extents(): float;
+}

package/typings/classes/Marshalls.d.ts

@@ -0,0 +1,27 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Data transformation (marshaling) and encoding helpers. */
+declare interface Marshalls extends GodotObject {
+  /** Returns a decoded {@link PackedByteArray} corresponding to the Base64-encoded string `base64_str`. */
+  base64_to_raw(base64_str: string | NodePath): PackedByteArray;
+  /** Returns a decoded string corresponding to the Base64-encoded string `base64_str`. */
+  base64_to_utf8(base64_str: string | NodePath): string;
+  /**
+   * Returns a decoded {@link Variant} corresponding to the Base64-encoded string `base64_str`. 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.
+   */
+  base64_to_variant(base64_str: string | NodePath, allow_objects?: boolean): unknown;
+  /** Returns a Base64-encoded string of a given {@link PackedByteArray}. */
+  raw_to_base64(array: PackedByteArray | Array<unknown>): string;
+  /** Returns a Base64-encoded string of the UTF-8 string `utf8_str`. */
+  utf8_to_base64(utf8_str: string | NodePath): string;
+  /**
+   * Returns a Base64-encoded string of the {@link Variant} `variant`. 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.
+   */
+  variant_to_base64(variant: unknown, full_objects?: boolean): string;
+}
+declare const Marshalls: Marshalls;
+

package/typings/classes/Material.d.ts

@@ -0,0 +1,50 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Virtual base class for applying visual properties to an object, such as color and roughness. */
+declare class Material extends Resource {
+  /**
+   * Sets the {@link Material} to be used for the next pass. This renders the object again using a different material.
+   * **Note:** {@link next_pass} materials are not necessarily drawn immediately after the source {@link Material}. Draw order is determined by material properties, {@link render_priority}, and distance to camera.
+   * **Note:** This only applies to {@link StandardMaterial3D}s and {@link ShaderMaterial}s with type "Spatial".
+   */
+  next_pass: Material | null;
+  /**
+   * Sets the render priority for objects in 3D scenes. Higher priority objects will be sorted in front of lower priority objects. In other words, all objects with {@link render_priority} `1` will render on top of all objects with {@link render_priority} `0`.
+   * **Note:** This only applies to {@link StandardMaterial3D}s and {@link ShaderMaterial}s with type "Spatial".
+   * **Note:** This will not impact how transparent objects are sorted relative to opaque objects or how dynamic meshes will be sorted relative to other opaque meshes. This is because all transparent objects are drawn after all opaque objects and all dynamic opaque meshes are drawn before other opaque meshes.
+   */
+  render_priority: int;
+  set_next_pass(value: Material | null): void;
+  get_next_pass(): Material | null;
+  set_render_priority(value: int): void;
+  get_render_priority(): int;
+
+  /**
+   * Only exposed for the purpose of overriding. You cannot call this function directly. Used internally to determine if {@link next_pass} should be shown in the editor or not.
+   */
+  _can_do_next_pass(): boolean;
+  /**
+   * Only exposed for the purpose of overriding. You cannot call this function directly. Used internally to determine if {@link render_priority} should be shown in the editor or not.
+   */
+  _can_use_render_priority(): boolean;
+  /**
+   * Only exposed for the purpose of overriding. You cannot call this function directly. Used internally by various editor tools.
+   */
+  _get_shader_mode(): int;
+  /**
+   * Only exposed for the purpose of overriding. You cannot call this function directly. Used internally by various editor tools. Used to access the RID of the {@link Material}'s {@link Shader}.
+   */
+  _get_shader_rid(): RID;
+  /** Creates a placeholder version of this resource ({@link PlaceholderMaterial}). */
+  create_placeholder(): Resource;
+  /**
+   * Only available when running in the editor. Opens a popup that visualizes the generated shader code, including all variants and internal shader code. See also {@link Shader.inspect_native_shader_code}.
+   */
+  inspect_native_shader_code(): void;
+
+  /** Maximum value for the {@link render_priority} parameter. */
+  static readonly RENDER_PRIORITY_MAX: int;
+  /** Minimum value for the {@link render_priority} parameter. */
+  static readonly RENDER_PRIORITY_MIN: int;
+}

package/typings/classes/MenuBar.d.ts

@@ -0,0 +1,64 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A horizontal menu bar that creates a menu for each {@link PopupMenu} child. */
+declare class MenuBar extends Control {
+  /** Flat {@link MenuBar} don't display item decoration. */
+  flat: boolean;
+  /**
+   * <member name="language" type="String" setter="set_language" getter="get_language" default="&quot;&quot;">
+   * Language code used for line-breaking and text shaping algorithms. If left empty, the current locale is used instead.
+   */
+  focus_mode: int;
+  /**
+   * If `true`, {@link MenuBar} will use system global menu when supported.
+   * **Note:** If `true` and global menu is supported, this node is not displayed, has zero size, and all its child nodes except {@link PopupMenu}s are inaccessible.
+   * **Note:** This property overrides the value of the {@link PopupMenu.prefer_native_menu} property of the child nodes.
+   */
+  prefer_global_menu: boolean;
+  /**
+   * Position order in the global menu to insert {@link MenuBar} items at. All menu items in the {@link MenuBar} are always inserted as a continuous range. Menus with lower {@link start_index} are inserted first. Menus with {@link start_index} equal to `-1` are inserted last.
+   */
+  start_index: int;
+  /**
+   * If `true`, when the cursor hovers above menu item, it will close the current {@link PopupMenu} and open the other one.
+   */
+  switch_on_hover: boolean;
+  /** Base text writing direction. */
+  text_direction: int;
+  set_flat(value: boolean): void;
+  is_flat(): boolean;
+  set_prefer_global_menu(value: boolean): void;
+  is_prefer_global_menu(): boolean;
+  set_start_index(value: int): void;
+  get_start_index(): int;
+  set_switch_on_hover(value: boolean): void;
+  is_switch_on_hover(): boolean;
+  set_text_direction(value: int): void;
+  get_text_direction(): int;
+
+  /** Returns number of menu items. */
+  get_menu_count(): int;
+  /** Returns {@link PopupMenu} associated with menu item. */
+  get_menu_popup(menu: int): PopupMenu | null;
+  /** Returns menu item title. */
+  get_menu_title(menu: int): string;
+  /** Returns menu item tooltip. */
+  get_menu_tooltip(menu: int): string;
+  /** Returns `true` if the menu item is disabled. */
+  is_menu_disabled(menu: int): boolean;
+  /** Returns `true` if the menu item is hidden. */
+  is_menu_hidden(menu: int): boolean;
+  /** Returns `true` if the current system's global menu is supported and used by this {@link MenuBar}. */
+  is_native_menu(): boolean;
+  /** If `true`, shortcuts are disabled and cannot be used to trigger the button. */
+  set_disable_shortcuts(disabled: boolean): void;
+  /** If `true`, menu item is disabled. */
+  set_menu_disabled(menu: int, disabled: boolean): void;
+  /** If `true`, menu item is hidden. */
+  set_menu_hidden(menu: int, hidden: boolean): void;
+  /** Sets menu item title. */
+  set_menu_title(menu: int, title: string | NodePath): void;
+  /** Sets menu item tooltip. */
+  set_menu_tooltip(menu: int, tooltip: string | NodePath): void;
+}

package/typings/classes/MenuButton.d.ts

@@ -0,0 +1,35 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A button that brings up a {@link PopupMenu} when clicked. */
+declare class MenuButton extends Button {
+  /**
+   * <member name="flat" type="bool" setter="set_flat" getter="is_flat" overrides="Button" default="true" />
+   * <member name="focus_mode" type="int" setter="set_focus_mode" getter="get_focus_mode" overrides="Control" enum="Control.FocusMode" default="3" />
+   * <member name="item_count" type="int" setter="set_item_count" getter="get_item_count" default="0">
+   * The number of items currently in the list.
+   */
+  action_mode: int;
+  /**
+   * If `true`, when the cursor hovers above another {@link MenuButton} within the same parent which also has {@link switch_on_hover} enabled, it will close the current {@link MenuButton} and open the other one.
+   */
+  switch_on_hover: boolean;
+  toggle_mode: boolean;
+  set_switch_on_hover(value: boolean): void;
+  is_switch_on_hover(): boolean;
+
+  /**
+   * Returns the {@link PopupMenu} contained in this button.
+   * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link Window.visible} property.
+   */
+  get_popup(): PopupMenu;
+  /** If `true`, shortcuts are disabled and cannot be used to trigger the button. */
+  set_disable_shortcuts(disabled: boolean): void;
+  /**
+   * Adjusts popup position and sizing for the {@link MenuButton}, then shows the {@link PopupMenu}. Prefer this over using `get_popup().popup()`.
+   */
+  show_popup(): void;
+
+  /** Emitted when the {@link PopupMenu} of this MenuButton is about to show. */
+  about_to_popup: Signal<[]>;
+}