godot-bevy 0.10.0

#![allow(dead_code)]
//! 🤖 This file is automatically generated by scripts/generate_godot_types.py
//! To regenerate: python scripts/generate_godot_types.py
//!
//! Signal name constants for Godot classes.
//! These provide convenient, discoverable signal names for connecting to Godot signals.
//!
//! Example usage:
//! ```ignore
//! use godot_bevy::interop::signal_names::ButtonSignals;
//! // Connect to the "pressed" signal
//! button.connect(ButtonSignals::PRESSED.into(), callable);
//! ```

/// Signal constants for `AcceptDialog`
pub struct AcceptDialogSignals;

impl AcceptDialogSignals {
    /// Emitted when the dialog is accepted, i.e. the OK button is pressed.
    pub const CONFIRMED: &'static str = "confirmed";

    /// Emitted when the dialog is closed or the button created with `add_cancel_button()` is pressed.
    pub const CANCELED: &'static str = "canceled";

    /// Emitted when a custom button with an action is pressed. See `add_button()`.
    pub const CUSTOM_ACTION: &'static str = "custom_action";
}

/// Signal constants for `AnimatedSprite2D`
pub struct AnimatedSprite2DSignals;

impl AnimatedSprite2DSignals {
    /// Emitted when `sprite_frames` changes.
    pub const SPRITE_FRAMES_CHANGED: &'static str = "sprite_frames_changed";

    /// Emitted when `animation` changes.
    pub const ANIMATION_CHANGED: &'static str = "animation_changed";

    /// Emitted when `frame` changes.
    pub const FRAME_CHANGED: &'static str = "frame_changed";

    /// Emitted when the animation loops.
    pub const ANIMATION_LOOPED: &'static str = "animation_looped";

    /// Emitted when the animation reaches the end, or the start if it is played in reverse. When the animation finishes, it pauses the playback.
    /// **Note:** This signal is not emitted if an animation is looping.
    pub const ANIMATION_FINISHED: &'static str = "animation_finished";
}

/// Signal constants for `AnimatedSprite3D`
pub struct AnimatedSprite3DSignals;

impl AnimatedSprite3DSignals {
    /// Emitted when `sprite_frames` changes.
    pub const SPRITE_FRAMES_CHANGED: &'static str = "sprite_frames_changed";

    /// Emitted when `animation` changes.
    pub const ANIMATION_CHANGED: &'static str = "animation_changed";

    /// Emitted when `frame` changes.
    pub const FRAME_CHANGED: &'static str = "frame_changed";

    /// Emitted when the animation loops.
    pub const ANIMATION_LOOPED: &'static str = "animation_looped";

    /// Emitted when the animation reaches the end, or the start if it is played in reverse. When the animation finishes, it pauses the playback.
    /// **Note:** This signal is not emitted if an animation is looping.
    pub const ANIMATION_FINISHED: &'static str = "animation_finished";
}

/// Signal constants for `AnimationLibrary`
pub struct AnimationLibrarySignals;

impl AnimationLibrarySignals {
    /// Emitted when an  is added, under the key `name`.
    pub const ANIMATION_ADDED: &'static str = "animation_added";

    /// Emitted when an  stored with the key `name` is removed.
    pub const ANIMATION_REMOVED: &'static str = "animation_removed";

    /// Emitted when the key for an  is changed, from `name` to `to_name`.
    pub const ANIMATION_RENAMED: &'static str = "animation_renamed";

    /// Emitted when there's a change in one of the animations, e.g. tracks are added, moved or have changed paths. `name` is the key of the animation that was changed.
    /// See also `Resource.changed`, which this acts as a relay for.
    pub const ANIMATION_CHANGED: &'static str = "animation_changed";
}

#[cfg(feature = "api-4-3")]
/// Signal constants for `AnimationMixer`
pub struct AnimationMixerSignals;

#[cfg(feature = "api-4-3")]
impl AnimationMixerSignals {
    /// Notifies when an animation list is changed.
    pub const ANIMATION_LIST_CHANGED: &'static str = "animation_list_changed";

    /// Notifies when the animation libraries have changed.
    pub const ANIMATION_LIBRARIES_UPDATED: &'static str = "animation_libraries_updated";

    /// Notifies when an animation finished playing.
    /// **Note:** This signal is not emitted if an animation is looping.
    pub const ANIMATION_FINISHED: &'static str = "animation_finished";

    /// Notifies when an animation starts playing.
    /// **Note:** This signal is not emitted if an animation is looping.
    pub const ANIMATION_STARTED: &'static str = "animation_started";

    /// Notifies when the caches have been cleared, either automatically, or manually via `clear_caches()`.
    pub const CACHES_CLEARED: &'static str = "caches_cleared";

    /// Notifies when the blending result related have been applied to the target objects.
    pub const MIXER_APPLIED: &'static str = "mixer_applied";

    /// Notifies when the property related process have been updated.
    pub const MIXER_UPDATED: &'static str = "mixer_updated";
}

/// Signal constants for `AnimationNode`
pub struct AnimationNodeSignals;

impl AnimationNodeSignals {
    /// Emitted by nodes that inherit from this class and that have an internal tree when one of their animation nodes changes. The animation nodes that emit this signal are , , ,  and .
    pub const TREE_CHANGED: &'static str = "tree_changed";

    /// Emitted by nodes that inherit from this class and that have an internal tree when one of their animation node names changes. The animation nodes that emit this signal are , , , and .
    pub const ANIMATION_NODE_RENAMED: &'static str = "animation_node_renamed";

    /// Emitted by nodes that inherit from this class and that have an internal tree when one of their animation nodes removes. The animation nodes that emit this signal are , , , and .
    pub const ANIMATION_NODE_REMOVED: &'static str = "animation_node_removed";
}

/// Signal constants for `AnimationNodeBlendSpace2D`
pub struct AnimationNodeBlendSpace2DSignals;

impl AnimationNodeBlendSpace2DSignals {
    /// Emitted every time the blend space's triangles are created, removed, or when one of their vertices changes position.
    pub const TRIANGLES_UPDATED: &'static str = "triangles_updated";
}

/// Signal constants for `AnimationNodeBlendTree`
pub struct AnimationNodeBlendTreeSignals;

impl AnimationNodeBlendTreeSignals {
    /// Emitted when the input port information is changed.
    pub const NODE_CHANGED: &'static str = "node_changed";
}

/// Signal constants for `AnimationNodeStateMachinePlayback`
pub struct AnimationNodeStateMachinePlaybackSignals;

impl AnimationNodeStateMachinePlaybackSignals {
    /// Emitted when the `state` starts playback. If `state` is a state machine set to grouped mode, its signals are passed through with its name prefixed.
    pub const STATE_STARTED: &'static str = "state_started";

    /// Emitted when the `state` finishes playback. If `state` is a state machine set to grouped mode, its signals are passed through with its name prefixed.
    /// If there is a crossfade, this will be fired when the influence of the `get_fading_from_node()` animation is no longer present.
    pub const STATE_FINISHED: &'static str = "state_finished";
}

/// Signal constants for `AnimationNodeStateMachineTransition`
pub struct AnimationNodeStateMachineTransitionSignals;

impl AnimationNodeStateMachineTransitionSignals {
    /// Emitted when `advance_condition` is changed.
    pub const ADVANCE_CONDITION_CHANGED: &'static str = "advance_condition_changed";
}

/// Signal constants for `AnimationPlayer`
pub struct AnimationPlayerSignals;

impl AnimationPlayerSignals {
    /// Emitted when `current_animation` changes.
    pub const CURRENT_ANIMATION_CHANGED: &'static str = "current_animation_changed";

    /// Emitted when a queued animation plays after the previous animation finished. See also `AnimationPlayer.queue()`.
    /// **Note:** The signal is not emitted when the animation is changed via `AnimationPlayer.play()` or by an .
    pub const ANIMATION_CHANGED: &'static str = "animation_changed";
}

/// Signal constants for `AnimationTree`
pub struct AnimationTreeSignals;

impl AnimationTreeSignals {
    /// Emitted when the `anim_player` is changed.
    pub const ANIMATION_PLAYER_CHANGED: &'static str = "animation_player_changed";
}

/// Signal constants for `Area2D`
pub struct Area2DSignals;

impl Area2DSignals {
    /// Emitted when a  of the received `body` enters a shape of this area. `body` can be a  or a . s are detected if their  has collision shapes configured. Requires `monitoring` to be set to `true`.
    /// `local_shape_index` and `body_shape_index` contain indices of the interacting shapes from this area and the interacting body, respectively. `body_rid` contains the  of the body. These values can be used with the .
    /// **Example:** Get the  node from the shape index:
    ///
    /// ```gdscript
    ///
    /// var body_shape_owner = body.shape_find_owner(body_shape_index)
    /// var body_shape_node = body.shape_owner_get_owner(body_shape_owner)
    ///
    /// var local_shape_owner = shape_find_owner(local_shape_index)
    /// var local_shape_node = shape_owner_get_owner(local_shape_owner)
    ///
    /// ```
    ///
    pub const BODY_SHAPE_ENTERED: &'static str = "body_shape_entered";

    /// Emitted when a  of the received `body` exits a shape of this area. `body` can be a  or a . s are detected if their  has collision shapes configured. Requires `monitoring` to be set to `true`.
    /// See also `body_shape_entered`.
    pub const BODY_SHAPE_EXITED: &'static str = "body_shape_exited";

    /// Emitted when the received `body` enters this area. `body` can be a  or a . s are detected if their  has collision shapes configured. Requires `monitoring` to be set to `true`.
    pub const BODY_ENTERED: &'static str = "body_entered";

    /// Emitted when the received `body` exits this area. `body` can be a  or a . s are detected if their  has collision shapes configured. Requires `monitoring` to be set to `true`.
    pub const BODY_EXITED: &'static str = "body_exited";

    /// Emitted when a  of the received `area` enters a shape of this area. Requires `monitoring` to be set to `true`.
    /// `local_shape_index` and `area_shape_index` contain indices of the interacting shapes from this area and the other area, respectively. `area_rid` contains the  of the other area. These values can be used with the .
    /// **Example:** Get the  node from the shape index:
    ///
    /// ```gdscript
    ///
    /// var other_shape_owner = area.shape_find_owner(area_shape_index)
    /// var other_shape_node = area.shape_owner_get_owner(other_shape_owner)
    ///
    /// var local_shape_owner = shape_find_owner(local_shape_index)
    /// var local_shape_node = shape_owner_get_owner(local_shape_owner)
    ///
    /// ```
    ///
    pub const AREA_SHAPE_ENTERED: &'static str = "area_shape_entered";

    /// Emitted when a  of the received `area` exits a shape of this area. Requires `monitoring` to be set to `true`.
    /// See also `area_shape_entered`.
    pub const AREA_SHAPE_EXITED: &'static str = "area_shape_exited";

    /// Emitted when the received `area` enters this area. Requires `monitoring` to be set to `true`.
    pub const AREA_ENTERED: &'static str = "area_entered";

    /// Emitted when the received `area` exits this area. Requires `monitoring` to be set to `true`.
    pub const AREA_EXITED: &'static str = "area_exited";
}

/// Signal constants for `Area3D`
pub struct Area3DSignals;

impl Area3DSignals {
    /// Emitted when a  of the received `body` enters a shape of this area. `body` can be a  or a . s are detected if their  has collision shapes configured. Requires `monitoring` to be set to `true`.
    /// `local_shape_index` and `body_shape_index` contain indices of the interacting shapes from this area and the interacting body, respectively. `body_rid` contains the  of the body. These values can be used with the .
    /// **Example:** Get the  node from the shape index:
    ///
    /// ```gdscript
    ///
    /// var body_shape_owner = body.shape_find_owner(body_shape_index)
    /// var body_shape_node = body.shape_owner_get_owner(body_shape_owner)
    ///
    /// var local_shape_owner = shape_find_owner(local_shape_index)
    /// var local_shape_node = shape_owner_get_owner(local_shape_owner)
    ///
    /// ```
    ///
    pub const BODY_SHAPE_ENTERED: &'static str = "body_shape_entered";

    /// Emitted when a  of the received `body` exits a shape of this area. `body` can be a  or a . s are detected if their  has collision shapes configured. Requires `monitoring` to be set to `true`.
    /// See also `body_shape_entered`.
    pub const BODY_SHAPE_EXITED: &'static str = "body_shape_exited";

    /// Emitted when the received `body` enters this area. `body` can be a  or a . s are detected if their  has collision shapes configured. Requires `monitoring` to be set to `true`.
    pub const BODY_ENTERED: &'static str = "body_entered";

    /// Emitted when the received `body` exits this area. `body` can be a  or a . s are detected if their  has collision shapes configured. Requires `monitoring` to be set to `true`.
    pub const BODY_EXITED: &'static str = "body_exited";

    /// Emitted when a  of the received `area` enters a shape of this area. Requires `monitoring` to be set to `true`.
    /// `local_shape_index` and `area_shape_index` contain indices of the interacting shapes from this area and the other area, respectively. `area_rid` contains the  of the other area. These values can be used with the .
    /// **Example:** Get the  node from the shape index:
    ///
    /// ```gdscript
    ///
    /// var other_shape_owner = area.shape_find_owner(area_shape_index)
    /// var other_shape_node = area.shape_owner_get_owner(other_shape_owner)
    ///
    /// var local_shape_owner = shape_find_owner(local_shape_index)
    /// var local_shape_node = shape_owner_get_owner(local_shape_owner)
    ///
    /// ```
    ///
    pub const AREA_SHAPE_ENTERED: &'static str = "area_shape_entered";

    /// Emitted when a  of the received `area` exits a shape of this area. Requires `monitoring` to be set to `true`.
    /// See also `area_shape_entered`.
    pub const AREA_SHAPE_EXITED: &'static str = "area_shape_exited";

    /// Emitted when the received `area` enters this area. Requires `monitoring` to be set to `true`.
    pub const AREA_ENTERED: &'static str = "area_entered";

    /// Emitted when the received `area` exits this area. Requires `monitoring` to be set to `true`.
    pub const AREA_EXITED: &'static str = "area_exited";
}

/// Signal constants for `AudioServer`
pub struct AudioServerSignals;

impl AudioServerSignals {
    /// Emitted when an audio bus is added, deleted, or moved.
    pub const BUS_LAYOUT_CHANGED: &'static str = "bus_layout_changed";

    /// Emitted when the audio bus at `bus_index` is renamed from `old_name` to `new_name`.
    pub const BUS_RENAMED: &'static str = "bus_renamed";
}

/// Signal constants for `AudioStream`
pub struct AudioStreamSignals;

impl AudioStreamSignals {
    /// Signal to be emitted to notify when the parameter list changed.
    pub const PARAMETER_LIST_CHANGED: &'static str = "parameter_list_changed";
}

/// Signal constants for `AudioStreamPlayer`
pub struct AudioStreamPlayerSignals;

impl AudioStreamPlayerSignals {
    /// Emitted when a sound finishes playing without interruptions. This signal is *not* emitted when calling `stop()`, or when exiting the tree while sounds are playing.
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `AudioStreamPlayer2D`
pub struct AudioStreamPlayer2DSignals;

impl AudioStreamPlayer2DSignals {
    /// Emitted when the audio stops playing.
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `AudioStreamPlayer3D`
pub struct AudioStreamPlayer3DSignals;

impl AudioStreamPlayer3DSignals {
    /// Emitted when the audio stops playing.
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `BaseButton`
pub struct BaseButtonSignals;

impl BaseButtonSignals {
    /// Emitted when the button is toggled or pressed. This is on `button_down` if `action_mode` is `ACTION_MODE_BUTTON_PRESS` and on `button_up` otherwise.
    /// If you need to know the button's pressed state (and `toggle_mode` is active), use `toggled` instead.
    pub const PRESSED: &'static str = "pressed";

    /// Emitted when the button stops being held down.
    pub const BUTTON_UP: &'static str = "button_up";

    /// Emitted when the button starts being held down.
    pub const BUTTON_DOWN: &'static str = "button_down";

    /// Emitted when the button was just toggled between pressed and normal states (only if `toggle_mode` is active). The new state is contained in the `toggled_on` argument.
    pub const TOGGLED: &'static str = "toggled";
}

/// Signal constants for `BoneMap`
pub struct BoneMapSignals;

impl BoneMapSignals {
    /// This signal is emitted when change the key value in the . This is used to validate mapping and to update  editor.
    pub const BONE_MAP_UPDATED: &'static str = "bone_map_updated";

    /// This signal is emitted when change the value in profile or change the reference of profile. This is used to update key names in the  and to redraw the  editor.
    pub const PROFILE_UPDATED: &'static str = "profile_updated";
}

/// Signal constants for `ButtonGroup`
pub struct ButtonGroupSignals;

impl ButtonGroupSignals {
    /// Emitted when one of the buttons of the group is pressed.
    pub const PRESSED: &'static str = "pressed";
}

/// Signal constants for `CpuParticles2D`
pub struct CpuParticles2DSignals;

impl CpuParticles2DSignals {
    /// Emitted when all active particles have finished processing. When `one_shot` is disabled, particles will process continuously, so this is never emitted.
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `CpuParticles3D`
pub struct CpuParticles3DSignals;

impl CpuParticles3DSignals {
    /// Emitted when all active particles have finished processing. When `one_shot` is disabled, particles will process continuously, so this is never emitted.
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `CameraFeed`
pub struct CameraFeedSignals;

impl CameraFeedSignals {
    /// Emitted when a new frame is available.
    pub const FRAME_CHANGED: &'static str = "frame_changed";

    /// Emitted when the format has changed.
    pub const FORMAT_CHANGED: &'static str = "format_changed";
}

/// Signal constants for `CameraServer`
pub struct CameraServerSignals;

impl CameraServerSignals {
    /// Emitted when a  is added (e.g. a webcam is plugged in).
    pub const CAMERA_FEED_ADDED: &'static str = "camera_feed_added";

    /// Emitted when a  is removed (e.g. a webcam is unplugged).
    pub const CAMERA_FEED_REMOVED: &'static str = "camera_feed_removed";

    /// Emitted when camera feeds are updated.
    pub const CAMERA_FEEDS_UPDATED: &'static str = "camera_feeds_updated";
}

/// Signal constants for `CanvasItem`
pub struct CanvasItemSignals;

impl CanvasItemSignals {
    /// Emitted when the  must redraw, *after* the related `NOTIFICATION_DRAW` notification, and *before* `_draw()` is called.
    /// **Note:** Deferred connections do not allow drawing through the `draw_*` methods.
    pub const DRAW: &'static str = "draw";

    /// Emitted when the 's visibility changes, either because its own `visible` property changed or because its visibility in the tree changed (see `is_visible_in_tree()`).
    /// This signal is emitted *after* the related `NOTIFICATION_VISIBILITY_CHANGED` notification.
    pub const VISIBILITY_CHANGED: &'static str = "visibility_changed";

    /// Emitted when this node becomes hidden, i.e. it's no longer visible in the tree (see `is_visible_in_tree()`).
    pub const HIDDEN: &'static str = "hidden";

    /// Emitted when the 's boundaries (position or size) change, or when an action took place that may have affected these boundaries (e.g. changing `Sprite2D.texture`).
    pub const ITEM_RECT_CHANGED: &'static str = "item_rect_changed";
}

/// Signal constants for `CanvasLayer`
pub struct CanvasLayerSignals;

impl CanvasLayerSignals {
    /// Emitted when visibility of the layer is changed. See `visible`.
    pub const VISIBILITY_CHANGED: &'static str = "visibility_changed";
}

/// Signal constants for `CodeEdit`
pub struct CodeEditSignals;

impl CodeEditSignals {
    /// Emitted when a breakpoint is added or removed from a line. If the line is removed via backspace, a signal is emitted at the old line.
    pub const BREAKPOINT_TOGGLED: &'static str = "breakpoint_toggled";

    /// Emitted when the user requests code completion. This signal will not be sent if `_request_code_completion()` is overridden or `code_completion_enabled` is `false`.
    pub const CODE_COMPLETION_REQUESTED: &'static str = "code_completion_requested";

    /// Emitted when the user has clicked on a valid symbol.
    pub const SYMBOL_LOOKUP: &'static str = "symbol_lookup";

    /// Emitted when the user hovers over a symbol. The symbol should be validated and responded to, by calling `set_symbol_lookup_word_as_valid()`.
    /// **Note:** `symbol_lookup_on_click` must be `true` for this signal to be emitted.
    pub const SYMBOL_VALIDATE: &'static str = "symbol_validate";

    /// Emitted when the user hovers over a symbol. Unlike `Control.mouse_entered`, this signal is not emitted immediately, but when the cursor is over the symbol for `ProjectSettings.gui/timers/tooltip_delay_sec` seconds.
    /// **Note:** `symbol_tooltip_on_hover` must be `true` for this signal to be emitted.
    pub const SYMBOL_HOVERED: &'static str = "symbol_hovered";
}

/// Signal constants for `CollisionObject2D`
pub struct CollisionObject2DSignals;

impl CollisionObject2DSignals {
    /// Emitted when an input event occurs. Requires `input_pickable` to be `true` and at least one `collision_layer` bit to be set. See `_input_event()` for details.
    pub const INPUT_EVENT: &'static str = "input_event";

    /// Emitted when the mouse pointer enters any of this object's shapes. Requires `input_pickable` to be `true` and at least one `collision_layer` bit to be set. Note that moving between different shapes within a single  won't cause this signal to be emitted.
    /// **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the 's area is small. This signal may also not be emitted if another  is overlapping the  in question.
    pub const MOUSE_ENTERED: &'static str = "mouse_entered";

    /// Emitted when the mouse pointer exits all this object's shapes. Requires `input_pickable` to be `true` and at least one `collision_layer` bit to be set. Note that moving between different shapes within a single  won't cause this signal to be emitted.
    /// **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the 's area is small. This signal may also not be emitted if another  is overlapping the  in question.
    pub const MOUSE_EXITED: &'static str = "mouse_exited";

    /// Emitted when the mouse pointer enters any of this object's shapes or moves from one shape to another. `shape_idx` is the child index of the newly entered . Requires `input_pickable` to be `true` and at least one `collision_layer` bit to be set.
    pub const MOUSE_SHAPE_ENTERED: &'static str = "mouse_shape_entered";

    /// Emitted when the mouse pointer exits any of this object's shapes. `shape_idx` is the child index of the exited . Requires `input_pickable` to be `true` and at least one `collision_layer` bit to be set.
    pub const MOUSE_SHAPE_EXITED: &'static str = "mouse_shape_exited";
}

/// Signal constants for `CollisionObject3D`
pub struct CollisionObject3DSignals;

impl CollisionObject3DSignals {
    /// Emitted when the object receives an unhandled . `event_position` is the location in world space of the mouse pointer on the surface of the shape with index `shape_idx` and `normal` is the normal vector of the surface at that point.
    pub const INPUT_EVENT: &'static str = "input_event";

    /// Emitted when the mouse pointer enters any of this object's shapes. Requires `input_ray_pickable` to be `true` and at least one `collision_layer` bit to be set.
    /// **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the 's area is small. This signal may also not be emitted if another  is overlapping the  in question.
    pub const MOUSE_ENTERED: &'static str = "mouse_entered";

    /// Emitted when the mouse pointer exits all this object's shapes. Requires `input_ray_pickable` to be `true` and at least one `collision_layer` bit to be set.
    /// **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the 's area is small. This signal may also not be emitted if another  is overlapping the  in question.
    pub const MOUSE_EXITED: &'static str = "mouse_exited";
}

/// Signal constants for `ColorPicker`
pub struct ColorPickerSignals;

impl ColorPickerSignals {
    /// Emitted when the color is changed.
    pub const COLOR_CHANGED: &'static str = "color_changed";

    /// Emitted when a preset is added.
    pub const PRESET_ADDED: &'static str = "preset_added";

    /// Emitted when a preset is removed.
    pub const PRESET_REMOVED: &'static str = "preset_removed";
}

/// Signal constants for `ColorPickerButton`
pub struct ColorPickerButtonSignals;

impl ColorPickerButtonSignals {
    /// Emitted when the color changes.
    pub const COLOR_CHANGED: &'static str = "color_changed";

    /// Emitted when the  is closed.
    pub const POPUP_CLOSED: &'static str = "popup_closed";

    /// Emitted when the  is created (the button is pressed for the first time).
    pub const PICKER_CREATED: &'static str = "picker_created";
}

/// Signal constants for `Container`
pub struct ContainerSignals;

impl ContainerSignals {
    /// Emitted when children are going to be sorted.
    pub const PRE_SORT_CHILDREN: &'static str = "pre_sort_children";

    /// Emitted when sorting the children is needed.
    pub const SORT_CHILDREN: &'static str = "sort_children";
}

/// Signal constants for `Control`
pub struct ControlSignals;

impl ControlSignals {
    /// Emitted when the control changes size.
    pub const RESIZED: &'static str = "resized";

    /// Emitted when the node receives an .
    pub const GUI_INPUT: &'static str = "gui_input";

    /// Emitted when the mouse cursor enters the control's (or any child control's) visible area, that is not occluded behind other Controls or Windows, provided its `mouse_filter` lets the event reach it and regardless if it's currently focused or not.
    /// **Note:** `CanvasItem.z_index` doesn't affect, which Control receives the signal.
    pub const MOUSE_ENTERED: &'static str = "mouse_entered";

    /// Emitted when the mouse cursor leaves the control's (and all child control's) visible area, that is not occluded behind other Controls or Windows, provided its `mouse_filter` lets the event reach it and regardless if it's currently focused or not.
    /// **Note:** `CanvasItem.z_index` doesn't affect, which Control receives the signal.
    /// **Note:** If you want to check whether the mouse truly left the area, ignoring any top nodes, you can use code like this:
    ///
    /// ```text
    /// func _on_mouse_exited():
    ///     if not Rect2(Vector2(), size).has_point(get_local_mouse_position()):
    ///         # Not hovering over area.
    /// ```
    ///
    pub const MOUSE_EXITED: &'static str = "mouse_exited";

    /// Emitted when the node gains focus.
    pub const FOCUS_ENTERED: &'static str = "focus_entered";

    /// Emitted when the node loses focus.
    pub const FOCUS_EXITED: &'static str = "focus_exited";

    /// Emitted when one of the size flags changes. See `size_flags_horizontal` and `size_flags_vertical`.
    pub const SIZE_FLAGS_CHANGED: &'static str = "size_flags_changed";

    /// Emitted when the node's minimum size changes.
    pub const MINIMUM_SIZE_CHANGED: &'static str = "minimum_size_changed";

    /// Emitted when the `NOTIFICATION_THEME_CHANGED` notification is sent.
    pub const THEME_CHANGED: &'static str = "theme_changed";
}

/// Signal constants for `Curve`
pub struct CurveSignals;

impl CurveSignals {
    /// Emitted when `max_value` or `min_value` is changed.
    pub const RANGE_CHANGED: &'static str = "range_changed";

    /// Emitted when `max_domain` or `min_domain` is changed.
    pub const DOMAIN_CHANGED: &'static str = "domain_changed";
}

/// Signal constants for `EditorDebuggerSession`
pub struct EditorDebuggerSessionSignals;

impl EditorDebuggerSessionSignals {
    /// Emitted when a remote instance is attached to this session (i.e. the session becomes active).
    pub const STARTED: &'static str = "started";

    /// Emitted when a remote instance is detached from this session (i.e. the session becomes inactive).
    pub const STOPPED: &'static str = "stopped";

    /// Emitted when the attached remote instance enters a break state. If `can_debug` is `true`, the remote instance will enter the debug loop.
    pub const BREAKED: &'static str = "breaked";

    /// Emitted when the attached remote instance exits a break state.
    pub const CONTINUED: &'static str = "continued";
}

/// Signal constants for `EditorFileDialog`
pub struct EditorFileDialogSignals;

impl EditorFileDialogSignals {
    /// Emitted when a file is selected.
    pub const FILE_SELECTED: &'static str = "file_selected";

    /// Emitted when multiple files are selected.
    pub const FILES_SELECTED: &'static str = "files_selected";

    /// Emitted when a directory is selected.
    pub const DIR_SELECTED: &'static str = "dir_selected";

    /// Emitted when the filter for file names changes.
    pub const FILENAME_FILTER_CHANGED: &'static str = "filename_filter_changed";
}

/// Signal constants for `EditorFileSystem`
pub struct EditorFileSystemSignals;

impl EditorFileSystemSignals {
    /// Emitted if the filesystem changed.
    pub const FILESYSTEM_CHANGED: &'static str = "filesystem_changed";

    /// Emitted when the list of global script classes gets updated.
    pub const SCRIPT_CLASSES_UPDATED: &'static str = "script_classes_updated";

    /// Emitted if the source of any imported file changed.
    pub const SOURCES_CHANGED: &'static str = "sources_changed";

    /// Emitted before a resource is reimported.
    pub const RESOURCES_REIMPORTING: &'static str = "resources_reimporting";

    /// Emitted if a resource is reimported.
    pub const RESOURCES_REIMPORTED: &'static str = "resources_reimported";

    /// Emitted if at least one resource is reloaded when the filesystem is scanned.
    pub const RESOURCES_RELOAD: &'static str = "resources_reload";
}

/// Signal constants for `EditorInspector`
pub struct EditorInspectorSignals;

impl EditorInspectorSignals {
    /// Emitted when a property is selected in the inspector.
    pub const PROPERTY_SELECTED: &'static str = "property_selected";

    /// Emitted when a property is keyed in the inspector. Properties can be keyed by clicking the "key" icon next to a property when the Animation panel is toggled.
    pub const PROPERTY_KEYED: &'static str = "property_keyed";

    /// Emitted when a property is removed from the inspector.
    pub const PROPERTY_DELETED: &'static str = "property_deleted";

    /// Emitted when a resource is selected in the inspector.
    pub const RESOURCE_SELECTED: &'static str = "resource_selected";

    /// Emitted when the Edit button of an  has been pressed in the inspector. This is mainly used in the remote scene tree Inspector.
    pub const OBJECT_ID_SELECTED: &'static str = "object_id_selected";

    /// Emitted when a property is edited in the inspector.
    pub const PROPERTY_EDITED: &'static str = "property_edited";

    /// Emitted when a boolean property is toggled in the inspector.
    /// **Note:** This signal is never emitted if the internal `autoclear` property enabled. Since this property is always enabled in the editor inspector, this signal is never emitted by the editor itself.
    pub const PROPERTY_TOGGLED: &'static str = "property_toggled";

    /// Emitted when the object being edited by the inspector has changed.
    pub const EDITED_OBJECT_CHANGED: &'static str = "edited_object_changed";

    /// Emitted when a property that requires a restart to be applied is edited in the inspector. This is only used in the Project Settings and Editor Settings.
    pub const RESTART_REQUESTED: &'static str = "restart_requested";
}

/// Signal constants for `EditorPlugin`
pub struct EditorPluginSignals;

impl EditorPluginSignals {
    /// Emitted when the scene is changed in the editor. The argument will return the root node of the scene that has just become active. If this scene is new and empty, the argument will be `null`.
    pub const SCENE_CHANGED: &'static str = "scene_changed";

    /// Emitted when user closes a scene. The argument is a file path to the closed scene.
    pub const SCENE_CLOSED: &'static str = "scene_closed";

    /// Emitted when user changes the workspace (**2D**, **3D**, **Script**, **Game**, **AssetLib**). Also works with custom screens defined by plugins.
    pub const MAIN_SCREEN_CHANGED: &'static str = "main_screen_changed";

    /// Emitted when the given `resource` was saved on disc. See also `scene_saved`.
    pub const RESOURCE_SAVED: &'static str = "resource_saved";

    /// Emitted when a scene was saved on disc. The argument is a file path to the saved scene. See also `resource_saved`.
    pub const SCENE_SAVED: &'static str = "scene_saved";

    /// Emitted when any project setting has changed.
    pub const PROJECT_SETTINGS_CHANGED: &'static str = "project_settings_changed";
}

/// Signal constants for `EditorProperty`
pub struct EditorPropertySignals;

impl EditorPropertySignals {
    /// Do not emit this manually, use the `emit_changed()` method instead.
    pub const PROPERTY_CHANGED: &'static str = "property_changed";

    /// Emit it if you want multiple properties modified at the same time. Do not use if added via `EditorInspectorPlugin._parse_property()`.
    pub const MULTIPLE_PROPERTIES_CHANGED: &'static str = "multiple_properties_changed";

    /// Emit it if you want to add this value as an animation key (check for keying being enabled first).
    pub const PROPERTY_KEYED: &'static str = "property_keyed";

    /// Emitted when a property was deleted. Used internally.
    pub const PROPERTY_DELETED: &'static str = "property_deleted";

    /// Emit it if you want to key a property with a single value.
    pub const PROPERTY_KEYED_WITH_VALUE: &'static str = "property_keyed_with_value";

    /// Emitted when a property was checked. Used internally.
    pub const PROPERTY_CHECKED: &'static str = "property_checked";

    /// Emitted when a setting override for the current project is requested.
    pub const PROPERTY_OVERRIDDEN: &'static str = "property_overridden";

    /// Emit it if you want to mark a property as favorited, making it appear at the top of the inspector.
    pub const PROPERTY_FAVORITED: &'static str = "property_favorited";

    /// Emit it if you want to mark (or unmark) the value of a property for being saved regardless of being equal to the default value.
    /// The default value is the one the property will get when the node is just instantiated and can come from an ancestor scene in the inheritance/instantiation chain, a script or a builtin class.
    pub const PROPERTY_PINNED: &'static str = "property_pinned";

    /// Emitted when the revertability (i.e., whether it has a non-default value and thus is displayed with a revert icon) of a property has changed.
    pub const PROPERTY_CAN_REVERT_CHANGED: &'static str = "property_can_revert_changed";

    /// If you want a sub-resource to be edited, emit this signal with the resource.
    pub const RESOURCE_SELECTED: &'static str = "resource_selected";

    /// Used by sub-inspectors. Emit it if what was selected was an Object ID.
    pub const OBJECT_ID_SELECTED: &'static str = "object_id_selected";

    /// Emitted when selected. Used internally.
    pub const SELECTED: &'static str = "selected";
}

/// Signal constants for `EditorResourcePicker`
pub struct EditorResourcePickerSignals;

impl EditorResourcePickerSignals {
    /// Emitted when the resource value was set and user clicked to edit it. When `inspect` is `true`, the signal was caused by the context menu "Edit" or "Inspect" option.
    pub const RESOURCE_SELECTED: &'static str = "resource_selected";

    /// Emitted when the value of the edited resource was changed.
    pub const RESOURCE_CHANGED: &'static str = "resource_changed";
}

/// Signal constants for `EditorResourcePreview`
pub struct EditorResourcePreviewSignals;

impl EditorResourcePreviewSignals {
    /// Emitted if a preview was invalidated (changed). `path` corresponds to the path of the preview.
    pub const PREVIEW_INVALIDATED: &'static str = "preview_invalidated";
}

/// Signal constants for `EditorSelection`
pub struct EditorSelectionSignals;

impl EditorSelectionSignals {
    /// Emitted when the selection changes.
    pub const SELECTION_CHANGED: &'static str = "selection_changed";
}

/// Signal constants for `EditorSettings`
pub struct EditorSettingsSignals;

impl EditorSettingsSignals {
    /// Emitted after any editor setting has changed.
    pub const SETTINGS_CHANGED: &'static str = "settings_changed";
}

/// Signal constants for `EditorSpinSlider`
pub struct EditorSpinSliderSignals;

impl EditorSpinSliderSignals {
    /// Emitted when the spinner/slider is grabbed.
    pub const GRABBED: &'static str = "grabbed";

    /// Emitted when the spinner/slider is ungrabbed.
    pub const UNGRABBED: &'static str = "ungrabbed";

    /// Emitted when the updown button is pressed.
    pub const UPDOWN_PRESSED: &'static str = "updown_pressed";

    /// Emitted when the value form gains focus.
    pub const VALUE_FOCUS_ENTERED: &'static str = "value_focus_entered";

    /// Emitted when the value form loses focus.
    pub const VALUE_FOCUS_EXITED: &'static str = "value_focus_exited";
}

/// Signal constants for `EditorUndoRedoManager`
pub struct EditorUndoRedoManagerSignals;

impl EditorUndoRedoManagerSignals {
    /// Emitted when the list of actions in any history has changed, either when an action is committed or a history is cleared.
    pub const HISTORY_CHANGED: &'static str = "history_changed";

    /// Emitted when the version of any history has changed as a result of undo or redo call.
    pub const VERSION_CHANGED: &'static str = "version_changed";
}

/// Signal constants for `FileDialog`
pub struct FileDialogSignals;

impl FileDialogSignals {
    /// Emitted when the user selects a file by double-clicking it or pressing the **OK** button.
    pub const FILE_SELECTED: &'static str = "file_selected";

    /// Emitted when the user selects multiple files.
    pub const FILES_SELECTED: &'static str = "files_selected";

    /// Emitted when the user selects a directory.
    pub const DIR_SELECTED: &'static str = "dir_selected";

    /// Emitted when the filter for file names changes.
    pub const FILENAME_FILTER_CHANGED: &'static str = "filename_filter_changed";
}

/// Signal constants for `FoldableContainer`
pub struct FoldableContainerSignals;

impl FoldableContainerSignals {
    /// Emitted when the container is folded/expanded.
    pub const FOLDING_CHANGED: &'static str = "folding_changed";
}

/// Signal constants for `FoldableGroup`
pub struct FoldableGroupSignals;

impl FoldableGroupSignals {
    /// Emitted when one of the containers of the group is expanded.
    pub const EXPANDED: &'static str = "expanded";
}

/// Signal constants for `GDExtensionManager`
pub struct GDExtensionManagerSignals;

impl GDExtensionManagerSignals {
    /// Emitted after the editor has finished reloading one or more extensions.
    pub const EXTENSIONS_RELOADED: &'static str = "extensions_reloaded";

    /// Emitted after the editor has finished loading a new extension.
    /// **Note:** This signal is only emitted in editor builds.
    pub const EXTENSION_LOADED: &'static str = "extension_loaded";

    /// Emitted before the editor starts unloading an extension.
    /// **Note:** This signal is only emitted in editor builds.
    pub const EXTENSION_UNLOADING: &'static str = "extension_unloading";
}

/// Signal constants for `GpuParticles2D`
pub struct GpuParticles2DSignals;

impl GpuParticles2DSignals {
    /// Emitted when all active particles have finished processing. To immediately restart the emission cycle, call `restart()`.
    /// This signal is never emitted when `one_shot` is disabled, as particles will be emitted and processed continuously.
    /// **Note:** For `one_shot` emitters, due to the particles being computed on the GPU, there may be a short period after receiving the signal during which setting `emitting` to `true` will not restart the emission cycle. This delay is avoided by instead calling `restart()`.
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `GpuParticles3D`
pub struct GpuParticles3DSignals;

impl GpuParticles3DSignals {
    /// Emitted when all active particles have finished processing. To immediately restart the emission cycle, call `restart()`.
    /// This signal is never emitted when `one_shot` is disabled, as particles will be emitted and processed continuously.
    /// **Note:** For `one_shot` emitters, due to the particles being computed on the GPU, there may be a short period after receiving the signal during which setting `emitting` to `true` will not restart the emission cycle. This delay is avoided by instead calling `restart()`.
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `GridMap`
pub struct GridMapSignals;

impl GridMapSignals {
    /// Emitted when `cell_size` changes.
    pub const CELL_SIZE_CHANGED: &'static str = "cell_size_changed";

    /// Emitted when the  of this GridMap changes.
    pub const CHANGED: &'static str = "changed";
}

/// Signal constants for `HttpRequest`
pub struct HttpRequestSignals;

impl HttpRequestSignals {
    /// Emitted when a request is completed.
    pub const REQUEST_COMPLETED: &'static str = "request_completed";
}

/// Signal constants for `Input`
pub struct InputSignals;

impl InputSignals {
    /// Emitted when a joypad device has been connected or disconnected.
    pub const JOY_CONNECTION_CHANGED: &'static str = "joy_connection_changed";
}

/// Signal constants for `ItemList`
pub struct ItemListSignals;

impl ItemListSignals {
    /// Emitted when specified item has been selected. Only applicable in single selection mode.
    /// `allow_reselect` must be enabled to reselect an item.
    pub const ITEM_SELECTED: &'static str = "item_selected";

    /// Emitted when any mouse click is issued within the rect of the list but on empty space.
    /// `at_position` is the click position in this control's local coordinate system.
    pub const EMPTY_CLICKED: &'static str = "empty_clicked";

    /// Emitted when specified list item has been clicked with any mouse button.
    /// `at_position` is the click position in this control's local coordinate system.
    pub const ITEM_CLICKED: &'static str = "item_clicked";

    /// Emitted when a multiple selection is altered on a list allowing multiple selection.
    pub const MULTI_SELECTED: &'static str = "multi_selected";

    /// Emitted when specified list item is activated via double-clicking or by pressing Enter.
    pub const ITEM_ACTIVATED: &'static str = "item_activated";
}

/// Signal constants for `JavaScriptBridge`
pub struct JavaScriptBridgeSignals;

impl JavaScriptBridgeSignals {
    /// Emitted when an update for this progressive web app has been detected but is waiting to be activated because a previous version is active. See `pwa_update()` to force the update to take place immediately.
    pub const PWA_UPDATE_AVAILABLE: &'static str = "pwa_update_available";
}

/// Signal constants for `LineEdit`
pub struct LineEditSignals;

impl LineEditSignals {
    /// Emitted when the text changes.
    pub const TEXT_CHANGED: &'static str = "text_changed";

    /// Emitted when appending text that overflows the `max_length`. The appended text is truncated to fit `max_length`, and the part that couldn't fit is passed as the `rejected_substring` argument.
    pub const TEXT_CHANGE_REJECTED: &'static str = "text_change_rejected";

    /// Emitted when the user presses the `ui_text_submit` action (by default: Enter or Kp Enter) while the  has focus.
    pub const TEXT_SUBMITTED: &'static str = "text_submitted";

    /// Emitted when the  switches in or out of edit mode.
    pub const EDITING_TOGGLED: &'static str = "editing_toggled";
}

/// Signal constants for `MainLoop`
pub struct MainLoopSignals;

impl MainLoopSignals {
    /// Emitted when a user responds to a permission request.
    pub const ON_REQUEST_PERMISSIONS_RESULT: &'static str = "on_request_permissions_result";
}

/// Signal constants for `MenuButton`
pub struct MenuButtonSignals;

impl MenuButtonSignals {
    /// Emitted when the  of this MenuButton is about to show.
    pub const ABOUT_TO_POPUP: &'static str = "about_to_popup";
}

/// Signal constants for `MeshInstance2D`
pub struct MeshInstance2DSignals;

impl MeshInstance2DSignals {
    /// Emitted when the `texture` is changed.
    pub const TEXTURE_CHANGED: &'static str = "texture_changed";
}

/// Signal constants for `MultiMeshInstance2D`
pub struct MultiMeshInstance2DSignals;

impl MultiMeshInstance2DSignals {
    /// Emitted when the `texture` is changed.
    pub const TEXTURE_CHANGED: &'static str = "texture_changed";
}

/// Signal constants for `MultiplayerAPI`
pub struct MultiplayerAPISignals;

impl MultiplayerAPISignals {
    /// Emitted when this MultiplayerAPI's `multiplayer_peer` connects with a new peer. ID is the peer ID of the new peer. Clients get notified when other clients connect to the same server. Upon connecting to a server, a client also receives this signal for the server (with ID being 1).
    pub const PEER_CONNECTED: &'static str = "peer_connected";

    /// Emitted when this MultiplayerAPI's `multiplayer_peer` disconnects from a peer. Clients get notified when other clients disconnect from the same server.
    pub const PEER_DISCONNECTED: &'static str = "peer_disconnected";

    /// Emitted when this MultiplayerAPI's `multiplayer_peer` successfully connected to a server. Only emitted on clients.
    pub const CONNECTED_TO_SERVER: &'static str = "connected_to_server";

    /// Emitted when this MultiplayerAPI's `multiplayer_peer` fails to establish a connection to a server. Only emitted on clients.
    pub const CONNECTION_FAILED: &'static str = "connection_failed";

    /// Emitted when this MultiplayerAPI's `multiplayer_peer` disconnects from server. Only emitted on clients.
    pub const SERVER_DISCONNECTED: &'static str = "server_disconnected";
}

/// Signal constants for `MultiplayerPeer`
pub struct MultiplayerPeerSignals;

impl MultiplayerPeerSignals {
    /// Emitted when a remote peer connects.
    pub const PEER_CONNECTED: &'static str = "peer_connected";

    /// Emitted when a remote peer has disconnected.
    pub const PEER_DISCONNECTED: &'static str = "peer_disconnected";
}

/// Signal constants for `MultiplayerSpawner`
pub struct MultiplayerSpawnerSignals;

impl MultiplayerSpawnerSignals {
    /// Emitted when a spawnable scene or custom spawn was despawned by the multiplayer authority. Only called on remote peers.
    pub const DESPAWNED: &'static str = "despawned";

    /// Emitted when a spawnable scene or custom spawn was spawned by the multiplayer authority. Only called on remote peers.
    pub const SPAWNED: &'static str = "spawned";
}

/// Signal constants for `MultiplayerSynchronizer`
pub struct MultiplayerSynchronizerSignals;

impl MultiplayerSynchronizerSignals {
    /// Emitted when a new synchronization state is received by this synchronizer after the properties have been updated.
    pub const SYNCHRONIZED: &'static str = "synchronized";

    /// Emitted when a new delta synchronization state is received by this synchronizer after the properties have been updated.
    pub const DELTA_SYNCHRONIZED: &'static str = "delta_synchronized";

    /// Emitted when visibility of `for_peer` is updated. See `update_visibility()`.
    pub const VISIBILITY_CHANGED: &'static str = "visibility_changed";
}

/// Signal constants for `NavigationServer2D`
pub struct NavigationServer2DSignals;

impl NavigationServer2DSignals {
    /// Emitted when a navigation map is updated, when a region moves or is modified.
    pub const MAP_CHANGED: &'static str = "map_changed";

    /// Emitted when navigation debug settings are changed. Only available in debug builds.
    pub const NAVIGATION_DEBUG_CHANGED: &'static str = "navigation_debug_changed";

    /// Emitted when avoidance debug settings are changed. Only available in debug builds.
    pub const AVOIDANCE_DEBUG_CHANGED: &'static str = "avoidance_debug_changed";
}

/// Signal constants for `NavigationServer3D`
pub struct NavigationServer3DSignals;

impl NavigationServer3DSignals {
    /// Emitted when a navigation map is updated, when a region moves or is modified.
    pub const MAP_CHANGED: &'static str = "map_changed";

    /// Emitted when navigation debug settings are changed. Only available in debug builds.
    pub const NAVIGATION_DEBUG_CHANGED: &'static str = "navigation_debug_changed";

    /// Emitted when avoidance debug settings are changed. Only available in debug builds.
    pub const AVOIDANCE_DEBUG_CHANGED: &'static str = "avoidance_debug_changed";
}

/// Signal constants for `NinePatchRect`
pub struct NinePatchRectSignals;

impl NinePatchRectSignals {
    /// Emitted when the node's texture changes.
    pub const TEXTURE_CHANGED: &'static str = "texture_changed";
}

/// Signal constants for `Node`
pub struct NodeSignals;

impl NodeSignals {
    /// Emitted when the node is considered ready, after `_ready()` is called.
    pub const READY: &'static str = "ready";

    /// Emitted when the node's `name` is changed, if the node is inside the tree.
    pub const RENAMED: &'static str = "renamed";

    /// Emitted when the node enters the tree.
    /// This signal is emitted *after* the related `NOTIFICATION_ENTER_TREE` notification.
    pub const TREE_ENTERED: &'static str = "tree_entered";

    /// Emitted when the node is just about to exit the tree. The node is still valid. As such, this is the right place for de-initialization (or a "destructor", if you will).
    /// This signal is emitted *after* the node's `_exit_tree()`, and *before* the related `NOTIFICATION_EXIT_TREE`.
    pub const TREE_EXITING: &'static str = "tree_exiting";

    /// Emitted after the node exits the tree and is no longer active.
    /// This signal is emitted *after* the related `NOTIFICATION_EXIT_TREE` notification.
    pub const TREE_EXITED: &'static str = "tree_exited";

    /// Emitted when the child `node` enters the , usually because this node entered the tree (see `tree_entered`), or `add_child()` has been called.
    /// This signal is emitted *after* the child node's own `NOTIFICATION_ENTER_TREE` and `tree_entered`.
    pub const CHILD_ENTERED_TREE: &'static str = "child_entered_tree";

    /// Emitted when the child `node` is about to exit the , usually because this node is exiting the tree (see `tree_exiting`), or because the child `node` is being removed or freed.
    /// When this signal is received, the child `node` is still accessible inside the tree. This signal is emitted *after* the child node's own `tree_exiting` and `NOTIFICATION_EXIT_TREE`.
    pub const CHILD_EXITING_TREE: &'static str = "child_exiting_tree";

    /// Emitted when the list of children is changed. This happens when child nodes are added, moved or removed.
    pub const CHILD_ORDER_CHANGED: &'static str = "child_order_changed";

    /// Emitted when this node is being replaced by the `node`, see `replace_by()`.
    /// This signal is emitted *after* `node` has been added as a child of the original parent node, but *before* all original child nodes have been reparented to `node`.
    pub const REPLACING_BY: &'static str = "replacing_by";

    /// Emitted when the node's editor description field changed.
    pub const EDITOR_DESCRIPTION_CHANGED: &'static str = "editor_description_changed";

    /// Emitted when an attribute of the node that is relevant to the editor is changed. Only emitted in the editor.
    pub const EDITOR_STATE_CHANGED: &'static str = "editor_state_changed";
}

/// Signal constants for `Node3D`
pub struct Node3DSignals;

impl Node3DSignals {
    /// Emitted when this node's visibility changes (see `visible` and `is_visible_in_tree()`).
    /// This signal is emitted *after* the related `NOTIFICATION_VISIBILITY_CHANGED` notification.
    pub const VISIBILITY_CHANGED: &'static str = "visibility_changed";
}

/// Signal constants for `Object`
pub struct ObjectSignals;

impl ObjectSignals {
    /// Emitted when the object's script is changed.
    /// **Note:** When this signal is emitted, the new script is not initialized yet. If you need to access the new script, defer connections to this signal with `CONNECT_DEFERRED`.
    pub const SCRIPT_CHANGED: &'static str = "script_changed";

    /// Emitted when `notify_property_list_changed()` is called.
    pub const PROPERTY_LIST_CHANGED: &'static str = "property_list_changed";
}

/// Signal constants for `OpenXRFutureResult`
pub struct OpenXRFutureResultSignals;

impl OpenXRFutureResultSignals {
    /// Emitted when the asynchronous function is finished or has been cancelled.
    pub const COMPLETED: &'static str = "completed";
}

/// Signal constants for `OpenXRInterface`
pub struct OpenXRInterfaceSignals;

impl OpenXRInterfaceSignals {
    /// Informs our OpenXR session has been started.
    pub const SESSION_BEGUN: &'static str = "session_begun";

    /// Informs our OpenXR session is stopping.
    pub const SESSION_STOPPING: &'static str = "session_stopping";

    /// Informs our OpenXR session has been synchronized.
    pub const SESSION_SYNCHRONIZED: &'static str = "session_synchronized";

    /// Informs our OpenXR session now has focus, for example output is sent to the HMD and we're receiving XR input.
    pub const SESSION_FOCUSSED: &'static str = "session_focussed";

    /// Informs our OpenXR session is now visible, for example output is sent to the HMD but we don't receive XR input.
    pub const SESSION_VISIBLE: &'static str = "session_visible";

    /// Informs our OpenXR session is in the process of being lost.
    pub const SESSION_LOSS_PENDING: &'static str = "session_loss_pending";

    /// Informs our OpenXR instance is exiting.
    pub const INSTANCE_EXITING: &'static str = "instance_exiting";

    /// Informs the user queued a recenter of the player position.
    pub const POSE_RECENTERED: &'static str = "pose_recentered";

    /// Informs the user the HMD refresh rate has changed.
    /// **Note:** Only emitted if XR runtime supports the refresh rate extension.
    pub const REFRESH_RATE_CHANGED: &'static str = "refresh_rate_changed";

    /// Informs the device CPU performance level has changed in the specified subdomain.
    pub const CPU_LEVEL_CHANGED: &'static str = "cpu_level_changed";

    /// Informs the device GPU performance level has changed in the specified subdomain.
    pub const GPU_LEVEL_CHANGED: &'static str = "gpu_level_changed";
}

#[cfg(not(feature = "experimental-wasm"))]
/// Signal constants for `OpenXrRenderModel`
pub struct OpenXrRenderModelSignals;

#[cfg(not(feature = "experimental-wasm"))]
impl OpenXrRenderModelSignals {
    /// Emitted when the top level path of this render model has changed.
    pub const RENDER_MODEL_TOP_LEVEL_PATH_CHANGED: &'static str =
        "render_model_top_level_path_changed";
}

/// Signal constants for `OpenXRRenderModelExtension`
pub struct OpenXRRenderModelExtensionSignals;

impl OpenXRRenderModelExtensionSignals {
    /// Emitted when a new render model is added.
    pub const RENDER_MODEL_ADDED: &'static str = "render_model_added";

    /// Emitted when a render model is removed.
    pub const RENDER_MODEL_REMOVED: &'static str = "render_model_removed";

    /// Emitted when the top level path associated with a render model changed.
    pub const RENDER_MODEL_TOP_LEVEL_PATH_CHANGED: &'static str =
        "render_model_top_level_path_changed";
}

#[cfg(not(feature = "experimental-wasm"))]
/// Signal constants for `OpenXrRenderModelManager`
pub struct OpenXrRenderModelManagerSignals;

#[cfg(not(feature = "experimental-wasm"))]
impl OpenXrRenderModelManagerSignals {
    /// Emitted when a render model node is added as a child to this node.
    pub const RENDER_MODEL_ADDED: &'static str = "render_model_added";

    /// Emitted when a render model child node is about to be removed from this node.
    pub const RENDER_MODEL_REMOVED: &'static str = "render_model_removed";
}

/// Signal constants for `OptionButton`
pub struct OptionButtonSignals;

impl OptionButtonSignals {
    /// Emitted when the current item has been changed by the user. The index of the item selected is passed as argument.
    /// `allow_reselect` must be enabled to reselect an item.
    pub const ITEM_SELECTED: &'static str = "item_selected";

    /// Emitted when the user navigates to an item using the `ProjectSettings.input/ui_up` or `ProjectSettings.input/ui_down` input actions. The index of the item selected is passed as argument.
    pub const ITEM_FOCUSED: &'static str = "item_focused";
}

/// Signal constants for `ParticleProcessMaterial`
pub struct ParticleProcessMaterialSignals;

impl ParticleProcessMaterialSignals {
    /// Emitted when this material's emission shape is changed in any way. This includes changes to `emission_shape`, `emission_shape_scale`, or `emission_sphere_radius`, and any other property that affects the emission shape's offset, size, scale, or orientation.
    /// **Note:** This signal is only emitted inside the editor for performance reasons.
    pub const EMISSION_SHAPE_CHANGED: &'static str = "emission_shape_changed";
}

/// Signal constants for `Path3D`
pub struct Path3DSignals;

impl Path3DSignals {
    /// Emitted when the `curve` changes.
    pub const CURVE_CHANGED: &'static str = "curve_changed";

    /// Emitted when the `debug_custom_color` changes.
    pub const DEBUG_COLOR_CHANGED: &'static str = "debug_color_changed";
}

/// Signal constants for `Popup`
pub struct PopupSignals;

impl PopupSignals {
    /// Emitted when the popup is hidden.
    pub const POPUP_HIDE: &'static str = "popup_hide";
}

/// Signal constants for `PopupMenu`
pub struct PopupMenuSignals;

impl PopupMenuSignals {
    /// Emitted when an item of some `id` is pressed or its accelerator is activated.
    /// **Note:** If `id` is negative (either explicitly or due to overflow), this will return the corresponding index instead.
    pub const ID_PRESSED: &'static str = "id_pressed";

    /// Emitted when the user navigated to an item of some `id` using the `ProjectSettings.input/ui_up` or `ProjectSettings.input/ui_down` input action.
    pub const ID_FOCUSED: &'static str = "id_focused";

    /// Emitted when an item of some `index` is pressed or its accelerator is activated.
    pub const INDEX_PRESSED: &'static str = "index_pressed";

    /// Emitted when any item is added, modified or removed.
    pub const MENU_CHANGED: &'static str = "menu_changed";
}

/// Signal constants for `ProjectSettings`
pub struct ProjectSettingsSignals;

impl ProjectSettingsSignals {
    /// Emitted when any setting is changed, up to once per process frame.
    pub const SETTINGS_CHANGED: &'static str = "settings_changed";
}

/// Signal constants for `Range`
pub struct RangeSignals;

impl RangeSignals {
    /// Emitted when `value` changes. When used on a , this is called continuously while dragging (potentially every frame). If you are performing an expensive operation in a function connected to `value_changed`, consider using a *debouncing*  to call the function less often.
    /// **Note:** Unlike signals such as `LineEdit.text_changed`, `value_changed` is also emitted when `value` is set directly via code.
    pub const VALUE_CHANGED: &'static str = "value_changed";

    /// Emitted when `min_value`, `max_value`, `page`, or `step` change.
    pub const CHANGED: &'static str = "changed";
}

/// Signal constants for `RenderingServer`
pub struct RenderingServerSignals;

impl RenderingServerSignals {
    /// Emitted at the beginning of the frame, before the RenderingServer updates all the Viewports.
    pub const FRAME_PRE_DRAW: &'static str = "frame_pre_draw";

    /// Emitted at the end of the frame, after the RenderingServer has finished updating all the Viewports.
    pub const FRAME_POST_DRAW: &'static str = "frame_post_draw";
}

/// Signal constants for `Resource`
pub struct ResourceSignals;

impl ResourceSignals {
    /// Emitted when the resource changes, usually when one of its properties is modified. See also `emit_changed()`.
    /// **Note:** This signal is not emitted automatically for properties of custom resources. If necessary, a setter needs to be created to emit the signal.
    pub const CHANGED: &'static str = "changed";

    /// Emitted by a newly duplicated resource with `resource_local_to_scene` set to `true`.
    pub const SETUP_LOCAL_TO_SCENE_REQUESTED: &'static str = "setup_local_to_scene_requested";
}

/// Signal constants for `RichTextLabel`
pub struct RichTextLabelSignals;

impl RichTextLabelSignals {
    /// Triggered when the user clicks on content between meta (URL) tags. If the meta is defined in BBCode, e.g. [code skip-lint]({"key": "value"})`, then the parameter for this signal will always be a  type. If a particular type or an object is desired, the `push_meta()` method must be used to manually insert the data into the tag stack. Alternatively, you can convert the  input to the desired type based on its contents (such as calling `JSON.parse()` on it).
    /// For example, the following method can be connected to `meta_clicked` to open clicked URLs using the user's default web browser:
    ///
    /// ```gdscript
    ///
    /// # This assumes RichTextLabel's `meta_clicked` signal was connected to
    /// # the function below using the signal connection dialog.
    /// func _richtextlabel_on_meta_clicked(meta):
    ///     # `meta` is of Variant type, so convert it to a String to avoid script errors at run-time.
    ///     OS.shell_open(str(meta))
    ///
    /// ```
    /// `
    pub const META_CLICKED: &'static str = "meta_clicked";

    /// Triggers when the mouse enters a meta tag.
    pub const META_HOVER_STARTED: &'static str = "meta_hover_started";

    /// Triggers when the mouse exits a meta tag.
    pub const META_HOVER_ENDED: &'static str = "meta_hover_ended";

    /// Triggered when the document is fully loaded.
    /// **Note:** This can happen before the text is processed for drawing. Scrolling values may not be valid until the document is drawn for the first time after this signal.
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `RigidBody2D`
pub struct RigidBody2DSignals;

impl RigidBody2DSignals {
    /// Emitted when one of this RigidBody2D's s collides with another  or 's s. Requires `contact_monitor` to be set to `true` and `max_contacts_reported` to be set high enough to detect all the collisions. s are detected if the  has Collision s.
    /// `body_rid` the  of the other  or 's  used by the .
    /// `body` the , if it exists in the tree, of the other  or .
    /// `body_shape_index` the index of the  of the other  or  used by the . Get the  node with `body.shape_owner_get_owner(body.shape_find_owner(body_shape_index))`.
    /// `local_shape_index` the index of the  of this RigidBody2D used by the . Get the  node with `self.shape_owner_get_owner(self.shape_find_owner(local_shape_index))`.
    pub const BODY_SHAPE_ENTERED: &'static str = "body_shape_entered";

    /// Emitted when the collision between one of this RigidBody2D's s and another  or 's s ends. Requires `contact_monitor` to be set to `true` and `max_contacts_reported` to be set high enough to detect all the collisions. s are detected if the  has Collision s.
    /// `body_rid` the  of the other  or 's  used by the .
    /// `body` the , if it exists in the tree, of the other  or .
    /// `body_shape_index` the index of the  of the other  or  used by the . Get the  node with `body.shape_owner_get_owner(body.shape_find_owner(body_shape_index))`.
    /// `local_shape_index` the index of the  of this RigidBody2D used by the . Get the  node with `self.shape_owner_get_owner(self.shape_find_owner(local_shape_index))`.
    pub const BODY_SHAPE_EXITED: &'static str = "body_shape_exited";

    /// Emitted when a collision with another  or  occurs. Requires `contact_monitor` to be set to `true` and `max_contacts_reported` to be set high enough to detect all the collisions. s are detected if the  has Collision s.
    /// `body` the , if it exists in the tree, of the other  or .
    pub const BODY_ENTERED: &'static str = "body_entered";

    /// Emitted when the collision with another  or  ends. Requires `contact_monitor` to be set to `true` and `max_contacts_reported` to be set high enough to detect all the collisions. s are detected if the  has Collision s.
    /// `body` the , if it exists in the tree, of the other  or .
    pub const BODY_EXITED: &'static str = "body_exited";

    /// Emitted when the physics engine changes the body's sleeping state.
    /// **Note:** Changing the value `sleeping` will not trigger this signal. It is only emitted if the sleeping state is changed by the physics engine or `emit_signal("sleeping_state_changed")` is used.
    pub const SLEEPING_STATE_CHANGED: &'static str = "sleeping_state_changed";
}

/// Signal constants for `RigidBody3D`
pub struct RigidBody3DSignals;

impl RigidBody3DSignals {
    /// Emitted when one of this RigidBody3D's s collides with another  or 's s. Requires `contact_monitor` to be set to `true` and `max_contacts_reported` to be set high enough to detect all the collisions. s are detected if the  has Collision s.
    /// `body_rid` the  of the other  or 's  used by the .
    /// `body` the , if it exists in the tree, of the other  or .
    /// `body_shape_index` the index of the  of the other  or  used by the . Get the  node with `body.shape_owner_get_owner(body.shape_find_owner(body_shape_index))`.
    /// `local_shape_index` the index of the  of this RigidBody3D used by the . Get the  node with `self.shape_owner_get_owner(self.shape_find_owner(local_shape_index))`.
    pub const BODY_SHAPE_ENTERED: &'static str = "body_shape_entered";

    /// Emitted when the collision between one of this RigidBody3D's s and another  or 's s ends. Requires `contact_monitor` to be set to `true` and `max_contacts_reported` to be set high enough to detect all the collisions. s are detected if the  has Collision s.
    /// `body_rid` the  of the other  or 's  used by the . s are detected if the Meshes have s.
    /// `body` the , if it exists in the tree, of the other  or .
    /// `body_shape_index` the index of the  of the other  or  used by the . Get the  node with `body.shape_owner_get_owner(body.shape_find_owner(body_shape_index))`.
    /// `local_shape_index` the index of the  of this RigidBody3D used by the . Get the  node with `self.shape_owner_get_owner(self.shape_find_owner(local_shape_index))`.
    pub const BODY_SHAPE_EXITED: &'static str = "body_shape_exited";

    /// Emitted when a collision with another  or  occurs. Requires `contact_monitor` to be set to `true` and `max_contacts_reported` to be set high enough to detect all the collisions. s are detected if the  has Collision s.
    /// `body` the , if it exists in the tree, of the other  or .
    pub const BODY_ENTERED: &'static str = "body_entered";

    /// Emitted when the collision with another  or  ends. Requires `contact_monitor` to be set to `true` and `max_contacts_reported` to be set high enough to detect all the collisions. s are detected if the  has Collision s.
    /// `body` the , if it exists in the tree, of the other  or .
    pub const BODY_EXITED: &'static str = "body_exited";

    /// Emitted when the physics engine changes the body's sleeping state.
    /// **Note:** Changing the value `sleeping` will not trigger this signal. It is only emitted if the sleeping state is changed by the physics engine or `emit_signal("sleeping_state_changed")` is used.
    pub const SLEEPING_STATE_CHANGED: &'static str = "sleeping_state_changed";
}

/// Signal constants for `SceneMultiplayer`
pub struct SceneMultiplayerSignals;

impl SceneMultiplayerSignals {
    /// Emitted when this MultiplayerAPI's `MultiplayerAPI.multiplayer_peer` connects to a new peer and a valid `auth_callback` is set. In this case, the `MultiplayerAPI.peer_connected` will not be emitted until `complete_auth()` is called with given peer `id`. While in this state, the peer will not be included in the list returned by `MultiplayerAPI.get_peers()` (but in the one returned by `get_authenticating_peers()`), and only authentication data will be sent or received. See `send_auth()` for sending authentication data.
    pub const PEER_AUTHENTICATING: &'static str = "peer_authenticating";

    /// Emitted when this MultiplayerAPI's `MultiplayerAPI.multiplayer_peer` disconnects from a peer for which authentication had not yet completed. See `peer_authenticating`.
    pub const PEER_AUTHENTICATION_FAILED: &'static str = "peer_authentication_failed";

    /// Emitted when this MultiplayerAPI's `MultiplayerAPI.multiplayer_peer` receives a `packet` with custom data (see `send_bytes()`). ID is the peer ID of the peer that sent the packet.
    pub const PEER_PACKET: &'static str = "peer_packet";
}

/// Signal constants for `SceneTree`
pub struct SceneTreeSignals;

impl SceneTreeSignals {
    /// Emitted any time the tree's hierarchy changes (nodes being moved, renamed, etc.).
    pub const TREE_CHANGED: &'static str = "tree_changed";

    /// Emitted after the new scene is added to scene tree and initialized. Can be used to reliably access `current_scene` when changing scenes.
    ///
    /// ```text
    /// # This code should be inside an autoload.
    /// get_tree().change_scene_to_file(other_scene_path)
    /// await get_tree().scene_changed
    /// print(get_tree().current_scene) # Prints the new scene.
    /// ```
    ///
    pub const SCENE_CHANGED: &'static str = "scene_changed";

    /// Emitted when the `Node.process_mode` of any node inside the tree is changed. Only emitted in the editor, to update the visibility of disabled nodes.
    pub const TREE_PROCESS_MODE_CHANGED: &'static str = "tree_process_mode_changed";

    /// Emitted when the `node` enters this tree.
    pub const NODE_ADDED: &'static str = "node_added";

    /// Emitted when the `node` exits this tree.
    pub const NODE_REMOVED: &'static str = "node_removed";

    /// Emitted when the `node`'s `Node.name` is changed.
    pub const NODE_RENAMED: &'static str = "node_renamed";

    /// Emitted when the `node`'s `Node.update_configuration_warnings()` is called. Only emitted in the editor.
    pub const NODE_CONFIGURATION_WARNING_CHANGED: &'static str =
        "node_configuration_warning_changed";

    /// Emitted immediately before `Node._process()` is called on every node in this tree.
    pub const PROCESS_FRAME: &'static str = "process_frame";

    /// Emitted immediately before `Node._physics_process()` is called on every node in this tree.
    pub const PHYSICS_FRAME: &'static str = "physics_frame";
}

/// Signal constants for `SceneTreeTimer`
pub struct SceneTreeTimerSignals;

impl SceneTreeTimerSignals {
    /// Emitted when the timer reaches 0.
    pub const TIMEOUT: &'static str = "timeout";
}

/// Signal constants for `ScriptEditor`
pub struct ScriptEditorSignals;

impl ScriptEditorSignals {
    /// Emitted when user changed active script. Argument is a freshly activated .
    pub const EDITOR_SCRIPT_CHANGED: &'static str = "editor_script_changed";

    /// Emitted when editor is about to close the active script. Argument is a  that is going to be closed.
    pub const SCRIPT_CLOSE: &'static str = "script_close";
}

/// Signal constants for `ScriptEditorBase`
pub struct ScriptEditorBaseSignals;

impl ScriptEditorBaseSignals {
    /// Emitted after script validation or when the edited resource has changed.
    pub const NAME_CHANGED: &'static str = "name_changed";

    /// Emitted after script validation.
    pub const EDITED_SCRIPT_CHANGED: &'static str = "edited_script_changed";

    /// Emitted when the user requests contextual help.
    pub const REQUEST_HELP: &'static str = "request_help";

    /// Emitted when the user requests to view a specific line of a script, similar to `go_to_method`.
    pub const REQUEST_OPEN_SCRIPT_AT_LINE: &'static str = "request_open_script_at_line";

    /// Emitted when the user contextual goto and the item is in the same script.
    pub const REQUEST_SAVE_HISTORY: &'static str = "request_save_history";

    /// Emitted when the user changes current script or moves caret by 10 or more columns within the same script.
    pub const REQUEST_SAVE_PREVIOUS_STATE: &'static str = "request_save_previous_state";

    /// Emitted when the user requests a specific documentation page.
    pub const GO_TO_HELP: &'static str = "go_to_help";

    /// Emitted when the user request to search text in the file system.
    pub const SEARCH_IN_FILES_REQUESTED: &'static str = "search_in_files_requested";

    /// Emitted when the user request to find and replace text in the file system.
    pub const REPLACE_IN_FILES_REQUESTED: &'static str = "replace_in_files_requested";

    /// Emitted when the user requests to view a specific method of a script, similar to `request_open_script_at_line`.
    pub const GO_TO_METHOD: &'static str = "go_to_method";
}

/// Signal constants for `ScrollBar`
pub struct ScrollBarSignals;

impl ScrollBarSignals {
    /// Emitted when the scrollbar is being scrolled.
    pub const SCROLLING: &'static str = "scrolling";
}

/// Signal constants for `ScrollContainer`
pub struct ScrollContainerSignals;

impl ScrollContainerSignals {
    /// Emitted when scrolling starts when dragging the scrollable area w*ith a touch event*. This signal is *not* emitted when scrolling by dragging the scrollbar, scrolling with the mouse wheel or scrolling with keyboard/gamepad events.
    /// **Note:** This signal is only emitted on Android or iOS, or on desktop/web platforms when `ProjectSettings.input_devices/pointing/emulate_touch_from_mouse` is enabled.
    pub const SCROLL_STARTED: &'static str = "scroll_started";

    /// Emitted when scrolling stops when dragging the scrollable area *with a touch event*. This signal is *not* emitted when scrolling by dragging the scrollbar, scrolling with the mouse wheel or scrolling with keyboard/gamepad events.
    /// **Note:** This signal is only emitted on Android or iOS, or on desktop/web platforms when `ProjectSettings.input_devices/pointing/emulate_touch_from_mouse` is enabled.
    pub const SCROLL_ENDED: &'static str = "scroll_ended";
}

/// Signal constants for `Skeleton2D`
pub struct Skeleton2DSignals;

impl Skeleton2DSignals {
    /// Emitted when the  setup attached to this skeletons changes. This is primarily used internally within the skeleton.
    pub const BONE_SETUP_CHANGED: &'static str = "bone_setup_changed";
}

/// Signal constants for `Skeleton3D`
pub struct Skeleton3DSignals;

impl Skeleton3DSignals {
    /// Emitted when the rest is updated.
    pub const REST_UPDATED: &'static str = "rest_updated";

    /// Emitted when the pose is updated.
    /// **Note:** During the update process, this signal is not fired, so modification by  is not detected.
    pub const POSE_UPDATED: &'static str = "pose_updated";

    /// Emitted when the final pose has been calculated will be applied to the skin in the update process.
    /// This means that all  processing is complete. In order to detect the completion of the processing of each , use `SkeletonModifier3D.modification_processed`.
    pub const SKELETON_UPDATED: &'static str = "skeleton_updated";

    /// Emitted when the bone at `bone_idx` is toggled with `set_bone_enabled()`. Use `is_bone_enabled()` to check the new value.
    pub const BONE_ENABLED_CHANGED: &'static str = "bone_enabled_changed";

    /// Emitted when the list of bones changes, such as when calling `add_bone()`, `set_bone_parent()`, `unparent_bone_and_rest()`, or `clear_bones()`.
    pub const BONE_LIST_CHANGED: &'static str = "bone_list_changed";

    /// Emitted when the value of `show_rest_only` changes.
    pub const SHOW_REST_ONLY_CHANGED: &'static str = "show_rest_only_changed";
}

/// Signal constants for `SkeletonModifier3D`
pub struct SkeletonModifier3DSignals;

impl SkeletonModifier3DSignals {
    /// Notifies when the modification have been finished.
    /// **Note:** If you want to get the modified bone pose by the modifier, you must use `Skeleton3D.get_bone_pose()` or `Skeleton3D.get_bone_global_pose()` at the moment this signal is fired.
    pub const MODIFICATION_PROCESSED: &'static str = "modification_processed";
}

/// Signal constants for `SkeletonProfile`
pub struct SkeletonProfileSignals;

impl SkeletonProfileSignals {
    /// This signal is emitted when change the value in profile. This is used to update key name in the  and to redraw the  editor.
    /// **Note:** This signal is not connected directly to editor to simplify the reference, instead it is passed on to editor through the .
    pub const PROFILE_UPDATED: &'static str = "profile_updated";
}

/// Signal constants for `Slider`
pub struct SliderSignals;

impl SliderSignals {
    /// Emitted when the grabber starts being dragged. This is emitted before the corresponding `Range.value_changed` signal.
    pub const DRAG_STARTED: &'static str = "drag_started";

    /// Emitted when the grabber stops being dragged. If `value_changed` is `true`, `Range.value` is different from the value when the dragging was started.
    pub const DRAG_ENDED: &'static str = "drag_ended";
}

/// Signal constants for `SplitContainer`
pub struct SplitContainerSignals;

impl SplitContainerSignals {
    /// Emitted when the dragger is dragged by user.
    pub const DRAGGED: &'static str = "dragged";

    /// Emitted when the user starts dragging.
    pub const DRAG_STARTED: &'static str = "drag_started";

    /// Emitted when the user ends dragging.
    pub const DRAG_ENDED: &'static str = "drag_ended";
}

/// Signal constants for `Sprite2D`
pub struct Sprite2DSignals;

impl Sprite2DSignals {
    /// Emitted when the `frame` changes.
    pub const FRAME_CHANGED: &'static str = "frame_changed";

    /// Emitted when the `texture` changes.
    pub const TEXTURE_CHANGED: &'static str = "texture_changed";
}

/// Signal constants for `Sprite3D`
pub struct Sprite3DSignals;

impl Sprite3DSignals {
    /// Emitted when the `frame` changes.
    pub const FRAME_CHANGED: &'static str = "frame_changed";

    /// Emitted when the `texture` changes.
    pub const TEXTURE_CHANGED: &'static str = "texture_changed";
}

/// Signal constants for `TabBar`
pub struct TabBarSignals;

impl TabBarSignals {
    /// Emitted when a tab is selected via click, directional input, or script, even if it is the current tab.
    pub const TAB_SELECTED: &'static str = "tab_selected";

    /// Emitted when switching to another tab.
    pub const TAB_CHANGED: &'static str = "tab_changed";

    /// Emitted when a tab is clicked, even if it is the current tab.
    pub const TAB_CLICKED: &'static str = "tab_clicked";

    /// Emitted when a tab is right-clicked. `select_with_rmb` must be enabled.
    pub const TAB_RMB_CLICKED: &'static str = "tab_rmb_clicked";

    /// Emitted when a tab's close button is pressed or when middle-clicking on a tab, if `close_with_middle_mouse` is enabled.
    /// **Note:** Tabs are not removed automatically once the close button is pressed, this behavior needs to be programmed manually. For example:
    ///
    /// ```gdscript
    ///
    /// $TabBar.tab_close_pressed.connect($TabBar.remove_tab)
    ///
    ///
    /// GetNode<TabBar>("TabBar").TabClosePressed += GetNode<TabBar>("TabBar").RemoveTab;
    ///
    /// ```
    ///
    pub const TAB_CLOSE_PRESSED: &'static str = "tab_close_pressed";

    /// Emitted when a tab's right button is pressed. See `set_tab_button_icon()`.
    pub const TAB_BUTTON_PRESSED: &'static str = "tab_button_pressed";

    /// Emitted when a tab is hovered by the mouse.
    pub const TAB_HOVERED: &'static str = "tab_hovered";

    /// Emitted when the active tab is rearranged via mouse drag. See `drag_to_rearrange_enabled`.
    pub const ACTIVE_TAB_REARRANGED: &'static str = "active_tab_rearranged";
}

/// Signal constants for `TabContainer`
pub struct TabContainerSignals;

impl TabContainerSignals {
    /// Emitted when the active tab is rearranged via mouse drag. See `drag_to_rearrange_enabled`.
    pub const ACTIVE_TAB_REARRANGED: &'static str = "active_tab_rearranged";

    /// Emitted when switching to another tab.
    pub const TAB_CHANGED: &'static str = "tab_changed";

    /// Emitted when a tab is clicked, even if it is the current tab.
    pub const TAB_CLICKED: &'static str = "tab_clicked";

    /// Emitted when a tab is hovered by the mouse.
    pub const TAB_HOVERED: &'static str = "tab_hovered";

    /// Emitted when a tab is selected via click, directional input, or script, even if it is the current tab.
    pub const TAB_SELECTED: &'static str = "tab_selected";

    /// Emitted when the user clicks on the button icon on this tab.
    pub const TAB_BUTTON_PRESSED: &'static str = "tab_button_pressed";

    /// Emitted when the 's  button is clicked. See `set_popup()` for details.
    pub const PRE_POPUP_PRESSED: &'static str = "pre_popup_pressed";
}

/// Signal constants for `TextEdit`
pub struct TextEditSignals;

impl TextEditSignals {
    /// Emitted when `clear()` is called or `text` is set.
    pub const TEXT_SET: &'static str = "text_set";

    /// Emitted when the text changes.
    pub const TEXT_CHANGED: &'static str = "text_changed";

    /// Emitted immediately when the text changes.
    /// When text is added `from_line` will be less than `to_line`. On a remove `to_line` will be less than `from_line`.
    pub const LINES_EDITED_FROM: &'static str = "lines_edited_from";

    /// Emitted when any caret changes position.
    pub const CARET_CHANGED: &'static str = "caret_changed";

    /// Emitted when a gutter is clicked.
    pub const GUTTER_CLICKED: &'static str = "gutter_clicked";

    /// Emitted when a gutter is added.
    pub const GUTTER_ADDED: &'static str = "gutter_added";

    /// Emitted when a gutter is removed.
    pub const GUTTER_REMOVED: &'static str = "gutter_removed";
}

/// Signal constants for `TextServerManager`
pub struct TextServerManagerSignals;

impl TextServerManagerSignals {
    /// Emitted when a new interface has been added.
    pub const INTERFACE_ADDED: &'static str = "interface_added";

    /// Emitted when an interface is removed.
    pub const INTERFACE_REMOVED: &'static str = "interface_removed";
}

/// Signal constants for `ThemeDB`
pub struct ThemeDBSignals;

impl ThemeDBSignals {
    /// Emitted when one of the fallback values had been changed. Use it to refresh the look of controls that may rely on the fallback theme items.
    pub const FALLBACK_CHANGED: &'static str = "fallback_changed";
}

/// Signal constants for `TileData`
pub struct TileDataSignals;

impl TileDataSignals {
    /// Emitted when any of the properties are changed.
    pub const CHANGED: &'static str = "changed";
}

/// Signal constants for `TileMap`
pub struct TileMapSignals;

impl TileMapSignals {
    /// Emitted when the  of this TileMap changes.
    pub const CHANGED: &'static str = "changed";
}

#[cfg(feature = "api-4-3")]
/// Signal constants for `TileMapLayer`
pub struct TileMapLayerSignals;

#[cfg(feature = "api-4-3")]
impl TileMapLayerSignals {
    /// Emitted when this 's properties changes. This includes modified cells, properties, or changes made to its assigned .
    /// **Note:** This signal may be emitted very often when batch-modifying a . Avoid executing complex processing in a connected function, and consider delaying it to the end of the frame instead (i.e. calling `Object.call_deferred()`).
    pub const CHANGED: &'static str = "changed";
}

/// Signal constants for `Timer`
pub struct TimerSignals;

impl TimerSignals {
    /// Emitted when the timer reaches the end.
    pub const TIMEOUT: &'static str = "timeout";
}

/// Signal constants for `TouchScreenButton`
pub struct TouchScreenButtonSignals;

impl TouchScreenButtonSignals {
    /// Emitted when the button is pressed (down).
    pub const PRESSED: &'static str = "pressed";

    /// Emitted when the button is released (up).
    pub const RELEASED: &'static str = "released";
}

/// Signal constants for `Tree`
pub struct TreeSignals;

impl TreeSignals {
    /// Emitted when an item is selected.
    pub const ITEM_SELECTED: &'static str = "item_selected";

    /// Emitted when a cell is selected.
    pub const CELL_SELECTED: &'static str = "cell_selected";

    /// Emitted instead of `item_selected` if `select_mode` is set to `SELECT_MULTI`.
    pub const MULTI_SELECTED: &'static str = "multi_selected";

    /// Emitted when an item is selected with a mouse button.
    pub const ITEM_MOUSE_SELECTED: &'static str = "item_mouse_selected";

    /// Emitted when a mouse button is clicked in the empty space of the tree.
    pub const EMPTY_CLICKED: &'static str = "empty_clicked";

    /// Emitted when an item is edited.
    pub const ITEM_EDITED: &'static str = "item_edited";

    /// Emitted when an item with `TreeItem.CELL_MODE_CUSTOM` is clicked with a mouse button.
    pub const CUSTOM_ITEM_CLICKED: &'static str = "custom_item_clicked";

    /// Emitted when an item's icon is double-clicked. For a signal that emits when any part of the item is double-clicked, see `item_activated`.
    pub const ITEM_ICON_DOUBLE_CLICKED: &'static str = "item_icon_double_clicked";

    /// Emitted when an item is expanded or collapsed by clicking on the folding arrow or through code.
    /// **Note:** Despite its name, this signal is also emitted when an item is expanded.
    pub const ITEM_COLLAPSED: &'static str = "item_collapsed";

    /// Emitted when `TreeItem.propagate_check()` is called. Connect to this signal to process the items that are affected when `TreeItem.propagate_check()` is invoked. The order that the items affected will be processed is as follows: the item that invoked the method, children of that item, and finally parents of that item.
    pub const CHECK_PROPAGATED_TO_ITEM: &'static str = "check_propagated_to_item";

    /// Emitted when a button on the tree was pressed (see `TreeItem.add_button()`).
    pub const BUTTON_CLICKED: &'static str = "button_clicked";

    /// Emitted when a cell with the `TreeItem.CELL_MODE_CUSTOM` is clicked to be edited.
    pub const CUSTOM_POPUP_EDITED: &'static str = "custom_popup_edited";

    /// Emitted when an item is double-clicked, or selected with a `ui_accept` input event (e.g. using Enter or Space on the keyboard).
    pub const ITEM_ACTIVATED: &'static str = "item_activated";

    /// Emitted when a column's title is clicked with either `MOUSE_BUTTON_LEFT` or `MOUSE_BUTTON_RIGHT`.
    pub const COLUMN_TITLE_CLICKED: &'static str = "column_title_clicked";

    /// Emitted when a left mouse button click does not select any item.
    pub const NOTHING_SELECTED: &'static str = "nothing_selected";
}

/// Signal constants for `Tween`
pub struct TweenSignals;

impl TweenSignals {
    /// Emitted when one step of the  is complete, providing the step index. One step is either a single  or a group of s running in parallel.
    pub const STEP_FINISHED: &'static str = "step_finished";

    /// Emitted when a full loop is complete (see `set_loops()`), providing the loop index. This signal is not emitted after the final loop, use `finished` instead for this case.
    pub const LOOP_FINISHED: &'static str = "loop_finished";

    /// Emitted when the  has finished all tweening. Never emitted when the  is set to infinite looping (see `set_loops()`).
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `Tweener`
pub struct TweenerSignals;

impl TweenerSignals {
    /// Emitted when the  has just finished its job or became invalid (e.g. due to a freed object).
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `UndoRedo`
pub struct UndoRedoSignals;

impl UndoRedoSignals {
    /// Called when `undo()` or `redo()` was called.
    pub const VERSION_CHANGED: &'static str = "version_changed";
}

/// Signal constants for `VideoStreamPlayer`
pub struct VideoStreamPlayerSignals;

impl VideoStreamPlayerSignals {
    /// Emitted when playback is finished.
    pub const FINISHED: &'static str = "finished";
}

/// Signal constants for `Viewport`
pub struct ViewportSignals;

impl ViewportSignals {
    /// Emitted when the size of the viewport is changed, whether by resizing of window, or some other means.
    pub const SIZE_CHANGED: &'static str = "size_changed";

    /// Emitted when a Control node grabs keyboard focus.
    /// **Note:** A Control node losing focus doesn't cause this signal to be emitted.
    pub const GUI_FOCUS_CHANGED: &'static str = "gui_focus_changed";
}

/// Signal constants for `VisibleOnScreenNotifier2D`
pub struct VisibleOnScreenNotifier2DSignals;

impl VisibleOnScreenNotifier2DSignals {
    /// Emitted when the VisibleOnScreenNotifier2D enters the screen.
    pub const SCREEN_ENTERED: &'static str = "screen_entered";

    /// Emitted when the VisibleOnScreenNotifier2D exits the screen.
    pub const SCREEN_EXITED: &'static str = "screen_exited";
}

/// Signal constants for `VisibleOnScreenNotifier3D`
pub struct VisibleOnScreenNotifier3DSignals;

impl VisibleOnScreenNotifier3DSignals {
    /// Emitted when the  enters the screen.
    pub const SCREEN_ENTERED: &'static str = "screen_entered";

    /// Emitted when the  exits the screen.
    pub const SCREEN_EXITED: &'static str = "screen_exited";
}

/// Signal constants for `VisualShaderNodeInput`
pub struct VisualShaderNodeInputSignals;

impl VisualShaderNodeInputSignals {
    /// Emitted when input is changed via `input_name`.
    pub const INPUT_TYPE_CHANGED: &'static str = "input_type_changed";
}

/// Signal constants for `WebRTCPeerConnection`
pub struct WebRTCPeerConnectionSignals;

impl WebRTCPeerConnectionSignals {
    /// Emitted after a successful call to `create_offer()` or `set_remote_description()` (when it generates an answer). The parameters are meant to be passed to `set_local_description()` on this object, and sent to the remote peer over the signaling server.
    pub const SESSION_DESCRIPTION_CREATED: &'static str = "session_description_created";

    /// Emitted when a new ICE candidate has been created. The three parameters are meant to be passed to the remote peer over the signaling server.
    pub const ICE_CANDIDATE_CREATED: &'static str = "ice_candidate_created";

    /// Emitted when a new in-band channel is received, i.e. when the channel was created with `negotiated: false` (default).
    /// The object will be an instance of . You must keep a reference of it or it will be closed automatically. See `create_data_channel()`.
    pub const DATA_CHANNEL_RECEIVED: &'static str = "data_channel_received";
}

/// Signal constants for `WebXRInterface`
pub struct WebXRInterfaceSignals;

impl WebXRInterfaceSignals {
    /// Emitted by `is_session_supported()` to indicate if the given `session_mode` is supported or not.
    pub const SESSION_SUPPORTED: &'static str = "session_supported";

    /// Emitted by `XRInterface.initialize()` if the session is successfully started.
    /// At this point, it's safe to do `get_viewport().use_xr = true` to instruct Godot to start rendering to the XR device.
    pub const SESSION_STARTED: &'static str = "session_started";

    /// Emitted when the user ends the WebXR session (which can be done using UI from the browser or device).
    /// At this point, you should do `get_viewport().use_xr = false` to instruct Godot to resume rendering to the screen.
    pub const SESSION_ENDED: &'static str = "session_ended";

    /// Emitted by `XRInterface.initialize()` if the session fails to start.
    /// `message` may optionally contain an error message from WebXR, or an empty string if no message is available.
    pub const SESSION_FAILED: &'static str = "session_failed";

    /// Emitted when one of the input source has started its "primary action".
    /// Use `get_input_source_tracker()` and `get_input_source_target_ray_mode()` to get more information about the input source.
    pub const SELECTSTART: &'static str = "selectstart";

    /// Emitted after one of the input sources has finished its "primary action".
    /// Use `get_input_source_tracker()` and `get_input_source_target_ray_mode()` to get more information about the input source.
    pub const SELECT: &'static str = "select";

    /// Emitted when one of the input sources has finished its "primary action".
    /// Use `get_input_source_tracker()` and `get_input_source_target_ray_mode()` to get more information about the input source.
    pub const SELECTEND: &'static str = "selectend";

    /// Emitted when one of the input sources has started its "primary squeeze action".
    /// Use `get_input_source_tracker()` and `get_input_source_target_ray_mode()` to get more information about the input source.
    pub const SQUEEZESTART: &'static str = "squeezestart";

    /// Emitted after one of the input sources has finished its "primary squeeze action".
    /// Use `get_input_source_tracker()` and `get_input_source_target_ray_mode()` to get more information about the input source.
    pub const SQUEEZE: &'static str = "squeeze";

    /// Emitted when one of the input sources has finished its "primary squeeze action".
    /// Use `get_input_source_tracker()` and `get_input_source_target_ray_mode()` to get more information about the input source.
    pub const SQUEEZEEND: &'static str = "squeezeend";

    /// Emitted when `visibility_state` has changed.
    pub const VISIBILITY_STATE_CHANGED: &'static str = "visibility_state_changed";

    /// Emitted to indicate that the reference space has been reset or reconfigured.
    /// When (or whether) this is emitted depends on the user's browser or device, but may include when the user has changed the dimensions of their play space (which you may be able to access via `XRInterface.get_play_area()`) or pressed/held a button to recenter their position.
    /// See [WebXR's XRReferenceSpace reset event](https://developer.mozilla.org/en-US/docs/Web/API/XRReferenceSpace/reset_event) for more information.
    pub const REFERENCE_SPACE_RESET: &'static str = "reference_space_reset";

    /// Emitted after the display's refresh rate has changed.
    pub const DISPLAY_REFRESH_RATE_CHANGED: &'static str = "display_refresh_rate_changed";
}

/// Signal constants for `Window`
pub struct WindowSignals;

impl WindowSignals {
    /// Emitted when the  is currently focused and receives any input, passing the received event as an argument. The event's position, if present, is in the embedder's coordinate system.
    pub const WINDOW_INPUT: &'static str = "window_input";

    /// Emitted when files are dragged from the OS file manager and dropped in the game window. The argument is a list of file paths.
    ///
    /// ```text
    /// func _ready():
    ///     get_window().files_dropped.connect(on_files_dropped)
    ///
    /// func on_files_dropped(files):
    ///     print(files)
    /// ```
    ///
    /// **Note:** This signal only works with native windows, i.e. the main window and -derived nodes when `Viewport.gui_embed_subwindows` is disabled in the main viewport.
    pub const FILES_DROPPED: &'static str = "files_dropped";

    /// Emitted when the mouse cursor enters the 's visible area, that is not occluded behind other s or windows, provided its `Viewport.gui_disable_input` is `false` and regardless if it's currently focused or not.
    pub const MOUSE_ENTERED: &'static str = "mouse_entered";

    /// Emitted when the mouse cursor leaves the 's visible area, that is not occluded behind other s or windows, provided its `Viewport.gui_disable_input` is `false` and regardless if it's currently focused or not.
    pub const MOUSE_EXITED: &'static str = "mouse_exited";

    /// Emitted when the  gains focus.
    pub const FOCUS_ENTERED: &'static str = "focus_entered";

    /// Emitted when the  loses its focus.
    pub const FOCUS_EXITED: &'static str = "focus_exited";

    /// Emitted when the 's close button is pressed or when `popup_window` is enabled and user clicks outside the window.
    /// This signal can be used to handle window closing, e.g. by connecting it to `hide()`.
    pub const CLOSE_REQUESTED: &'static str = "close_requested";

    /// Emitted when a go back request is sent (e.g. pressing the "Back" button on Android), right after `Node.NOTIFICATION_WM_GO_BACK_REQUEST`.
    pub const GO_BACK_REQUESTED: &'static str = "go_back_requested";

    /// Emitted when  is made visible or disappears.
    pub const VISIBILITY_CHANGED: &'static str = "visibility_changed";

    /// Emitted right after `popup()` call, before the  appears or does anything.
    pub const ABOUT_TO_POPUP: &'static str = "about_to_popup";

    /// Emitted when the `NOTIFICATION_THEME_CHANGED` notification is sent.
    pub const THEME_CHANGED: &'static str = "theme_changed";

    /// Emitted when the 's DPI changes as a result of OS-level changes (e.g. moving the window from a Retina display to a lower resolution one).
    /// **Note:** Only implemented on macOS and Linux (Wayland).
    pub const DPI_CHANGED: &'static str = "dpi_changed";

    /// Emitted when window title bar decorations are changed, e.g. macOS window enter/exit full screen mode, or extend-to-title flag is changed.
    pub const TITLEBAR_CHANGED: &'static str = "titlebar_changed";

    /// Emitted when window title bar text is changed.
    pub const TITLE_CHANGED: &'static str = "title_changed";
}

/// Signal constants for `XRInterface`
pub struct XRInterfaceSignals;

impl XRInterfaceSignals {
    /// Emitted when the play area is changed. This can be a result of the player resetting the boundary or entering a new play area, the player changing the play area mode, the world scale changing or the player resetting their headset orientation.
    pub const PLAY_AREA_CHANGED: &'static str = "play_area_changed";
}

/// Signal constants for `XRPositionalTracker`
pub struct XRPositionalTrackerSignals;

impl XRPositionalTrackerSignals {
    /// Emitted when the state of a pose tracked by this tracker changes.
    pub const POSE_CHANGED: &'static str = "pose_changed";

    /// Emitted when a pose tracked by this tracker stops getting updated tracking data.
    pub const POSE_LOST_TRACKING: &'static str = "pose_lost_tracking";

    /// Emitted when a button on this tracker is pressed. Note that many XR runtimes allow other inputs to be mapped to buttons.
    pub const BUTTON_PRESSED: &'static str = "button_pressed";

    /// Emitted when a button on this tracker is released.
    pub const BUTTON_RELEASED: &'static str = "button_released";

    /// Emitted when a trigger or similar input on this tracker changes value.
    pub const INPUT_FLOAT_CHANGED: &'static str = "input_float_changed";

    /// Emitted when a thumbstick or thumbpad on this tracker moves.
    pub const INPUT_VECTOR2_CHANGED: &'static str = "input_vector2_changed";

    /// Emitted when the profile of our tracker changes.
    pub const PROFILE_CHANGED: &'static str = "profile_changed";
}

/// Signal constants for `XRServer`
pub struct XRServerSignals;

impl XRServerSignals {
    /// Emitted when the reference frame transform changes.
    pub const REFERENCE_FRAME_CHANGED: &'static str = "reference_frame_changed";

    /// Emitted when a new interface has been added.
    pub const INTERFACE_ADDED: &'static str = "interface_added";

    /// Emitted when an interface is removed.
    pub const INTERFACE_REMOVED: &'static str = "interface_removed";

    /// Emitted when a new tracker has been added. If you don't use a fixed number of controllers or if you're using s for an AR solution, it is important to react to this signal to add the appropriate  or  nodes related to this new tracker.
    pub const TRACKER_ADDED: &'static str = "tracker_added";

    /// Emitted when an existing tracker has been updated. This can happen if the user switches controllers.
    pub const TRACKER_UPDATED: &'static str = "tracker_updated";

    /// Emitted when a tracker is removed. You should remove any  or  points if applicable. This is not mandatory, the nodes simply become inactive and will be made active again when a new tracker becomes available (i.e. a new controller is switched on that takes the place of the previous one).
    pub const TRACKER_REMOVED: &'static str = "tracker_removed";
}