fake-bge-module 20250317__py3-none-any.whl → 20260131__py3-none-any.whl

bpy/ops/node/__init__.pyi

@@ -1,18 +1,35 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import bl_operators.node
-import bpy._typing.rna_enums
 import bpy.ops.transform
+import bpy.ops.wm
+import bpy.stub_internal.rna_enums
 import bpy.types
 
 def activate_viewer(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Activate selected viewer node in compositor and geometry nodes
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Activate selected viewer node in compositor and geometry nodes"""
+
+def add_closure_zone(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
+    | None = None,
+    use_transform: bool | None = False,
+    offset: collections.abc.Iterable[float] | None = (150.0, 0.0),
+) -> None:
+    """Add a Closure zone
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param settings: Settings, Settings to be applied on the newly created node
+    :param use_transform: Use Transform, Start transform operator after inserting the node
+    :param offset: Offset, Offset of nodes from the cursor when added
     """
 
 def add_collection(
@@ -22,15 +39,11 @@ def add_collection(
     *,
     name: str = "",
     session_uid: int | None = 0,
-):
+) -> None:
     """Add a collection info node to the current node editor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param name: Name, Name of the data-block to use by the operator
-    :type name: str
     :param session_uid: Session UID, Session UID of the data-block to use by the operator
-    :type session_uid: int | None
     """
 
 def add_color(
@@ -41,20 +54,94 @@ def add_color(
     color: collections.abc.Iterable[float] | None = (0.0, 0.0, 0.0, 0.0),
     gamma: bool | None = False,
     has_alpha: bool | None = False,
-):
+) -> None:
     """Add a color node to the current node editor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param color: Color, Source color
-    :type color: collections.abc.Iterable[float] | None
     :param gamma: Gamma Corrected, The source color is gamma corrected
-    :type gamma: bool | None
     :param has_alpha: Has Alpha, The source color contains an Alpha component
-    :type has_alpha: bool | None
     """
 
-def add_file(
+def add_empty_group(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
+    | None = None,
+    use_transform: bool | None = False,
+) -> None:
+    """Add a group node with an empty group
+
+    :param settings: Settings, Settings to be applied on the newly created node
+    :param use_transform: Use Transform, Start transform operator after inserting the node
+    """
+
+def add_foreach_geometry_element_zone(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
+    | None = None,
+    use_transform: bool | None = False,
+    offset: collections.abc.Iterable[float] | None = (150.0, 0.0),
+) -> None:
+    """Add a For Each Geometry Element zone that allows executing nodes e.g. for each vertex separately
+
+    :param settings: Settings, Settings to be applied on the newly created node
+    :param use_transform: Use Transform, Start transform operator after inserting the node
+    :param offset: Offset, Offset of nodes from the cursor when added
+    """
+
+def add_group(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    name: str = "",
+    session_uid: int | None = 0,
+    show_datablock_in_node: bool | None = True,
+) -> None:
+    """Add an existing node group to the current node editor
+
+    :param name: Name, Name of the data-block to use by the operator
+    :param session_uid: Session UID, Session UID of the data-block to use by the operator
+    :param show_datablock_in_node: Show the data-block selector in the node
+    """
+
+def add_group_asset(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    asset_library_type: bpy.stub_internal.rna_enums.AssetLibraryTypeItems
+    | None = "LOCAL",
+    asset_library_identifier: str = "",
+    relative_asset_identifier: str = "",
+) -> None:
+    """Add a node group asset to the active node tree
+
+    :param asset_library_type: Asset Library Type
+    :param asset_library_identifier: Asset Library Identifier
+    :param relative_asset_identifier: Relative Asset Identifier
+    """
+
+def add_group_input_node(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    socket_identifier: str = "",
+    panel_identifier: int | None = 0,
+) -> None:
+    """Add a Group Input node with selected sockets to the current node editor
+
+    :param socket_identifier: Socket Identifier, Socket to include in the added group input/output node
+    :param panel_identifier: Panel Identifier, Panel from which to add sockets to the added group input/output node
+    """
+
+def add_image(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
@@ -75,7 +162,6 @@ def add_file(
     filter_text: bool | None = False,
     filter_archive: bool | None = False,
     filter_btx: bool | None = False,
-    filter_collada: bool | None = False,
     filter_alembic: bool | None = False,
     filter_usd: bool | None = False,
     filter_obj: bool | None = False,
@@ -101,63 +187,34 @@ def add_file(
     | None = "",
     name: str = "",
     session_uid: int | None = 0,
-):
-    """Add a file node to the current node editor
+) -> None:
+    """Add a image/movie file as node to the current node editor
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param filepath: File Path, Path to file
-        :type filepath: str
         :param directory: Directory, Directory of the file
-        :type directory: str
         :param files: Files
-        :type files: bpy.types.bpy_prop_collection[bpy.types.OperatorFileListElement] | None
         :param hide_props_region: Hide Operator Properties, Collapse the region displaying the operator settings
-        :type hide_props_region: bool | None
         :param check_existing: Check Existing, Check and warn on overwriting existing files
-        :type check_existing: bool | None
         :param filter_blender: Filter .blend files
-        :type filter_blender: bool | None
         :param filter_backup: Filter .blend files
-        :type filter_backup: bool | None
         :param filter_image: Filter image files
-        :type filter_image: bool | None
         :param filter_movie: Filter movie files
-        :type filter_movie: bool | None
         :param filter_python: Filter Python files
-        :type filter_python: bool | None
         :param filter_font: Filter font files
-        :type filter_font: bool | None
         :param filter_sound: Filter sound files
-        :type filter_sound: bool | None
         :param filter_text: Filter text files
-        :type filter_text: bool | None
         :param filter_archive: Filter archive files
-        :type filter_archive: bool | None
         :param filter_btx: Filter btx files
-        :type filter_btx: bool | None
-        :param filter_collada: Filter COLLADA files
-        :type filter_collada: bool | None
         :param filter_alembic: Filter Alembic files
-        :type filter_alembic: bool | None
         :param filter_usd: Filter USD files
-        :type filter_usd: bool | None
         :param filter_obj: Filter OBJ files
-        :type filter_obj: bool | None
         :param filter_volume: Filter OpenVDB volume files
-        :type filter_volume: bool | None
         :param filter_folder: Filter folders
-        :type filter_folder: bool | None
         :param filter_blenlib: Filter Blender IDs
-        :type filter_blenlib: bool | None
         :param filemode: File Browser Mode, The setting for the file browser mode to load a .blend file, a library or a special file
-        :type filemode: int | None
         :param relative_path: Relative Path, Select the file relative to the blend file
-        :type relative_path: bool | None
         :param show_multiview: Enable Multi-View
-        :type show_multiview: bool | None
         :param use_multiview: Use Multi-View
-        :type use_multiview: bool | None
         :param display_type: Display Type
 
     DEFAULT
@@ -171,7 +228,6 @@ def add_file(
 
     THUMBNAIL
     Thumbnails -- Display files as thumbnails.
-        :type display_type: typing.Literal['DEFAULT','LIST_VERTICAL','LIST_HORIZONTAL','THUMBNAIL'] | None
         :param sort_method: File sorting mode
 
     DEFAULT
@@ -191,75 +247,8 @@ def add_file(
 
     ASSET_CATALOG
     Asset Catalog -- Sort the asset list so that assets in the same catalog are kept together. Within a single catalog, assets are ordered by name. The catalogs are in order of the flattened catalog hierarchy..
-        :type sort_method: typing.Literal['DEFAULT','FILE_SORT_ALPHA','FILE_SORT_EXTENSION','FILE_SORT_TIME','FILE_SORT_SIZE','ASSET_CATALOG'] | None
         :param name: Name, Name of the data-block to use by the operator
-        :type name: str
         :param session_uid: Session UID, Session UID of the data-block to use by the operator
-        :type session_uid: int | None
-    """
-
-def add_foreach_geometry_element_zone(
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-    /,
-    *,
-    use_transform: bool | None = False,
-    settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
-    | None = None,
-    offset: collections.abc.Iterable[float] | None = (150.0, 0.0),
-):
-    """Add a For Each Geometry Element zone that allows executing nodes e.g. for each vertex separately
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param use_transform: Use Transform, Start transform operator after inserting the node
-    :type use_transform: bool | None
-    :param settings: Settings, Settings to be applied on the newly created node
-    :type settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting] | None
-    :param offset: Offset, Offset of nodes from the cursor when added
-    :type offset: collections.abc.Iterable[float] | None
-    """
-
-def add_group(
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-    /,
-    *,
-    name: str = "",
-    session_uid: int | None = 0,
-    show_datablock_in_node: bool | None = True,
-):
-    """Add an existing node group to the current node editor
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param name: Name, Name of the data-block to use by the operator
-    :type name: str
-    :param session_uid: Session UID, Session UID of the data-block to use by the operator
-    :type session_uid: int | None
-    :param show_datablock_in_node: Show the datablock selector in the node
-    :type show_datablock_in_node: bool | None
-    """
-
-def add_group_asset(
-    execution_context: int | str | None = None,
-    undo: bool | None = None,
-    /,
-    *,
-    asset_library_type: bpy._typing.rna_enums.AssetLibraryTypeItems | None = "LOCAL",
-    asset_library_identifier: str = "",
-    relative_asset_identifier: str = "",
-):
-    """Add a node group asset to the active node tree
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param asset_library_type: Asset Library Type
-    :type asset_library_type: bpy._typing.rna_enums.AssetLibraryTypeItems | None
-    :param asset_library_identifier: Asset Library Identifier
-    :type asset_library_identifier: str
-    :param relative_asset_identifier: Relative Asset Identifier
-    :type relative_asset_identifier: str
     """
 
 def add_import_node(
@@ -270,15 +259,11 @@ def add_import_node(
     directory: str = "",
     files: bpy.types.bpy_prop_collection[bpy.types.OperatorFileListElement]
     | None = None,
-):
+) -> None:
     """Add an import node to the node tree
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param directory: Directory, Directory of the file
-    :type directory: str
     :param files: Files
-    :type files: bpy.types.bpy_prop_collection[bpy.types.OperatorFileListElement] | None
     """
 
 def add_mask(
@@ -288,15 +273,11 @@ def add_mask(
     *,
     name: str = "",
     session_uid: int | None = 0,
-):
+) -> None:
     """Add a mask node to the current node editor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param name: Name, Name of the data-block to use by the operator
-    :type name: str
     :param session_uid: Session UID, Session UID of the data-block to use by the operator
-    :type session_uid: int | None
     """
 
 def add_material(
@@ -306,15 +287,11 @@ def add_material(
     *,
     name: str = "",
     session_uid: int | None = 0,
-):
+) -> None:
     """Add a material node to the current node editor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param name: Name, Name of the data-block to use by the operator
-    :type name: str
     :param session_uid: Session UID, Session UID of the data-block to use by the operator
-    :type session_uid: int | None
     """
 
 def add_node(
@@ -322,21 +299,18 @@ def add_node(
     undo: bool | None = None,
     /,
     *,
-    use_transform: bool | None = False,
     settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
     | None = None,
+    use_transform: bool | None = False,
     type: str = "",
-):
+    visible_output: str = "",
+) -> None:
     """Add a node to the active tree
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param use_transform: Use Transform, Start transform operator after inserting the node
-    :type use_transform: bool | None
     :param settings: Settings, Settings to be applied on the newly created node
-    :type settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting] | None
+    :param use_transform: Use Transform, Start transform operator after inserting the node
     :param type: Node Type, Node type
-    :type type: str
+    :param visible_output: Output Name, If provided, all outputs that are named differently will be hidden
     """
 
 def add_object(
@@ -346,15 +320,11 @@ def add_object(
     *,
     name: str = "",
     session_uid: int | None = 0,
-):
+) -> None:
     """Add an object info node to the current node editor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param name: Name, Name of the data-block to use by the operator
-    :type name: str
     :param session_uid: Session UID, Session UID of the data-block to use by the operator
-    :type session_uid: int | None
     """
 
 def add_repeat_zone(
@@ -362,21 +332,16 @@ def add_repeat_zone(
     undo: bool | None = None,
     /,
     *,
-    use_transform: bool | None = False,
     settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
     | None = None,
+    use_transform: bool | None = False,
     offset: collections.abc.Iterable[float] | None = (150.0, 0.0),
-):
+) -> None:
     """Add a repeat zone that allows executing nodes a dynamic number of times
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param use_transform: Use Transform, Start transform operator after inserting the node
-    :type use_transform: bool | None
     :param settings: Settings, Settings to be applied on the newly created node
-    :type settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting] | None
+    :param use_transform: Use Transform, Start transform operator after inserting the node
     :param offset: Offset, Offset of nodes from the cursor when added
-    :type offset: collections.abc.Iterable[float] | None
     """
 
 def add_reroute(
@@ -386,15 +351,11 @@ def add_reroute(
     *,
     path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None = None,
     cursor: int | None = 11,
-):
+) -> None:
     """Add a reroute node
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param path: Path
-    :type path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None
     :param cursor: Cursor
-    :type cursor: int | None
     """
 
 def add_simulation_zone(
@@ -402,54 +363,68 @@ def add_simulation_zone(
     undo: bool | None = None,
     /,
     *,
-    use_transform: bool | None = False,
     settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
     | None = None,
+    use_transform: bool | None = False,
     offset: collections.abc.Iterable[float] | None = (150.0, 0.0),
-):
+) -> None:
     """Add simulation zone input and output nodes to the active tree
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param use_transform: Use Transform, Start transform operator after inserting the node
-    :type use_transform: bool | None
     :param settings: Settings, Settings to be applied on the newly created node
-    :type settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting] | None
+    :param use_transform: Use Transform, Start transform operator after inserting the node
     :param offset: Offset, Offset of nodes from the cursor when added
-    :type offset: collections.abc.Iterable[float] | None
     """
 
-def attach(execution_context: int | str | None = None, undo: bool | None = None):
-    """Attach active node to a frame
+def add_zone(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
+    | None = None,
+    use_transform: bool | None = False,
+    offset: collections.abc.Iterable[float] | None = (150.0, 0.0),
+    input_node_type: str = "",
+    output_node_type: str = "",
+    add_default_geometry_link: bool | None = False,
+) -> None:
+    """Undocumented, consider contributing.
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param settings: Settings, Settings to be applied on the newly created node
+    :param use_transform: Use Transform, Start transform operator after inserting the node
+    :param offset: Offset, Offset of nodes from the cursor when added
+    :param input_node_type: Input Node, Specifies the input node used by the created zone
+    :param output_node_type: Output Node, Specifies the output node used by the created zone
+    :param add_default_geometry_link: Add Geometry Link, When enabled, create a link between geometry sockets in this zone
     """
 
-def backimage_fit(execution_context: int | str | None = None, undo: bool | None = None):
-    """Fit the background image to the view
+def attach(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Attach active node to a frame"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def backimage_fit(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Fit the background image to the view"""
 
 def backimage_move(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Move node backdrop
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Move node backdrop"""
 
 def backimage_sample(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Use mouse to sample background image
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Use mouse to sample background image"""
 
 def backimage_zoom(
     execution_context: int | str | None = None,
@@ -457,22 +432,22 @@ def backimage_zoom(
     /,
     *,
     factor: float | None = 1.2,
-):
+) -> None:
     """Zoom in/out the background image
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param factor: Factor
-    :type factor: float | None
     """
 
 def bake_node_item_add(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def bake_node_item_move(
@@ -481,31 +456,36 @@ def bake_node_item_move(
     /,
     *,
     direction: typing.Literal["UP", "DOWN"] | None = "UP",
-):
+    node_identifier: int | None = 0,
+) -> None:
     """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param direction: Direction, Move direction
-    :type direction: typing.Literal['UP','DOWN'] | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def bake_node_item_remove(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def capture_attribute_item_add(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def capture_attribute_item_move(
@@ -514,41 +494,39 @@ def capture_attribute_item_move(
     /,
     *,
     direction: typing.Literal["UP", "DOWN"] | None = "UP",
-):
+    node_identifier: int | None = 0,
+) -> None:
     """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param direction: Direction, Move direction
-    :type direction: typing.Literal['UP','DOWN'] | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def capture_attribute_item_remove(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def clear_viewer_border(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Clear the boundaries for viewer operations
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Clear the boundaries for viewer operations"""
 
 def clipboard_copy(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Copy the selected nodes to the internal clipboard
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Copy the selected nodes to the internal clipboard"""
 
 def clipboard_paste(
     execution_context: int | str | None = None,
@@ -556,171 +534,278 @@ def clipboard_paste(
     /,
     *,
     offset: collections.abc.Iterable[float] | None = (0.0, 0.0),
-):
+) -> None:
     """Paste nodes from the internal clipboard to the active node tree
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param offset: Location, The 2D view location for the center of the new nodes, or unchanged if not set
-    :type offset: collections.abc.Iterable[float] | None
-    """
-
-def collapse_hide_unused_toggle(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Toggle collapsed nodes and hide unused sockets
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
     """
 
-def connect_to_output(
+def closure_input_item_add(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
     *,
-    run_in_geometry_nodes: bool | None = True,
-):
-    """Connect active node to the active output node of the node tree
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param run_in_geometry_nodes: Run in Geometry Nodes Editor
-    :type run_in_geometry_nodes: bool | None
-    """
-
-def cryptomatte_layer_add(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Add a new input layer to a Cryptomatte node
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
-
-def cryptomatte_layer_remove(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Remove layer from a Cryptomatte node
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
-
-def deactivate_viewer(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Deactivate selected viewer node in geometry nodes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
-
-def default_group_width_set(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Set the width based on the parent group node in the current context
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
-
-def delete(execution_context: int | str | None = None, undo: bool | None = None):
-    """Remove selected nodes
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
-def delete_reconnect(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Remove nodes and reconnect nodes as if deletion was muted
+def closure_input_item_move(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
-def detach(execution_context: int | str | None = None, undo: bool | None = None):
-    """Detach selected nodes from parents
+def closure_input_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
-def detach_translate_attach(
+def closure_output_item_add(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
     *,
-    NODE_OT_detach: detach | None = None,
-    TRANSFORM_OT_translate: bpy.ops.transform.translate | None = None,
-    NODE_OT_attach: attach | None = None,
-):
-    """Detach nodes, move and attach to frame
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param NODE_OT_detach: Detach Nodes, Detach selected nodes from parents
-    :type NODE_OT_detach: detach | None
-    :param TRANSFORM_OT_translate: Move, Move selected items
-    :type TRANSFORM_OT_translate: bpy.ops.transform.translate | None
-    :param NODE_OT_attach: Attach Nodes, Attach active node to a frame
-    :type NODE_OT_attach: attach | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
-def duplicate(
+def closure_output_item_move(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
     *,
-    keep_inputs: bool | None = False,
-    linked: bool | None = True,
-):
-    """Duplicate selected nodes
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param keep_inputs: Keep Inputs, Keep the input links to duplicated nodes
-    :type keep_inputs: bool | None
-    :param linked: Linked, Duplicate node but not node trees, linking to the original data
-    :type linked: bool | None
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
-def duplicate_move(
+def closure_output_item_remove(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
     *,
-    NODE_OT_duplicate: duplicate | None = None,
-    NODE_OT_translate_attach: translate_attach | None = None,
-):
-    """Duplicate selected nodes and move them
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param NODE_OT_duplicate: Duplicate Nodes, Duplicate selected nodes
-    :type NODE_OT_duplicate: duplicate | None
-    :param NODE_OT_translate_attach: Move and Attach, Move nodes and attach to frame
-    :type NODE_OT_translate_attach: translate_attach | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
-def duplicate_move_keep_inputs(
+def collapse_hide_unused_toggle(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Toggle collapsed nodes and hide unused sockets"""
+
+def combine_bundle_item_add(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def combine_bundle_item_move(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
+
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def combine_bundle_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def connect_to_output(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    run_in_geometry_nodes: bool | None = True,
+) -> None:
+    """Connect active node to the active output node of the node tree
+
+    :param run_in_geometry_nodes: Run in Geometry Nodes Editor
+    """
+
+def cryptomatte_layer_add(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Add a new input layer to a Cryptomatte node"""
+
+def cryptomatte_layer_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Remove layer from a Cryptomatte node"""
+
+def deactivate_viewer(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Deactivate selected viewer node in geometry nodes"""
+
+def default_group_width_set(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Set the width based on the parent group node in the current context"""
+
+def delete(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Remove selected nodes"""
+
+def delete_copy_reconnect(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    NODE_OT_clipboard_copy: clipboard_copy | None = None,
+    NODE_OT_delete_reconnect: delete_reconnect | None = None,
+) -> None:
+    """Copy nodes to clipboard, remove and reconnect them.
+
+    :param NODE_OT_clipboard_copy: Copy to Clipboard, Copy the selected nodes to the internal clipboard
+    :param NODE_OT_delete_reconnect: Delete with Reconnect, Remove nodes and reconnect nodes as if deletion was muted
+    """
+
+def delete_reconnect(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Remove nodes and reconnect nodes as if deletion was muted"""
+
+def detach(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Detach selected nodes from parents"""
+
+def detach_translate_attach(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    NODE_OT_detach: detach | None = None,
+    TRANSFORM_OT_translate: bpy.ops.transform.translate | None = None,
+    NODE_OT_attach: attach | None = None,
+) -> None:
+    """Detach nodes, move and attach to frame
+
+    :param NODE_OT_detach: Detach Nodes, Detach selected nodes from parents
+    :param TRANSFORM_OT_translate: Move, Move selected items
+    :param NODE_OT_attach: Attach Nodes, Attach active node to a frame
+    """
+
+def duplicate(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    keep_inputs: bool | None = False,
+    linked: bool | None = True,
+) -> None:
+    """Duplicate selected nodes
+
+    :param keep_inputs: Keep Inputs, Keep the input links to duplicated nodes
+    :param linked: Linked, Duplicate node but not node trees, linking to the original data
+    """
+
+def duplicate_compositing_modifier_node_group(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Duplicate the currently assigned compositing node group."""
+
+def duplicate_compositing_node_group(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Duplicate the currently assigned compositing node group."""
+
+def duplicate_move(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
     *,
     NODE_OT_duplicate: duplicate | None = None,
     NODE_OT_translate_attach: translate_attach | None = None,
-):
+) -> None:
+    """Duplicate selected nodes and move them
+
+    :param NODE_OT_duplicate: Duplicate Nodes, Duplicate selected nodes
+    :param NODE_OT_translate_attach: Move and Attach, Move nodes and attach to frame
+    """
+
+def duplicate_move_keep_inputs(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    NODE_OT_duplicate: duplicate | None = None,
+    NODE_OT_translate_attach: translate_attach | None = None,
+) -> None:
     """Duplicate selected nodes keeping input links and move them
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param NODE_OT_duplicate: Duplicate Nodes, Duplicate selected nodes
-    :type NODE_OT_duplicate: duplicate | None
     :param NODE_OT_translate_attach: Move and Attach, Move nodes and attach to frame
-    :type NODE_OT_translate_attach: translate_attach | None
     """
 
 def duplicate_move_linked(
@@ -730,24 +815,23 @@ def duplicate_move_linked(
     *,
     NODE_OT_duplicate: duplicate | None = None,
     NODE_OT_translate_attach: translate_attach | None = None,
-):
+) -> None:
     """Duplicate selected nodes, but not their node trees, and move them
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param NODE_OT_duplicate: Duplicate Nodes, Duplicate selected nodes
-    :type NODE_OT_duplicate: duplicate | None
     :param NODE_OT_translate_attach: Move and Attach, Move nodes and attach to frame
-    :type NODE_OT_translate_attach: translate_attach | None
     """
 
 def enum_definition_item_add(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def enum_definition_item_move(
@@ -756,38 +840,233 @@ def enum_definition_item_move(
     /,
     *,
     direction: typing.Literal["UP", "DOWN"] | None = "UP",
-):
+    node_identifier: int | None = 0,
+) -> None:
     """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param direction: Direction, Move direction
-    :type direction: typing.Literal['UP','DOWN'] | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def enum_definition_item_remove(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def evaluate_closure_input_item_add(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def evaluate_closure_input_item_move(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
+
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def evaluate_closure_input_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def evaluate_closure_output_item_add(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def evaluate_closure_output_item_move(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
+
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def evaluate_closure_output_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def field_to_grid_item_add(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def field_to_grid_item_move(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
+
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def field_to_grid_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def field_to_list_item_add(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def field_to_list_item_move(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
+
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def field_to_list_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def file_output_item_add(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
-def find_node(execution_context: int | str | None = None, undo: bool | None = None):
-    """Search for a node by name and focus and select it
+def file_output_item_move(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
+def file_output_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def find_node(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Search for a node by name and focus and select it"""
+
 def foreach_geometry_element_zone_generation_item_add(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def foreach_geometry_element_zone_generation_item_move(
@@ -796,31 +1075,36 @@ def foreach_geometry_element_zone_generation_item_move(
     /,
     *,
     direction: typing.Literal["UP", "DOWN"] | None = "UP",
-):
+    node_identifier: int | None = 0,
+) -> None:
     """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param direction: Direction, Move direction
-    :type direction: typing.Literal['UP','DOWN'] | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def foreach_geometry_element_zone_generation_item_remove(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def foreach_geometry_element_zone_input_item_add(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def foreach_geometry_element_zone_input_item_move(
@@ -829,31 +1113,36 @@ def foreach_geometry_element_zone_input_item_move(
     /,
     *,
     direction: typing.Literal["UP", "DOWN"] | None = "UP",
-):
+    node_identifier: int | None = 0,
+) -> None:
     """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param direction: Direction, Move direction
-    :type direction: typing.Literal['UP','DOWN'] | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def foreach_geometry_element_zone_input_item_remove(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def foreach_geometry_element_zone_main_item_add(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def foreach_geometry_element_zone_main_item_move(
@@ -862,61 +1151,141 @@ def foreach_geometry_element_zone_main_item_move(
     /,
     *,
     direction: typing.Literal["UP", "DOWN"] | None = "UP",
-):
+    node_identifier: int | None = 0,
+) -> None:
     """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param direction: Direction, Move direction
-    :type direction: typing.Literal['UP','DOWN'] | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def foreach_geometry_element_zone_main_item_remove(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
-def gltf_settings_node_operator(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Add a node to the active tree for glTF export
+def format_string_item_add(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
+def format_string_item_move(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
+
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def format_string_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def geometry_nodes_viewer_item_add(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def geometry_nodes_viewer_item_move(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
+
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def geometry_nodes_viewer_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def gltf_settings_node_operator(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Add a node to the active tree for glTF export"""
+
 def group_edit(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
     *,
     exit: bool | None = False,
-):
+) -> None:
     """Edit node group
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param exit: Exit
-    :type exit: bool | None
     """
 
-def group_insert(execution_context: int | str | None = None, undo: bool | None = None):
-    """Insert selected nodes into a node group
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def group_enter_exit(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Enter or exit node group based on cursor location"""
 
-def group_make(execution_context: int | str | None = None, undo: bool | None = None):
-    """Make group from selected nodes
+def group_insert(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Insert selected nodes into a node group"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def group_make(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Make group from selected nodes"""
 
 def group_separate(
     execution_context: int | str | None = None,
@@ -924,11 +1293,9 @@ def group_separate(
     /,
     *,
     type: typing.Literal["COPY", "MOVE"] | None = "COPY",
-):
+) -> None:
     """Separate selected nodes from the node group
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param type: Type
 
     COPY
@@ -936,39 +1303,39 @@ def group_separate(
 
     MOVE
     Move -- Move to parent node tree, remove from group.
-        :type type: typing.Literal['COPY','MOVE'] | None
     """
 
-def group_ungroup(execution_context: int | str | None = None, undo: bool | None = None):
-    """Ungroup selected nodes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def group_ungroup(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Ungroup selected nodes"""
 
 def hide_socket_toggle(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Toggle unused node socket display
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
-
-def hide_toggle(execution_context: int | str | None = None, undo: bool | None = None):
-    """Toggle hiding of selected nodes
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Toggle unused node socket display"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def hide_toggle(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Toggle collapsing of selected nodes"""
 
 def index_switch_item_add(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Add bake item
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Add an item to the index switch
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def index_switch_item_remove(
@@ -977,80 +1344,94 @@ def index_switch_item_remove(
     /,
     *,
     index: int | None = 0,
-):
+) -> None:
     """Remove an item from the index switch
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param index: Index, Index to remove
-    :type index: int | None
     """
 
-def insert_offset(execution_context: int | str | None = None, undo: bool | None = None):
-    """Automatically offset nodes on insertion
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def insert_offset(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Automatically offset nodes on insertion"""
 
 def interface_item_duplicate(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Add a copy of the active item to the interface
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Add a copy of the active item to the interface"""
 
 def interface_item_make_panel_toggle(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Make the active boolean socket a toggle for its parent panel
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Make the active boolean socket a toggle for its parent panel"""
 
 def interface_item_new(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
     *,
-    item_type: str | None = "",
-):
+    item_type: typing.Literal["INPUT", "OUTPUT", "PANEL"] | None = "INPUT",
+) -> None:
     """Add a new item to the interface
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param item_type: Item Type, Type of the item to create
-    :type item_type: str | None
     """
 
-def interface_item_remove(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Remove active item from the interface
+def interface_item_new_panel_toggle(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Add a checkbox to the currently selected panel"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def interface_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Remove selected items from the interface"""
 
 def interface_item_unlink_panel_toggle(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Make the panel toggle a stand-alone socket
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Make the panel toggle a stand-alone socket"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def join(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Attach selected nodes to a new common frame"""
 
-def join(execution_context: int | str | None = None, undo: bool | None = None):
-    """Attach selected nodes to a new common frame
+def join_named(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    NODE_OT_join: join | None = None,
+    WM_OT_call_panel: bpy.ops.wm.call_panel | None = None,
+) -> None:
+    """Create a new frame node around the selected nodes and name it immediately
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param NODE_OT_join: Join Nodes in Frame, Attach selected nodes to a new common frame
+    :param WM_OT_call_panel: Call Panel, Open a predefined panel
     """
 
+def join_nodes(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Merge selected group input nodes into one if possible"""
+
 def link(
     execution_context: int | str | None = None,
     undo: bool | None = None,
@@ -1064,27 +1445,17 @@ def link(
     max_speed: float | None = 26.0,
     delay: float | None = 0.5,
     zoom_influence: float | None = 0.5,
-):
+) -> None:
     """Use the mouse to create a link between two nodes
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param detach: Detach, Detach and redirect existing links
-    :type detach: bool | None
     :param drag_start: Drag Start, The position of the mouse cursor at the start of the operation
-    :type drag_start: collections.abc.Iterable[float] | None
     :param inside_padding: Inside Padding, Inside distance in UI units from the edge of the region within which to start panning
-    :type inside_padding: float | None
     :param outside_padding: Outside Padding, Outside distance in UI units from the edge of the region at which to stop panning
-    :type outside_padding: float | None
     :param speed_ramp: Speed Ramp, Width of the zone in UI units where speed increases with distance from the edge
-    :type speed_ramp: float | None
     :param max_speed: Max Speed, Maximum speed in UI units per second
-    :type max_speed: float | None
     :param delay: Delay, Delay in seconds before maximum speed is reached
-    :type delay: float | None
     :param zoom_influence: Zoom Influence, Influence of the zoom factor on scroll speed
-    :type zoom_influence: float | None
     """
 
 def link_make(
@@ -1093,21 +1464,18 @@ def link_make(
     /,
     *,
     replace: bool | None = False,
-):
+) -> None:
     """Make a link between selected output and input sockets
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param replace: Replace, Replace socket connections with the new links
-    :type replace: bool | None
     """
 
-def link_viewer(execution_context: int | str | None = None, undo: bool | None = None):
-    """Link to viewer node
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def link_viewer(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Link to viewer node"""
 
 def links_cut(
     execution_context: int | str | None = None,
@@ -1116,23 +1484,19 @@ def links_cut(
     *,
     path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None = None,
     cursor: int | None = 15,
-):
+) -> None:
     """Use the mouse to cut (remove) some links
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param path: Path
-    :type path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None
     :param cursor: Cursor
-    :type cursor: int | None
     """
 
-def links_detach(execution_context: int | str | None = None, undo: bool | None = None):
-    """Remove all links to selected nodes, and try to connect neighbor nodes together
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def links_detach(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Remove all links to selected nodes, and try to connect neighbor nodes together"""
 
 def links_mute(
     execution_context: int | str | None = None,
@@ -1140,16 +1504,12 @@ def links_mute(
     /,
     *,
     path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None = None,
-    cursor: int | None = 38,
-):
+    cursor: int | None = 39,
+) -> None:
     """Use the mouse to mute links
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param path: Path
-    :type path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None
     :param cursor: Cursor
-    :type cursor: int | None
     """
 
 def move_detach_links(
@@ -1159,15 +1519,11 @@ def move_detach_links(
     *,
     NODE_OT_links_detach: links_detach | None = None,
     TRANSFORM_OT_translate: bpy.ops.transform.translate | None = None,
-):
+) -> None:
     """Move a node to detach links
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param NODE_OT_links_detach: Detach Links, Remove all links to selected nodes, and try to connect neighbor nodes together
-    :type NODE_OT_links_detach: links_detach | None
     :param TRANSFORM_OT_translate: Move, Move selected items
-    :type TRANSFORM_OT_translate: bpy.ops.transform.translate | None
     """
 
 def move_detach_links_release(
@@ -1177,50 +1533,64 @@ def move_detach_links_release(
     *,
     NODE_OT_links_detach: links_detach | None = None,
     NODE_OT_translate_attach: translate_attach | None = None,
-):
+) -> None:
     """Move a node to detach links
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param NODE_OT_links_detach: Detach Links, Remove all links to selected nodes, and try to connect neighbor nodes together
-    :type NODE_OT_links_detach: links_detach | None
     :param NODE_OT_translate_attach: Move and Attach, Move nodes and attach to frame
-    :type NODE_OT_translate_attach: translate_attach | None
     """
 
-def mute_toggle(execution_context: int | str | None = None, undo: bool | None = None):
-    """Toggle muting of selected nodes
+def mute_toggle(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Toggle muting of selected nodes"""
+
+def new_compositing_node_group(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    name: str = "",
+) -> None:
+    """Create a new compositing node group and initialize it with default nodes
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param name: Name
     """
 
-def new_geometry_node_group_assign(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Create a new geometry node group and assign it to the active modifier
+def new_compositor_sequencer_node_group(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    name: str = "Sequencer Compositor Nodes",
+) -> None:
+    """Create a new compositor node group for sequencer
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param name: Name
     """
 
-def new_geometry_node_group_tool(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Create a new geometry node group for a tool
+def new_geometry_node_group_assign(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Create a new geometry node group and assign it to the active modifier"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def new_geometry_node_group_tool(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Create a new geometry node group for a tool"""
 
 def new_geometry_nodes_modifier(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Create a new modifier with a new geometry node group
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Create a new modifier with a new geometry node group"""
 
 def new_node_tree(
     execution_context: int | str | None = None,
@@ -1229,15 +1599,11 @@ def new_node_tree(
     *,
     type: str | None = "",
     name: str = "NodeTree",
-):
+) -> None:
     """Create a new node tree
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param type: Tree Type
-    :type type: str | None
     :param name: Name
-    :type name: str
     """
 
 def node_color_preset_add(
@@ -1248,117 +1614,66 @@ def node_color_preset_add(
     name: str = "",
     remove_name: bool | None = False,
     remove_active: bool | None = False,
-):
+) -> None:
     """Add or remove a Node Color Preset
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param name: Name, Name of the preset, used to make the path name
-    :type name: str
     :param remove_name: remove_name
-    :type remove_name: bool | None
     :param remove_active: remove_active
-    :type remove_active: bool | None
     """
 
 def node_copy_color(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Copy color to all selected nodes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Copy color to all selected nodes"""
 
 def options_toggle(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Toggle option buttons display for selected nodes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
-
-def output_file_add_socket(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
-    *,
-    file_path: str = "Image",
-):
-    """Add a new input to a file output node
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param file_path: File Path, Subpath of the output file
-    :type file_path: str
-    """
+) -> None:
+    """Toggle option buttons display for selected nodes"""
 
-def output_file_move_active_socket(
+def parent_set(
     execution_context: int | str | None = None,
     undo: bool | None = None,
     /,
-    *,
-    direction: typing.Literal["UP", "DOWN"] | None = "DOWN",
-):
-    """Move the active input of a file output node up or down the list
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    :param direction: Direction
-    :type direction: typing.Literal['UP','DOWN'] | None
-    """
-
-def output_file_remove_active_socket(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Remove the active input from a file output node
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
-
-def parent_set(execution_context: int | str | None = None, undo: bool | None = None):
-    """Attach selected nodes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+) -> None:
+    """Attach selected nodes"""
 
 def preview_toggle(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Toggle preview display for selected nodes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Toggle preview display for selected nodes"""
 
 def read_viewlayers(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Read all render layers of all used scenes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Read all render layers of all used scenes"""
 
 def render_changed(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Render current scene, when input node's layer has been changed
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Render current scene, when input nodes layer has been changed"""
 
 def repeat_zone_item_add(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def repeat_zone_item_move(
@@ -1367,30 +1682,32 @@ def repeat_zone_item_move(
     /,
     *,
     direction: typing.Literal["UP", "DOWN"] | None = "UP",
-):
+    node_identifier: int | None = 0,
+) -> None:
     """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param direction: Direction, Move direction
-    :type direction: typing.Literal['UP','DOWN'] | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def repeat_zone_item_remove(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
-def resize(execution_context: int | str | None = None, undo: bool | None = None):
-    """Resize a node
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def resize(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Resize a node"""
 
 def select(
     execution_context: int | str | None = None,
@@ -1405,27 +1722,17 @@ def select(
     location: collections.abc.Iterable[int] | None = (0, 0),
     socket_select: bool | None = False,
     clear_viewer: bool | None = False,
-):
+) -> None:
     """Select the node under the cursor
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param extend: Extend, Extend selection instead of deselecting everything first
-    :type extend: bool | None
     :param deselect: Deselect, Remove from selection
-    :type deselect: bool | None
     :param toggle: Toggle Selection, Toggle the selection
-    :type toggle: bool | None
     :param deselect_all: Deselect On Nothing, Deselect all when nothing under the cursor
-    :type deselect_all: bool | None
     :param select_passthrough: Only Select Unselected, Ignore the select action when the element is already selected
-    :type select_passthrough: bool | None
     :param location: Location, Mouse location
-    :type location: collections.abc.Iterable[int] | None
     :param socket_select: Socket Select
-    :type socket_select: bool | None
     :param clear_viewer: Clear Viewer, Deactivate geometry nodes viewer when clicking in empty space
-    :type clear_viewer: bool | None
     """
 
 def select_all(
@@ -1434,11 +1741,9 @@ def select_all(
     /,
     *,
     action: typing.Literal["TOGGLE", "SELECT", "DESELECT", "INVERT"] | None = "TOGGLE",
-):
+) -> None:
     """(De)select all nodes
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param action: Action, Selection action to execute
 
     TOGGLE
@@ -1452,7 +1757,6 @@ def select_all(
 
     INVERT
     Invert -- Invert selection of all elements.
-        :type action: typing.Literal['TOGGLE','SELECT','DESELECT','INVERT'] | None
     """
 
 def select_box(
@@ -1467,23 +1771,15 @@ def select_box(
     ymax: int | None = 0,
     wait_for_input: bool | None = True,
     mode: typing.Literal["SET", "ADD", "SUB"] | None = "SET",
-):
+) -> None:
     """Use box selection to select nodes
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param tweak: Tweak, Only activate when mouse is not over a node (useful for tweak gesture)
-        :type tweak: bool | None
         :param xmin: X Min
-        :type xmin: int | None
         :param xmax: X Max
-        :type xmax: int | None
         :param ymin: Y Min
-        :type ymin: int | None
         :param ymax: Y Max
-        :type ymax: int | None
         :param wait_for_input: Wait for Input
-        :type wait_for_input: bool | None
         :param mode: Mode
 
     SET
@@ -1494,7 +1790,6 @@ def select_box(
 
     SUB
     Subtract -- Subtract existing selection.
-        :type mode: typing.Literal['SET','ADD','SUB'] | None
     """
 
 def select_circle(
@@ -1507,19 +1802,13 @@ def select_circle(
     radius: int | None = 25,
     wait_for_input: bool | None = True,
     mode: typing.Literal["SET", "ADD", "SUB"] | None = "SET",
-):
+) -> None:
     """Use circle selection to select nodes
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param x: X
-        :type x: int | None
         :param y: Y
-        :type y: int | None
         :param radius: Radius
-        :type radius: int | None
         :param wait_for_input: Wait for Input
-        :type wait_for_input: bool | None
         :param mode: Mode
 
     SET
@@ -1530,7 +1819,6 @@ def select_circle(
 
     SUB
     Subtract -- Subtract existing selection.
-        :type mode: typing.Literal['SET','ADD','SUB'] | None
     """
 
 def select_grouped(
@@ -1540,15 +1828,11 @@ def select_grouped(
     *,
     extend: bool | None = False,
     type: typing.Literal["TYPE", "COLOR", "PREFIX", "SUFFIX"] | None = "TYPE",
-):
+) -> None:
     """Select nodes with similar properties
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param extend: Extend, Extend selection instead of deselecting everything first
-    :type extend: bool | None
     :param type: Type
-    :type type: typing.Literal['TYPE','COLOR','PREFIX','SUFFIX'] | None
     """
 
 def select_lasso(
@@ -1562,21 +1846,14 @@ def select_lasso(
     smooth_stroke_factor: float | None = 0.75,
     smooth_stroke_radius: int | None = 35,
     mode: typing.Literal["SET", "ADD", "SUB"] | None = "SET",
-):
+) -> None:
     """Select nodes using lasso selection
 
-        :type execution_context: int | str | None
-        :type undo: bool | None
         :param tweak: Tweak, Only activate when mouse is not over a node (useful for tweak gesture)
-        :type tweak: bool | None
         :param path: Path
-        :type path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None
         :param use_smooth_stroke: Stabilize Stroke, Selection lags behind mouse and follows a smoother path
-        :type use_smooth_stroke: bool | None
         :param smooth_stroke_factor: Smooth Stroke Factor, Higher values gives a smoother stroke
-        :type smooth_stroke_factor: float | None
         :param smooth_stroke_radius: Smooth Stroke Radius, Minimum distance from last point before selection continues
-        :type smooth_stroke_radius: int | None
         :param mode: Mode
 
     SET
@@ -1587,7 +1864,6 @@ def select_lasso(
 
     SUB
     Subtract -- Subtract existing selection.
-        :type mode: typing.Literal['SET','ADD','SUB'] | None
     """
 
 def select_link_viewer(
@@ -1597,34 +1873,26 @@ def select_link_viewer(
     *,
     NODE_OT_select: select | None = None,
     NODE_OT_link_viewer: link_viewer | None = None,
-):
+) -> None:
     """Select node and link it to a viewer node
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param NODE_OT_select: Select, Select the node under the cursor
-    :type NODE_OT_select: select | None
     :param NODE_OT_link_viewer: Link to Viewer Node, Link to viewer node
-    :type NODE_OT_link_viewer: link_viewer | None
     """
 
 def select_linked_from(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Select nodes linked from the selected ones
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select nodes linked from the selected ones"""
 
 def select_linked_to(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Select nodes linked to the selected ones
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Select nodes linked to the selected ones"""
 
 def select_same_type_step(
     execution_context: int | str | None = None,
@@ -1632,31 +1900,67 @@ def select_same_type_step(
     /,
     *,
     prev: bool | None = False,
-):
+) -> None:
     """Activate and view same node type, step by step
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param prev: Previous
-    :type prev: bool | None
     """
 
-def shader_script_update(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
-    """Update shader script node with new sockets and options from the script
+def separate_bundle_item_add(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Add item below active item
+
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def separate_bundle_item_move(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    direction: typing.Literal["UP", "DOWN"] | None = "UP",
+    node_identifier: int | None = 0,
+) -> None:
+    """Move active item
+
+    :param direction: Direction, Move direction
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def separate_bundle_item_remove(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
+    """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
+def shader_script_update(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Update shader script node with new sockets and options from the script"""
+
 def simulation_zone_item_add(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Add item below active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def simulation_zone_item_move(
@@ -1665,24 +1969,120 @@ def simulation_zone_item_move(
     /,
     *,
     direction: typing.Literal["UP", "DOWN"] | None = "UP",
-):
+    node_identifier: int | None = 0,
+) -> None:
     """Move active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param direction: Direction, Move direction
-    :type direction: typing.Literal['UP','DOWN'] | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
     """
 
 def simulation_zone_item_remove(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_identifier: int | None = 0,
+) -> None:
     """Remove active item
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param node_identifier: Node Identifier, Optional identifier of the node to operate on
+    """
+
+def sockets_sync(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    node_name: str = "",
+) -> None:
+    """Update sockets to match what is actually used
+
+    :param node_name: Node Name
+    """
+
+def swap_empty_group(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
+    | None = None,
+) -> None:
+    """Replace active node with an empty group
+
+    :param settings: Settings, Settings to be applied on the newly created node
+    """
+
+def swap_group_asset(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    asset_library_type: bpy.stub_internal.rna_enums.AssetLibraryTypeItems
+    | None = "LOCAL",
+    asset_library_identifier: str = "",
+    relative_asset_identifier: str = "",
+) -> None:
+    """Swap selected nodes with the specified node group asset
+
+    :param asset_library_type: Asset Library Type
+    :param asset_library_identifier: Asset Library Identifier
+    :param relative_asset_identifier: Relative Asset Identifier
+    """
+
+def swap_node(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
+    | None = None,
+    type: str = "",
+    visible_output: str = "",
+) -> None:
+    """Replace the selected nodes with the specified type
+
+    :param settings: Settings, Settings to be applied on the newly created node
+    :param type: Node Type, Node type
+    :param visible_output: Output Name, If provided, all outputs that are named differently will be hidden
+    """
+
+def swap_zone(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    settings: bpy.types.bpy_prop_collection[bl_operators.node.NodeSetting]
+    | None = None,
+    offset: collections.abc.Iterable[float] | None = (150.0, 0.0),
+    input_node_type: str = "",
+    output_node_type: str = "",
+    add_default_geometry_link: bool | None = False,
+) -> None:
+    """Undocumented, consider contributing.
+
+    :param settings: Settings, Settings to be applied on the newly created node
+    :param offset: Offset, Offset of nodes from the cursor when added
+    :param input_node_type: Input Node, Specifies the input node used by the created zone
+    :param output_node_type: Output Node, Specifies the output node used by the created zone
+    :param add_default_geometry_link: Add Geometry Link, When enabled, create a link between geometry sockets in this zone
     """
 
+def test_inlining_shader_nodes(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Create a new inlined shader node tree as is consumed by renderers"""
+
+def toggle_viewer(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Toggle selected viewer node in compositor and geometry nodes"""
+
 def translate_attach(
     execution_context: int | str | None = None,
     undo: bool | None = None,
@@ -1690,15 +2090,11 @@ def translate_attach(
     *,
     TRANSFORM_OT_translate: bpy.ops.transform.translate | None = None,
     NODE_OT_attach: attach | None = None,
-):
+) -> None:
     """Move nodes and attach to frame
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param TRANSFORM_OT_translate: Move, Move selected items
-    :type TRANSFORM_OT_translate: bpy.ops.transform.translate | None
     :param NODE_OT_attach: Attach Nodes, Attach active node to a frame
-    :type NODE_OT_attach: attach | None
     """
 
 def translate_attach_remove_on_cancel(
@@ -1708,39 +2104,38 @@ def translate_attach_remove_on_cancel(
     *,
     TRANSFORM_OT_translate: bpy.ops.transform.translate | None = None,
     NODE_OT_attach: attach | None = None,
-):
+) -> None:
     """Move nodes and attach to frame
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param TRANSFORM_OT_translate: Move, Move selected items
-    :type TRANSFORM_OT_translate: bpy.ops.transform.translate | None
     :param NODE_OT_attach: Attach Nodes, Attach active node to a frame
-    :type NODE_OT_attach: attach | None
     """
 
 def tree_path_parent(
-    execution_context: int | str | None = None, undo: bool | None = None
-):
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+    *,
+    parent_tree_index: int | None = 0,
+) -> None:
     """Go to parent node tree
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
-
-def view_all(execution_context: int | str | None = None, undo: bool | None = None):
-    """Resize view so you can see all nodes
-
-    :type execution_context: int | str | None
-    :type undo: bool | None
+    :param parent_tree_index: Parent Index, Parent index in context path
     """
 
-def view_selected(execution_context: int | str | None = None, undo: bool | None = None):
-    """Resize view so you can see selected nodes
+def view_all(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Resize view so you can see all nodes"""
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
-    """
+def view_selected(
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    /,
+) -> None:
+    """Resize view so you can see selected nodes"""
 
 def viewer_border(
     execution_context: int | str | None = None,
@@ -1752,21 +2147,14 @@ def viewer_border(
     ymin: int | None = 0,
     ymax: int | None = 0,
     wait_for_input: bool | None = True,
-):
+) -> None:
     """Set the boundaries for viewer operations
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param xmin: X Min
-    :type xmin: int | None
     :param xmax: X Max
-    :type xmax: int | None
     :param ymin: Y Min
-    :type ymin: int | None
     :param ymax: Y Max
-    :type ymax: int | None
     :param wait_for_input: Wait for Input
-    :type wait_for_input: bool | None
     """
 
 def viewer_shortcut_get(
@@ -1775,13 +2163,10 @@ def viewer_shortcut_get(
     /,
     *,
     viewer_index: int | None = 0,
-):
-    """Activate a specific compositor viewer node using 1,2,..,9 keys
+) -> None:
+    """Toggle a specific viewer node using 1,2,..,9 keys
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param viewer_index: Viewer Index, Index corresponding to the shortcut, e.g. number key 1 corresponds to index 1 etc..
-    :type viewer_index: int | None
     """
 
 def viewer_shortcut_set(
@@ -1790,11 +2175,8 @@ def viewer_shortcut_set(
     /,
     *,
     viewer_index: int | None = 0,
-):
-    """Create a compositor viewer shortcut for the selected node by pressing ctrl+1,2,..9
+) -> None:
+    """Create a viewer shortcut for the selected node by pressing ctrl+1,2,..9
 
-    :type execution_context: int | str | None
-    :type undo: bool | None
     :param viewer_index: Viewer Index, Index corresponding to the shortcut, e.g. number key 1 corresponds to index 1 etc..
-    :type viewer_index: int | None
     """