# Auto-generated by `python -m gen` — do not edit manually.

from typing import TYPE_CHECKING, Generic, Literal

import bpy

from ...builder import BaseNode, SocketAccessor

from ...types import (
    InputBoolean,
    InputBundle,
    InputColor,
    InputFloat,
    InputFont,
    InputGeometry,
    InputInteger,
    InputMaterial,
    InputMatrix,
    InputMenu,
    InputRotation,
    InputString,
    InputVector,
    InputAny,
)

from ...builder.socket import (
    BooleanSocket,
    BundleSocket,
    ColorSocket,
    FloatSocket,
    FontSocket,
    GeometrySocket,
    IntegerSocket,
    MaterialSocket,
    MatrixSocket,
    MenuSocket,
    RotationSocket,
    StringSocket,
    VectorSocket,
    StringSocketList,
    _T,
    _S,
)

from .._mixins import _BakeMixin

from .._mixins import _HandleModeMixin


class Arc(BaseNode):
    """
    Generate a poly spline arc

    Parameters
    ----------
    resolution : InputInteger
        Resolution
    start : InputVector
        Start
    middle : InputVector
        Middle
    end : InputVector
        End
    radius : InputFloat
        Radius
    start_angle : InputFloat
        Start Angle
    sweep_angle : InputFloat
        Sweep Angle
    offset_angle : InputFloat
        Offset Angle
    connect_center : InputBoolean
        Connect Center
    invert_arc : InputBoolean
        Invert Arc

    Inputs
    ------
    i.resolution : IntegerSocket
        Resolution
    i.start : VectorSocket
        Start
    i.middle : VectorSocket
        Middle
    i.end : VectorSocket
        End
    i.radius : FloatSocket
        Radius
    i.start_angle : FloatSocket
        Start Angle
    i.sweep_angle : FloatSocket
        Sweep Angle
    i.offset_angle : FloatSocket
        Offset Angle
    i.connect_center : BooleanSocket
        Connect Center
    i.invert_arc : BooleanSocket
        Invert Arc

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    o.center : VectorSocket
        Center
    o.normal : VectorSocket
        Normal
    o.radius : FloatSocket
        Radius
    """

    _bl_idname = "GeometryNodeCurveArc"
    node: bpy.types.GeometryNodeCurveArc

    class _Inputs(SocketAccessor):
        resolution: IntegerSocket
        """Resolution"""
        start: VectorSocket
        """Start"""
        middle: VectorSocket
        """Middle"""
        end: VectorSocket
        """End"""
        radius: FloatSocket
        """Radius"""
        start_angle: FloatSocket
        """Start Angle"""
        sweep_angle: FloatSocket
        """Sweep Angle"""
        offset_angle: FloatSocket
        """Offset Angle"""
        connect_center: BooleanSocket
        """Connect Center"""
        invert_arc: BooleanSocket
        """Invert Arc"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        center: VectorSocket
        """Center"""
        normal: VectorSocket
        """Normal"""
        radius: FloatSocket
        """Radius"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        resolution: InputInteger = 16,
        start: InputVector = None,
        middle: InputVector = None,
        end: InputVector = None,
        radius: InputFloat = 1.0,
        start_angle: InputFloat = 0.0,
        sweep_angle: InputFloat = 5.4978,
        offset_angle: InputFloat = 0.0,
        connect_center: InputBoolean = False,
        invert_arc: InputBoolean = False,
        *,
        mode: Literal["POINTS", "RADIUS"] = "RADIUS",
    ):
        super().__init__()
        key_args = {
            "Resolution": resolution,
            "Start": start,
            "Middle": middle,
            "End": end,
            "Radius": radius,
            "Start Angle": start_angle,
            "Sweep Angle": sweep_angle,
            "Offset Angle": offset_angle,
            "Connect Center": connect_center,
            "Invert Arc": invert_arc,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def points(
        cls,
        resolution: InputInteger = 16,
        start: InputVector = None,
        middle: InputVector = None,
        end: InputVector = None,
        offset_angle: InputFloat = 0.0,
        connect_center: InputBoolean = False,
        invert_arc: InputBoolean = False,
    ) -> "Arc":
        """Create Arc with operation 'Points'. Define arc by 3 points on circle. Arc is calculated between start and end points"""
        return cls(
            mode="POINTS",
            resolution=resolution,
            start=start,
            middle=middle,
            end=end,
            offset_angle=offset_angle,
            connect_center=connect_center,
            invert_arc=invert_arc,
        )

    @classmethod
    def radius(
        cls,
        resolution: InputInteger = 16,
        radius: InputFloat = 1.0,
        start_angle: InputFloat = 0.0,
        sweep_angle: InputFloat = 5.4978,
        connect_center: InputBoolean = False,
        invert_arc: InputBoolean = False,
    ) -> "Arc":
        """Create Arc with operation 'Radius'. Define radius with a float"""
        return cls(
            mode="RADIUS",
            resolution=resolution,
            radius=radius,
            start_angle=start_angle,
            sweep_angle=sweep_angle,
            connect_center=connect_center,
            invert_arc=invert_arc,
        )

    @property
    def mode(self) -> Literal["POINTS", "RADIUS"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["POINTS", "RADIUS"]):
        self.node.mode = value


class Bake(_BakeMixin, BaseNode):
    """
    Cache the incoming data so that it can be used without recomputation
    """

    _bl_idname = "GeometryNodeBake"
    node: bpy.types.GeometryNodeBake

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        pass

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...


class BoundingBox(BaseNode):
    """
    Calculate the limits of a geometry's positions and generate a box mesh with those dimensions

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    use_radius : InputBoolean
        Use Radius

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.use_radius : BooleanSocket
        Use Radius

    Outputs
    -------
    o.bounding_box : GeometrySocket
        Bounding Box
    o.min : VectorSocket
        Min
    o.max : VectorSocket
        Max
    """

    _bl_idname = "GeometryNodeBoundBox"
    node: bpy.types.GeometryNodeBoundBox

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        use_radius: BooleanSocket
        """Use Radius"""

    class _Outputs(SocketAccessor):
        bounding_box: GeometrySocket
        """Bounding Box"""
        min: VectorSocket
        """Min"""
        max: VectorSocket
        """Max"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        use_radius: InputBoolean = True,
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Use Radius": use_radius}

        self._establish_links(**key_args)


class BezierSegment(BaseNode):
    """
    Generate a 2D Bézier spline from the given control points and handles

    Parameters
    ----------
    resolution : InputInteger
        Resolution
    start : InputVector
        Start
    start_handle : InputVector
        Start Handle
    end_handle : InputVector
        End Handle
    end : InputVector
        End

    Inputs
    ------
    i.resolution : IntegerSocket
        Resolution
    i.start : VectorSocket
        Start
    i.start_handle : VectorSocket
        Start Handle
    i.end_handle : VectorSocket
        End Handle
    i.end : VectorSocket
        End

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeCurvePrimitiveBezierSegment"
    node: bpy.types.GeometryNodeCurvePrimitiveBezierSegment

    class _Inputs(SocketAccessor):
        resolution: IntegerSocket
        """Resolution"""
        start: VectorSocket
        """Start"""
        start_handle: VectorSocket
        """Start Handle"""
        end_handle: VectorSocket
        """End Handle"""
        end: VectorSocket
        """End"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        resolution: InputInteger = 16,
        start: InputVector = None,
        start_handle: InputVector = None,
        end_handle: InputVector = None,
        end: InputVector = None,
        *,
        mode: Literal["POSITION", "OFFSET"] = "POSITION",
    ):
        super().__init__()
        key_args = {
            "Resolution": resolution,
            "Start": start,
            "Start Handle": start_handle,
            "End Handle": end_handle,
            "End": end,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def position(
        cls,
        resolution: InputInteger = 16,
        start: InputVector = None,
        start_handle: InputVector = None,
        end_handle: InputVector = None,
        end: InputVector = None,
    ) -> "BezierSegment":
        """Create Bézier Segment with operation 'Position'. The start and end handles are fixed positions"""
        return cls(
            mode="POSITION",
            resolution=resolution,
            start=start,
            start_handle=start_handle,
            end_handle=end_handle,
            end=end,
        )

    @classmethod
    def offset(
        cls,
        resolution: InputInteger = 16,
        start: InputVector = None,
        start_handle: InputVector = None,
        end_handle: InputVector = None,
        end: InputVector = None,
    ) -> "BezierSegment":
        """Create Bézier Segment with operation 'Offset'. The start and end handles are offsets from the spline's control points"""
        return cls(
            mode="OFFSET",
            resolution=resolution,
            start=start,
            start_handle=start_handle,
            end_handle=end_handle,
            end=end,
        )

    @property
    def mode(self) -> Literal["POSITION", "OFFSET"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["POSITION", "OFFSET"]):
        self.node.mode = value


class Cone(BaseNode):
    """
    Generate a cone mesh

    Parameters
    ----------
    vertices : InputInteger
        Vertices
    side_segments : InputInteger
        Side Segments
    fill_segments : InputInteger
        Fill Segments
    radius_top : InputFloat
        Radius Top
    radius_bottom : InputFloat
        Radius Bottom
    depth : InputFloat
        Depth

    Inputs
    ------
    i.vertices : IntegerSocket
        Vertices
    i.side_segments : IntegerSocket
        Side Segments
    i.fill_segments : IntegerSocket
        Fill Segments
    i.radius_top : FloatSocket
        Radius Top
    i.radius_bottom : FloatSocket
        Radius Bottom
    i.depth : FloatSocket
        Depth

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    o.top : BooleanSocket
        Top
    o.bottom : BooleanSocket
        Bottom
    o.side : BooleanSocket
        Side
    o.uv_map : VectorSocket
        UV Map
    """

    _bl_idname = "GeometryNodeMeshCone"
    node: bpy.types.GeometryNodeMeshCone

    class _Inputs(SocketAccessor):
        vertices: IntegerSocket
        """Vertices"""
        side_segments: IntegerSocket
        """Side Segments"""
        fill_segments: IntegerSocket
        """Fill Segments"""
        radius_top: FloatSocket
        """Radius Top"""
        radius_bottom: FloatSocket
        """Radius Bottom"""
        depth: FloatSocket
        """Depth"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        top: BooleanSocket
        """Top"""
        bottom: BooleanSocket
        """Bottom"""
        side: BooleanSocket
        """Side"""
        uv_map: VectorSocket
        """UV Map"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        vertices: InputInteger = 32,
        side_segments: InputInteger = 1,
        fill_segments: InputInteger = 1,
        radius_top: InputFloat = 0.0,
        radius_bottom: InputFloat = 1.0,
        depth: InputFloat = 2.0,
        *,
        fill_type: Literal["NONE", "NGON", "TRIANGLE_FAN"] = "NGON",
    ):
        super().__init__()
        key_args = {
            "Vertices": vertices,
            "Side Segments": side_segments,
            "Fill Segments": fill_segments,
            "Radius Top": radius_top,
            "Radius Bottom": radius_bottom,
            "Depth": depth,
        }
        self.fill_type = fill_type
        self._establish_links(**key_args)

    @classmethod
    def none(
        cls,
        vertices: InputInteger = 32,
        side_segments: InputInteger = 1,
        radius_top: InputFloat = 0.0,
        radius_bottom: InputFloat = 1.0,
        depth: InputFloat = 2.0,
    ) -> "Cone":
        """Create Cone with operation 'None'."""
        return cls(
            fill_type="NONE",
            vertices=vertices,
            side_segments=side_segments,
            radius_top=radius_top,
            radius_bottom=radius_bottom,
            depth=depth,
        )

    @classmethod
    def n_gon(
        cls,
        vertices: InputInteger = 32,
        side_segments: InputInteger = 1,
        fill_segments: InputInteger = 1,
        radius_top: InputFloat = 0.0,
        radius_bottom: InputFloat = 1.0,
        depth: InputFloat = 2.0,
    ) -> "Cone":
        """Create Cone with operation 'N-Gon'."""
        return cls(
            fill_type="NGON",
            vertices=vertices,
            side_segments=side_segments,
            fill_segments=fill_segments,
            radius_top=radius_top,
            radius_bottom=radius_bottom,
            depth=depth,
        )

    @classmethod
    def triangles(
        cls,
        vertices: InputInteger = 32,
        side_segments: InputInteger = 1,
        fill_segments: InputInteger = 1,
        radius_top: InputFloat = 0.0,
        radius_bottom: InputFloat = 1.0,
        depth: InputFloat = 2.0,
    ) -> "Cone":
        """Create Cone with operation 'Triangles'."""
        return cls(
            fill_type="TRIANGLE_FAN",
            vertices=vertices,
            side_segments=side_segments,
            fill_segments=fill_segments,
            radius_top=radius_top,
            radius_bottom=radius_bottom,
            depth=depth,
        )

    @property
    def fill_type(self) -> Literal["NONE", "NGON", "TRIANGLE_FAN"]:
        return self.node.fill_type

    @fill_type.setter
    def fill_type(self, value: Literal["NONE", "NGON", "TRIANGLE_FAN"]):
        self.node.fill_type = value


class ConvexHull(BaseNode):
    """
    Create a mesh that encloses all points in the input geometry with the smallest number of points

    Parameters
    ----------
    geometry : InputGeometry
        Geometry

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry

    Outputs
    -------
    o.convex_hull : GeometrySocket
        Convex Hull
    """

    _bl_idname = "GeometryNodeConvexHull"
    node: bpy.types.GeometryNodeConvexHull

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    class _Outputs(SocketAccessor):
        convex_hull: GeometrySocket
        """Convex Hull"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self, geometry: InputGeometry = None):
        super().__init__()
        key_args = {"Geometry": geometry}

        self._establish_links(**key_args)


class Cube(BaseNode):
    """
    Generate a cuboid mesh with variable side lengths and subdivisions

    Parameters
    ----------
    size : InputVector
        Size
    vertices_x : InputInteger
        Vertices X
    vertices_y : InputInteger
        Vertices Y
    vertices_z : InputInteger
        Vertices Z

    Inputs
    ------
    i.size : VectorSocket
        Size
    i.vertices_x : IntegerSocket
        Vertices X
    i.vertices_y : IntegerSocket
        Vertices Y
    i.vertices_z : IntegerSocket
        Vertices Z

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    o.uv_map : VectorSocket
        UV Map
    """

    _bl_idname = "GeometryNodeMeshCube"
    node: bpy.types.GeometryNodeMeshCube

    class _Inputs(SocketAccessor):
        size: VectorSocket
        """Size"""
        vertices_x: IntegerSocket
        """Vertices X"""
        vertices_y: IntegerSocket
        """Vertices Y"""
        vertices_z: IntegerSocket
        """Vertices Z"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        uv_map: VectorSocket
        """UV Map"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        size: InputVector = None,
        vertices_x: InputInteger = 2,
        vertices_y: InputInteger = 2,
        vertices_z: InputInteger = 2,
    ):
        super().__init__()
        key_args = {
            "Size": size,
            "Vertices X": vertices_x,
            "Vertices Y": vertices_y,
            "Vertices Z": vertices_z,
        }

        self._establish_links(**key_args)


class CurveCircle(BaseNode):
    """
    Generate a poly spline circle

    Parameters
    ----------
    resolution : InputInteger
        Resolution
    point_1 : InputVector
        Point 1
    point_2 : InputVector
        Point 2
    point_3 : InputVector
        Point 3
    radius : InputFloat
        Radius

    Inputs
    ------
    i.resolution : IntegerSocket
        Resolution
    i.point_1 : VectorSocket
        Point 1
    i.point_2 : VectorSocket
        Point 2
    i.point_3 : VectorSocket
        Point 3
    i.radius : FloatSocket
        Radius

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    o.center : VectorSocket
        Center
    """

    _bl_idname = "GeometryNodeCurvePrimitiveCircle"
    node: bpy.types.GeometryNodeCurvePrimitiveCircle

    class _Inputs(SocketAccessor):
        resolution: IntegerSocket
        """Resolution"""
        point_1: VectorSocket
        """Point 1"""
        point_2: VectorSocket
        """Point 2"""
        point_3: VectorSocket
        """Point 3"""
        radius: FloatSocket
        """Radius"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        center: VectorSocket
        """Center"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        resolution: InputInteger = 32,
        point_1: InputVector = None,
        point_2: InputVector = None,
        point_3: InputVector = None,
        radius: InputFloat = 1.0,
        *,
        mode: Literal["POINTS", "RADIUS"] = "RADIUS",
    ):
        super().__init__()
        key_args = {
            "Resolution": resolution,
            "Point 1": point_1,
            "Point 2": point_2,
            "Point 3": point_3,
            "Radius": radius,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def points(
        cls,
        resolution: InputInteger = 32,
        point_1: InputVector = None,
        point_2: InputVector = None,
        point_3: InputVector = None,
    ) -> "CurveCircle":
        """Create Curve Circle with operation 'Points'. Define the radius and location with three points"""
        return cls(
            mode="POINTS",
            resolution=resolution,
            point_1=point_1,
            point_2=point_2,
            point_3=point_3,
        )

    @classmethod
    def radius(
        cls, resolution: InputInteger = 32, radius: InputFloat = 1.0
    ) -> "CurveCircle":
        """Create Curve Circle with operation 'Radius'. Define the radius with a float"""
        return cls(mode="RADIUS", resolution=resolution, radius=radius)

    @property
    def mode(self) -> Literal["POINTS", "RADIUS"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["POINTS", "RADIUS"]):
        self.node.mode = value


class CurveLength(BaseNode):
    """
    Retrieve the length of all splines added together

    Parameters
    ----------
    curve : InputGeometry
        Curve

    Inputs
    ------
    i.curve : GeometrySocket
        Curve

    Outputs
    -------
    o.length : FloatSocket
        Length
    """

    _bl_idname = "GeometryNodeCurveLength"
    node: bpy.types.GeometryNodeCurveLength

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    class _Outputs(SocketAccessor):
        length: FloatSocket
        """Length"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self, curve: InputGeometry = None):
        super().__init__()
        key_args = {"Curve": curve}

        self._establish_links(**key_args)


class CurveLine(BaseNode):
    """
    Generate a poly spline line with two points

    Parameters
    ----------
    start : InputVector
        Start
    end : InputVector
        End
    direction : InputVector
        Direction
    length : InputFloat
        Length

    Inputs
    ------
    i.start : VectorSocket
        Start
    i.end : VectorSocket
        End
    i.direction : VectorSocket
        Direction
    i.length : FloatSocket
        Length

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeCurvePrimitiveLine"
    node: bpy.types.GeometryNodeCurvePrimitiveLine

    class _Inputs(SocketAccessor):
        start: VectorSocket
        """Start"""
        end: VectorSocket
        """End"""
        direction: VectorSocket
        """Direction"""
        length: FloatSocket
        """Length"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        start: InputVector = None,
        end: InputVector = None,
        direction: InputVector = None,
        length: InputFloat = 1.0,
        *,
        mode: Literal["POINTS", "DIRECTION"] = "POINTS",
    ):
        super().__init__()
        key_args = {
            "Start": start,
            "End": end,
            "Direction": direction,
            "Length": length,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def points(cls, start: InputVector = None, end: InputVector = None) -> "CurveLine":
        """Create Curve Line with operation 'Points'. Define the start and end points of the line"""
        return cls(mode="POINTS", start=start, end=end)

    @classmethod
    def direction(
        cls,
        start: InputVector = None,
        direction: InputVector = None,
        length: InputFloat = 1.0,
    ) -> "CurveLine":
        """Create Curve Line with operation 'Direction'. Define a line with a start point, direction and length"""
        return cls(mode="DIRECTION", start=start, direction=direction, length=length)

    @property
    def mode(self) -> Literal["POINTS", "DIRECTION"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["POINTS", "DIRECTION"]):
        self.node.mode = value


class CurveToMesh(BaseNode):
    """
    Convert curves into a mesh, optionally with a custom profile shape defined by curves

    Parameters
    ----------
    curve : InputGeometry
        Curve
    profile_curve : InputGeometry
        Profile Curve
    scale : InputFloat
        Scale
    fill_caps : InputBoolean
        Fill Caps

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.profile_curve : GeometrySocket
        Profile Curve
    i.scale : FloatSocket
        Scale
    i.fill_caps : BooleanSocket
        Fill Caps

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeCurveToMesh"
    node: bpy.types.GeometryNodeCurveToMesh

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        profile_curve: GeometrySocket
        """Profile Curve"""
        scale: FloatSocket
        """Scale"""
        fill_caps: BooleanSocket
        """Fill Caps"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        profile_curve: InputGeometry = None,
        scale: InputFloat = 1.0,
        fill_caps: InputBoolean = False,
    ):
        super().__init__()
        key_args = {
            "Curve": curve,
            "Profile Curve": profile_curve,
            "Scale": scale,
            "Fill Caps": fill_caps,
        }

        self._establish_links(**key_args)


class CurveToPoints(BaseNode):
    """
    Generate a point cloud by sampling positions along curves

    Parameters
    ----------
    curve : InputGeometry
        Curve
    count : InputInteger
        Count
    length : InputFloat
        Length

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.count : IntegerSocket
        Count
    i.length : FloatSocket
        Length

    Outputs
    -------
    o.points : GeometrySocket
        Points
    o.tangent : VectorSocket
        Tangent
    o.normal : VectorSocket
        Normal
    o.rotation : RotationSocket
        Rotation
    """

    _bl_idname = "GeometryNodeCurveToPoints"
    node: bpy.types.GeometryNodeCurveToPoints

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        count: IntegerSocket
        """Count"""
        length: FloatSocket
        """Length"""

    class _Outputs(SocketAccessor):
        points: GeometrySocket
        """Points"""
        tangent: VectorSocket
        """Tangent"""
        normal: VectorSocket
        """Normal"""
        rotation: RotationSocket
        """Rotation"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        count: InputInteger = 10,
        length: InputFloat = 0.1,
        *,
        mode: Literal["EVALUATED", "COUNT", "LENGTH"] = "COUNT",
    ):
        super().__init__()
        key_args = {"Curve": curve, "Count": count, "Length": length}
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def evaluated(cls, curve: InputGeometry = None) -> "CurveToPoints":
        """Create Curve to Points with operation 'Evaluated'. Create points from the curve's evaluated points, based on the resolution attribute for NURBS and Bézier splines"""
        return cls(mode="EVALUATED", curve=curve)

    @classmethod
    def count(
        cls, curve: InputGeometry = None, count: InputInteger = 10
    ) -> "CurveToPoints":
        """Create Curve to Points with operation 'Count'. Sample each spline by evenly distributing the specified number of points"""
        return cls(mode="COUNT", curve=curve, count=count)

    @classmethod
    def length(
        cls, curve: InputGeometry = None, length: InputFloat = 0.1
    ) -> "CurveToPoints":
        """Create Curve to Points with operation 'Length'. Sample each spline by splitting it into segments with the specified length"""
        return cls(mode="LENGTH", curve=curve, length=length)

    @property
    def mode(self) -> Literal["EVALUATED", "COUNT", "LENGTH"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["EVALUATED", "COUNT", "LENGTH"]):
        self.node.mode = value


class CurvesToGreasePencil(BaseNode):
    """
    Convert the curves in each top-level instance into Grease Pencil layer

    Parameters
    ----------
    curves : InputGeometry
        Curves
    selection : InputBoolean
        Selection
    instances_as_layers : InputBoolean
        Instances as Layers

    Inputs
    ------
    i.curves : GeometrySocket
        Curves
    i.selection : BooleanSocket
        Selection
    i.instances_as_layers : BooleanSocket
        Instances as Layers

    Outputs
    -------
    o.grease_pencil : GeometrySocket
        Grease Pencil
    """

    _bl_idname = "GeometryNodeCurvesToGreasePencil"
    node: bpy.types.GeometryNodeCurvesToGreasePencil

    class _Inputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""
        selection: BooleanSocket
        """Selection"""
        instances_as_layers: BooleanSocket
        """Instances as Layers"""

    class _Outputs(SocketAccessor):
        grease_pencil: GeometrySocket
        """Grease Pencil"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curves: InputGeometry = None,
        selection: InputBoolean = True,
        instances_as_layers: InputBoolean = True,
    ):
        super().__init__()
        key_args = {
            "Curves": curves,
            "Selection": selection,
            "Instances as Layers": instances_as_layers,
        }

        self._establish_links(**key_args)


class Cylinder(BaseNode):
    """
    Generate a cylinder mesh

    Parameters
    ----------
    vertices : InputInteger
        Vertices
    side_segments : InputInteger
        Side Segments
    fill_segments : InputInteger
        Fill Segments
    radius : InputFloat
        Radius
    depth : InputFloat
        Depth

    Inputs
    ------
    i.vertices : IntegerSocket
        Vertices
    i.side_segments : IntegerSocket
        Side Segments
    i.fill_segments : IntegerSocket
        Fill Segments
    i.radius : FloatSocket
        Radius
    i.depth : FloatSocket
        Depth

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    o.top : BooleanSocket
        Top
    o.side : BooleanSocket
        Side
    o.bottom : BooleanSocket
        Bottom
    o.uv_map : VectorSocket
        UV Map
    """

    _bl_idname = "GeometryNodeMeshCylinder"
    node: bpy.types.GeometryNodeMeshCylinder

    class _Inputs(SocketAccessor):
        vertices: IntegerSocket
        """Vertices"""
        side_segments: IntegerSocket
        """Side Segments"""
        fill_segments: IntegerSocket
        """Fill Segments"""
        radius: FloatSocket
        """Radius"""
        depth: FloatSocket
        """Depth"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        top: BooleanSocket
        """Top"""
        side: BooleanSocket
        """Side"""
        bottom: BooleanSocket
        """Bottom"""
        uv_map: VectorSocket
        """UV Map"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        vertices: InputInteger = 32,
        side_segments: InputInteger = 1,
        fill_segments: InputInteger = 1,
        radius: InputFloat = 1.0,
        depth: InputFloat = 2.0,
        *,
        fill_type: Literal["NONE", "NGON", "TRIANGLE_FAN"] = "NGON",
    ):
        super().__init__()
        key_args = {
            "Vertices": vertices,
            "Side Segments": side_segments,
            "Fill Segments": fill_segments,
            "Radius": radius,
            "Depth": depth,
        }
        self.fill_type = fill_type
        self._establish_links(**key_args)

    @classmethod
    def none(
        cls,
        vertices: InputInteger = 32,
        side_segments: InputInteger = 1,
        radius: InputFloat = 1.0,
        depth: InputFloat = 2.0,
    ) -> "Cylinder":
        """Create Cylinder with operation 'None'."""
        return cls(
            fill_type="NONE",
            vertices=vertices,
            side_segments=side_segments,
            radius=radius,
            depth=depth,
        )

    @classmethod
    def n_gon(
        cls,
        vertices: InputInteger = 32,
        side_segments: InputInteger = 1,
        fill_segments: InputInteger = 1,
        radius: InputFloat = 1.0,
        depth: InputFloat = 2.0,
    ) -> "Cylinder":
        """Create Cylinder with operation 'N-Gon'."""
        return cls(
            fill_type="NGON",
            vertices=vertices,
            side_segments=side_segments,
            fill_segments=fill_segments,
            radius=radius,
            depth=depth,
        )

    @classmethod
    def triangles(
        cls,
        vertices: InputInteger = 32,
        side_segments: InputInteger = 1,
        fill_segments: InputInteger = 1,
        radius: InputFloat = 1.0,
        depth: InputFloat = 2.0,
    ) -> "Cylinder":
        """Create Cylinder with operation 'Triangles'."""
        return cls(
            fill_type="TRIANGLE_FAN",
            vertices=vertices,
            side_segments=side_segments,
            fill_segments=fill_segments,
            radius=radius,
            depth=depth,
        )

    @property
    def fill_type(self) -> Literal["NONE", "NGON", "TRIANGLE_FAN"]:
        return self.node.fill_type

    @fill_type.setter
    def fill_type(self, value: Literal["NONE", "NGON", "TRIANGLE_FAN"]):
        self.node.fill_type = value


class DeformCurvesOnSurface(BaseNode):
    """
    Translate and rotate curves based on changes between the object's original and evaluated surface mesh

    Parameters
    ----------
    curves : InputGeometry
        Curves

    Inputs
    ------
    i.curves : GeometrySocket
        Curves

    Outputs
    -------
    o.curves : GeometrySocket
        Curves
    """

    _bl_idname = "GeometryNodeDeformCurvesOnSurface"
    node: bpy.types.GeometryNodeDeformCurvesOnSurface

    class _Inputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""

    class _Outputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self, curves: InputGeometry = None):
        super().__init__()
        key_args = {"Curves": curves}

        self._establish_links(**key_args)


class DeleteGeometry(BaseNode):
    """
    Remove selected elements of a geometry

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeDeleteGeometry"
    node: bpy.types.GeometryNodeDeleteGeometry

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        *,
        mode: Literal["ALL", "EDGE_FACE", "ONLY_FACE"] = "ALL",
        domain: Literal[
            "POINT", "EDGE", "FACE", "CURVE", "INSTANCE", "LAYER"
        ] = "POINT",
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Selection": selection}
        self.mode = mode
        self.domain = domain
        self._establish_links(**key_args)

    @classmethod
    def all(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "DeleteGeometry":
        """Create Delete Geometry with operation 'All'."""
        return cls(mode="ALL", geometry=geometry, selection=selection)

    @classmethod
    def only_edges_faces(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "DeleteGeometry":
        """Create Delete Geometry with operation 'Only Edges & Faces'."""
        return cls(mode="EDGE_FACE", geometry=geometry, selection=selection)

    @classmethod
    def only_faces(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "DeleteGeometry":
        """Create Delete Geometry with operation 'Only Faces'."""
        return cls(mode="ONLY_FACE", geometry=geometry, selection=selection)

    @classmethod
    def point(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "DeleteGeometry":
        """Create Delete Geometry with operation 'Point'. Attribute on point"""
        return cls(domain="POINT", geometry=geometry, selection=selection)

    @classmethod
    def edge(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "DeleteGeometry":
        """Create Delete Geometry with operation 'Edge'. Attribute on mesh edge"""
        return cls(domain="EDGE", geometry=geometry, selection=selection)

    @classmethod
    def face(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "DeleteGeometry":
        """Create Delete Geometry with operation 'Face'. Attribute on mesh faces"""
        return cls(domain="FACE", geometry=geometry, selection=selection)

    @classmethod
    def spline(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "DeleteGeometry":
        """Create Delete Geometry with operation 'Spline'. Attribute on spline"""
        return cls(domain="CURVE", geometry=geometry, selection=selection)

    @classmethod
    def instance(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "DeleteGeometry":
        """Create Delete Geometry with operation 'Instance'. Attribute on instance"""
        return cls(domain="INSTANCE", geometry=geometry, selection=selection)

    @classmethod
    def layer(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "DeleteGeometry":
        """Create Delete Geometry with operation 'Layer'. Attribute on Grease Pencil layer"""
        return cls(domain="LAYER", geometry=geometry, selection=selection)

    @property
    def mode(self) -> Literal["ALL", "EDGE_FACE", "ONLY_FACE"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["ALL", "EDGE_FACE", "ONLY_FACE"]):
        self.node.mode = value

    @property
    def domain(self) -> Literal["POINT", "EDGE", "FACE", "CURVE", "INSTANCE", "LAYER"]:
        return self.node.domain

    @domain.setter
    def domain(
        self, value: Literal["POINT", "EDGE", "FACE", "CURVE", "INSTANCE", "LAYER"]
    ):
        self.node.domain = value


class DistributePointsOnFaces(BaseNode):
    """
    Generate points spread out on the surface of a mesh

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    selection : InputBoolean
        Selection
    distance_min : InputFloat
        Distance Min
    density_max : InputFloat
        Density Max
    density : InputFloat
        Density
    density_factor : InputFloat
        Density Factor
    seed : InputInteger
        Seed

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.selection : BooleanSocket
        Selection
    i.distance_min : FloatSocket
        Distance Min
    i.density_max : FloatSocket
        Density Max
    i.density : FloatSocket
        Density
    i.density_factor : FloatSocket
        Density Factor
    i.seed : IntegerSocket
        Seed

    Outputs
    -------
    o.points : GeometrySocket
        Points
    o.normal : VectorSocket
        Normal
    o.rotation : RotationSocket
        Rotation
    """

    _bl_idname = "GeometryNodeDistributePointsOnFaces"
    node: bpy.types.GeometryNodeDistributePointsOnFaces

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        selection: BooleanSocket
        """Selection"""
        distance_min: FloatSocket
        """Distance Min"""
        density_max: FloatSocket
        """Density Max"""
        density: FloatSocket
        """Density"""
        density_factor: FloatSocket
        """Density Factor"""
        seed: IntegerSocket
        """Seed"""

    class _Outputs(SocketAccessor):
        points: GeometrySocket
        """Points"""
        normal: VectorSocket
        """Normal"""
        rotation: RotationSocket
        """Rotation"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        distance_min: InputFloat = 0.0,
        density_max: InputFloat = 10.0,
        density: InputFloat = 10.0,
        density_factor: InputFloat = 1.0,
        seed: InputInteger = 0,
        *,
        distribute_method: Literal["RANDOM", "POISSON"] = "RANDOM",
        use_legacy_normal: bool = False,
    ):
        super().__init__()
        key_args = {
            "Mesh": mesh,
            "Selection": selection,
            "Distance Min": distance_min,
            "Density Max": density_max,
            "Density": density,
            "Density Factor": density_factor,
            "Seed": seed,
        }
        self.distribute_method = distribute_method
        self.use_legacy_normal = use_legacy_normal
        self._establish_links(**key_args)

    @property
    def distribute_method(self) -> Literal["RANDOM", "POISSON"]:
        return self.node.distribute_method

    @distribute_method.setter
    def distribute_method(self, value: Literal["RANDOM", "POISSON"]):
        self.node.distribute_method = value

    @property
    def use_legacy_normal(self) -> bool:
        return self.node.use_legacy_normal

    @use_legacy_normal.setter
    def use_legacy_normal(self, value: bool):
        self.node.use_legacy_normal = value


class DualMesh(BaseNode):
    """
    Convert Faces into vertices and vertices into faces

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    keep_boundaries : InputBoolean
        Keep Boundaries

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.keep_boundaries : BooleanSocket
        Keep Boundaries

    Outputs
    -------
    o.dual_mesh : GeometrySocket
        Dual Mesh
    """

    _bl_idname = "GeometryNodeDualMesh"
    node: bpy.types.GeometryNodeDualMesh

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        keep_boundaries: BooleanSocket
        """Keep Boundaries"""

    class _Outputs(SocketAccessor):
        dual_mesh: GeometrySocket
        """Dual Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        keep_boundaries: InputBoolean = False,
    ):
        super().__init__()
        key_args = {"Mesh": mesh, "Keep Boundaries": keep_boundaries}

        self._establish_links(**key_args)


class DuplicateElements(BaseNode):
    """
    Generate an arbitrary number copies of each selected input element

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    amount : InputInteger
        Amount

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.amount : IntegerSocket
        Amount

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    o.duplicate_index : IntegerSocket
        Duplicate Index
    """

    _bl_idname = "GeometryNodeDuplicateElements"
    node: bpy.types.GeometryNodeDuplicateElements

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        amount: IntegerSocket
        """Amount"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        duplicate_index: IntegerSocket
        """Duplicate Index"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        amount: InputInteger = 1,
        *,
        domain: Literal[
            "POINT", "EDGE", "FACE", "SPLINE", "LAYER", "INSTANCE"
        ] = "POINT",
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Selection": selection, "Amount": amount}
        self.domain = domain
        self._establish_links(**key_args)

    @classmethod
    def point(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        amount: InputInteger = 1,
    ) -> "DuplicateElements":
        """Create Duplicate Elements with operation 'Point'."""
        return cls(
            domain="POINT", geometry=geometry, selection=selection, amount=amount
        )

    @classmethod
    def edge(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        amount: InputInteger = 1,
    ) -> "DuplicateElements":
        """Create Duplicate Elements with operation 'Edge'."""
        return cls(domain="EDGE", geometry=geometry, selection=selection, amount=amount)

    @classmethod
    def face(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        amount: InputInteger = 1,
    ) -> "DuplicateElements":
        """Create Duplicate Elements with operation 'Face'."""
        return cls(domain="FACE", geometry=geometry, selection=selection, amount=amount)

    @classmethod
    def spline(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        amount: InputInteger = 1,
    ) -> "DuplicateElements":
        """Create Duplicate Elements with operation 'Spline'."""
        return cls(
            domain="SPLINE", geometry=geometry, selection=selection, amount=amount
        )

    @classmethod
    def layer(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        amount: InputInteger = 1,
    ) -> "DuplicateElements":
        """Create Duplicate Elements with operation 'Layer'."""
        return cls(
            domain="LAYER", geometry=geometry, selection=selection, amount=amount
        )

    @classmethod
    def instance(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        amount: InputInteger = 1,
    ) -> "DuplicateElements":
        """Create Duplicate Elements with operation 'Instance'."""
        return cls(
            domain="INSTANCE", geometry=geometry, selection=selection, amount=amount
        )

    @property
    def domain(self) -> Literal["POINT", "EDGE", "FACE", "SPLINE", "LAYER", "INSTANCE"]:
        return self.node.domain

    @domain.setter
    def domain(
        self, value: Literal["POINT", "EDGE", "FACE", "SPLINE", "LAYER", "INSTANCE"]
    ):
        self.node.domain = value


class EdgePathsToCurves(BaseNode):
    """
    Output curves following paths across mesh edges

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    start_vertices : InputBoolean
        Start Vertices
    next_vertex_index : InputInteger
        Next Vertex Index

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.start_vertices : BooleanSocket
        Start Vertices
    i.next_vertex_index : IntegerSocket
        Next Vertex Index

    Outputs
    -------
    o.curves : GeometrySocket
        Curves
    """

    _bl_idname = "GeometryNodeEdgePathsToCurves"
    node: bpy.types.GeometryNodeEdgePathsToCurves

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        start_vertices: BooleanSocket
        """Start Vertices"""
        next_vertex_index: IntegerSocket
        """Next Vertex Index"""

    class _Outputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        start_vertices: InputBoolean = True,
        next_vertex_index: InputInteger = -1,
    ):
        super().__init__()
        key_args = {
            "Mesh": mesh,
            "Start Vertices": start_vertices,
            "Next Vertex Index": next_vertex_index,
        }

        self._establish_links(**key_args)


class ExtrudeMesh(BaseNode):
    """
    Generate new vertices, edges, or faces from selected elements and move them based on an offset while keeping them connected by their boundary

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    selection : InputBoolean
        Selection
    offset : InputVector
        Offset
    offset_scale : InputFloat
        Offset Scale
    individual : InputBoolean
        Individual

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.selection : BooleanSocket
        Selection
    i.offset : VectorSocket
        Offset
    i.offset_scale : FloatSocket
        Offset Scale
    i.individual : BooleanSocket
        Individual

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    o.top : BooleanSocket
        Top
    o.side : BooleanSocket
        Side
    """

    _bl_idname = "GeometryNodeExtrudeMesh"
    node: bpy.types.GeometryNodeExtrudeMesh

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        selection: BooleanSocket
        """Selection"""
        offset: VectorSocket
        """Offset"""
        offset_scale: FloatSocket
        """Offset Scale"""
        individual: BooleanSocket
        """Individual"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        top: BooleanSocket
        """Top"""
        side: BooleanSocket
        """Side"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        offset: InputVector = None,
        offset_scale: InputFloat = 1.0,
        individual: InputBoolean = True,
        *,
        mode: Literal["VERTICES", "EDGES", "FACES"] = "FACES",
    ):
        super().__init__()
        key_args = {
            "Mesh": mesh,
            "Selection": selection,
            "Offset": offset,
            "Offset Scale": offset_scale,
            "Individual": individual,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def vertices(
        cls,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        offset: InputVector = None,
        offset_scale: InputFloat = 1.0,
    ) -> "ExtrudeMesh":
        """Create Extrude Mesh with operation 'Vertices'."""
        return cls(
            mode="VERTICES",
            mesh=mesh,
            selection=selection,
            offset=offset,
            offset_scale=offset_scale,
        )

    @classmethod
    def edges(
        cls,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        offset: InputVector = None,
        offset_scale: InputFloat = 1.0,
    ) -> "ExtrudeMesh":
        """Create Extrude Mesh with operation 'Edges'."""
        return cls(
            mode="EDGES",
            mesh=mesh,
            selection=selection,
            offset=offset,
            offset_scale=offset_scale,
        )

    @classmethod
    def faces(
        cls,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        offset: InputVector = None,
        offset_scale: InputFloat = 1.0,
        individual: InputBoolean = True,
    ) -> "ExtrudeMesh":
        """Create Extrude Mesh with operation 'Faces'."""
        return cls(
            mode="FACES",
            mesh=mesh,
            selection=selection,
            offset=offset,
            offset_scale=offset_scale,
            individual=individual,
        )

    @property
    def mode(self) -> Literal["VERTICES", "EDGES", "FACES"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["VERTICES", "EDGES", "FACES"]):
        self.node.mode = value


class FillCurve(BaseNode):
    """
    Generate a mesh on the XY plane with faces on the inside of input curves

    Parameters
    ----------
    curve : InputGeometry
        Curve
    group_id : InputInteger
        Group ID
    mode : InputMenu | Literal['Triangles', 'N-gons']
        Mode
    fill_rule : InputMenu | Literal['Even-Odd', 'Non-Zero']
        Fill Rule

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.group_id : IntegerSocket
        Group ID
    i.mode : MenuSocket
        Mode
    i.fill_rule : MenuSocket
        Fill Rule

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeFillCurve"
    node: bpy.types.GeometryNodeFillCurve

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        group_id: IntegerSocket
        """Group ID"""
        mode: MenuSocket
        """Mode"""
        fill_rule: MenuSocket
        """Fill Rule"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        group_id: InputInteger = 0,
        mode: InputMenu | Literal["Triangles", "N-gons"] = "Triangles",
        fill_rule: InputMenu | Literal["Even-Odd", "Non-Zero"] = "Even-Odd",
    ):
        super().__init__()
        key_args = {
            "Curve": curve,
            "Group ID": group_id,
            "Mode": mode,
            "Fill Rule": fill_rule,
        }

        self._establish_links(**key_args)


class FilletCurve(BaseNode):
    """
    Round corners by generating circular arcs on each control point

    Parameters
    ----------
    curve : InputGeometry
        Curve
    radius : InputFloat
        Radius
    limit_radius : InputBoolean
        Limit Radius
    mode : InputMenu | Literal['Bézier', 'Poly']
        Mode
    count : InputInteger
        Count

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.radius : FloatSocket
        Radius
    i.limit_radius : BooleanSocket
        Limit Radius
    i.mode : MenuSocket
        Mode
    i.count : IntegerSocket
        Count

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeFilletCurve"
    node: bpy.types.GeometryNodeFilletCurve

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        radius: FloatSocket
        """Radius"""
        limit_radius: BooleanSocket
        """Limit Radius"""
        mode: MenuSocket
        """Mode"""
        count: IntegerSocket
        """Count"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        radius: InputFloat = 0.25,
        limit_radius: InputBoolean = False,
        mode: InputMenu | Literal["Bézier", "Poly"] = "Bézier",
        count: InputInteger = 1,
    ):
        super().__init__()
        key_args = {
            "Curve": curve,
            "Radius": radius,
            "Limit Radius": limit_radius,
            "Mode": mode,
            "Count": count,
        }

        self._establish_links(**key_args)


class FlipFaces(BaseNode):
    """
    Reverse the order of the vertices and edges of selected faces, flipping their normal direction

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    selection : InputBoolean
        Selection

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.selection : BooleanSocket
        Selection

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeFlipFaces"
    node: bpy.types.GeometryNodeFlipFaces

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        selection: BooleanSocket
        """Selection"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
    ):
        super().__init__()
        key_args = {"Mesh": mesh, "Selection": selection}

        self._establish_links(**key_args)


class GeometryProximity(BaseNode):
    """
    Compute the closest location on the target geometry

    Parameters
    ----------
    target : InputGeometry
        Geometry
    group_id : InputInteger
        Group ID
    source_position : InputVector
        Sample Position
    sample_group_id : InputInteger
        Sample Group ID

    Inputs
    ------
    i.target : GeometrySocket
        Geometry
    i.group_id : IntegerSocket
        Group ID
    i.source_position : VectorSocket
        Sample Position
    i.sample_group_id : IntegerSocket
        Sample Group ID

    Outputs
    -------
    o.position : VectorSocket
        Position
    o.distance : FloatSocket
        Distance
    o.is_valid : BooleanSocket
        Is Valid
    """

    _bl_idname = "GeometryNodeProximity"
    node: bpy.types.GeometryNodeProximity

    class _Inputs(SocketAccessor):
        target: GeometrySocket
        """Geometry"""
        group_id: IntegerSocket
        """Group ID"""
        source_position: VectorSocket
        """Sample Position"""
        sample_group_id: IntegerSocket
        """Sample Group ID"""

    class _Outputs(SocketAccessor):
        position: VectorSocket
        """Position"""
        distance: FloatSocket
        """Distance"""
        is_valid: BooleanSocket
        """Is Valid"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        target: InputGeometry = None,
        group_id: InputInteger = 0,
        source_position: InputVector = None,
        sample_group_id: InputInteger = 0,
        *,
        target_element: Literal["POINTS", "EDGES", "FACES"] = "FACES",
    ):
        super().__init__()
        key_args = {
            "Target": target,
            "Group ID": group_id,
            "Source Position": source_position,
            "Sample Group ID": sample_group_id,
        }
        self.target_element = target_element
        self._establish_links(**key_args)

    @property
    def target_element(self) -> Literal["POINTS", "EDGES", "FACES"]:
        return self.node.target_element

    @target_element.setter
    def target_element(self, value: Literal["POINTS", "EDGES", "FACES"]):
        self.node.target_element = value


class GetGeometryBundle(BaseNode):
    """
    Get the bundle of a geometry

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    remove : InputBoolean
        Remove

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.remove : BooleanSocket
        Remove

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    o.bundle : BundleSocket
        Bundle
    """

    _bl_idname = "GeometryNodeGetGeometryBundle"
    node: bpy.types.GeometryNodeGetGeometryBundle

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        remove: BooleanSocket
        """Remove"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        bundle: BundleSocket
        """Bundle"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        remove: InputBoolean = False,
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Remove": remove}

        self._establish_links(**key_args)


class GetGeometryComponent(BaseNode):
    """
    Get a single component of a geometry

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    type : InputMenu | Literal['Mesh', 'Point Cloud', 'Curve', 'Instances', 'Grease Pencil', 'Volume']
        Type
    remove : InputBoolean
        Remove

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.type : MenuSocket
        Type
    i.remove : BooleanSocket
        Remove

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    o.component : GeometrySocket
        Component
    o.exists : BooleanSocket
        Exists
    """

    _bl_idname = "GeometryNodeGetGeometryComponent"
    node: bpy.types.GeometryNodeGetGeometryComponent  # ty: ignore[unresolved-attribute]

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        type: MenuSocket
        """Type"""
        remove: BooleanSocket
        """Remove"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        component: GeometrySocket
        """Component"""
        exists: BooleanSocket
        """Exists"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        type: InputMenu
        | Literal[
            "Mesh", "Point Cloud", "Curve", "Instances", "Grease Pencil", "Volume"
        ] = "Mesh",
        remove: InputBoolean = True,
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Type": type, "Remove": remove}

        self._establish_links(**key_args)

    @classmethod
    def mesh(
        cls, geometry: InputGeometry = None, remove: InputBoolean = True
    ) -> "GetGeometryComponent":
        """Create Get Geometry Component node with type 'Mesh'."""
        return cls(geometry=geometry, remove=remove, type="Mesh")

    @classmethod
    def point_cloud(
        cls, geometry: InputGeometry = None, remove: InputBoolean = True
    ) -> "GetGeometryComponent":
        """Create Get Geometry Component node with type 'Point Cloud'."""
        return cls(geometry=geometry, remove=remove, type="Point Cloud")

    @classmethod
    def curve(
        cls, geometry: InputGeometry = None, remove: InputBoolean = True
    ) -> "GetGeometryComponent":
        """Create Get Geometry Component node with type 'Curve'."""
        return cls(geometry=geometry, remove=remove, type="Curve")

    @classmethod
    def instances(
        cls, geometry: InputGeometry = None, remove: InputBoolean = True
    ) -> "GetGeometryComponent":
        """Create Get Geometry Component node with type 'Instances'."""
        return cls(geometry=geometry, remove=remove, type="Instances")

    @classmethod
    def grease_pencil(
        cls, geometry: InputGeometry = None, remove: InputBoolean = True
    ) -> "GetGeometryComponent":
        """Create Get Geometry Component node with type 'Grease Pencil'."""
        return cls(geometry=geometry, remove=remove, type="Grease Pencil")

    @classmethod
    def volume(
        cls, geometry: InputGeometry = None, remove: InputBoolean = True
    ) -> "GetGeometryComponent":
        """Create Get Geometry Component node with type 'Volume'."""
        return cls(geometry=geometry, remove=remove, type="Volume")


class GreasePencilToCurves(BaseNode):
    """
    Convert Grease Pencil layers into curve instances

    Parameters
    ----------
    grease_pencil : InputGeometry
        Grease Pencil
    selection : InputBoolean
        Selection
    layers_as_instances : InputBoolean
        Layers as Instances

    Inputs
    ------
    i.grease_pencil : GeometrySocket
        Grease Pencil
    i.selection : BooleanSocket
        Selection
    i.layers_as_instances : BooleanSocket
        Layers as Instances

    Outputs
    -------
    o.curves : GeometrySocket
        Curves
    """

    _bl_idname = "GeometryNodeGreasePencilToCurves"
    node: bpy.types.GeometryNodeGreasePencilToCurves

    class _Inputs(SocketAccessor):
        grease_pencil: GeometrySocket
        """Grease Pencil"""
        selection: BooleanSocket
        """Selection"""
        layers_as_instances: BooleanSocket
        """Layers as Instances"""

    class _Outputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        grease_pencil: InputGeometry = None,
        selection: InputBoolean = True,
        layers_as_instances: InputBoolean = True,
    ):
        super().__init__()
        key_args = {
            "Grease Pencil": grease_pencil,
            "Selection": selection,
            "Layers as Instances": layers_as_instances,
        }

        self._establish_links(**key_args)


class Grid(BaseNode):
    """
    Generate a planar mesh on the XY plane

    Parameters
    ----------
    size_x : InputFloat
        Size X
    size_y : InputFloat
        Size Y
    vertices_x : InputInteger
        Vertices X
    vertices_y : InputInteger
        Vertices Y

    Inputs
    ------
    i.size_x : FloatSocket
        Size X
    i.size_y : FloatSocket
        Size Y
    i.vertices_x : IntegerSocket
        Vertices X
    i.vertices_y : IntegerSocket
        Vertices Y

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    o.uv_map : VectorSocket
        UV Map
    """

    _bl_idname = "GeometryNodeMeshGrid"
    node: bpy.types.GeometryNodeMeshGrid

    class _Inputs(SocketAccessor):
        size_x: FloatSocket
        """Size X"""
        size_y: FloatSocket
        """Size Y"""
        vertices_x: IntegerSocket
        """Vertices X"""
        vertices_y: IntegerSocket
        """Vertices Y"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        uv_map: VectorSocket
        """UV Map"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        size_x: InputFloat = 1.0,
        size_y: InputFloat = 1.0,
        vertices_x: InputInteger = 3,
        vertices_y: InputInteger = 3,
    ):
        super().__init__()
        key_args = {
            "Size X": size_x,
            "Size Y": size_y,
            "Vertices X": vertices_x,
            "Vertices Y": vertices_y,
        }

        self._establish_links(**key_args)


class IcoSphere(BaseNode):
    """
    Generate a spherical mesh that consists of equally sized triangles

    Parameters
    ----------
    radius : InputFloat
        Radius
    subdivisions : InputInteger
        Subdivisions

    Inputs
    ------
    i.radius : FloatSocket
        Radius
    i.subdivisions : IntegerSocket
        Subdivisions

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    o.uv_map : VectorSocket
        UV Map
    """

    _bl_idname = "GeometryNodeMeshIcoSphere"
    node: bpy.types.GeometryNodeMeshIcoSphere

    class _Inputs(SocketAccessor):
        radius: FloatSocket
        """Radius"""
        subdivisions: IntegerSocket
        """Subdivisions"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        uv_map: VectorSocket
        """UV Map"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        radius: InputFloat = 1.0,
        subdivisions: InputInteger = 1,
    ):
        super().__init__()
        key_args = {"Radius": radius, "Subdivisions": subdivisions}

        self._establish_links(**key_args)


class InstanceOnPoints(BaseNode):
    """
    Generate a reference to geometry at each of the input points, without duplicating its underlying data

    Parameters
    ----------
    points : InputGeometry
        Points
    selection : InputBoolean
        Selection
    instance : InputGeometry
        Instance
    pick_instance : InputBoolean
        Pick Instance
    instance_index : InputInteger
        Instance Index
    rotation : InputRotation
        Rotation
    scale : InputVector
        Scale

    Inputs
    ------
    i.points : GeometrySocket
        Points
    i.selection : BooleanSocket
        Selection
    i.instance : GeometrySocket
        Instance
    i.pick_instance : BooleanSocket
        Pick Instance
    i.instance_index : IntegerSocket
        Instance Index
    i.rotation : RotationSocket
        Rotation
    i.scale : VectorSocket
        Scale

    Outputs
    -------
    o.instances : GeometrySocket
        Instances
    """

    _bl_idname = "GeometryNodeInstanceOnPoints"
    node: bpy.types.GeometryNodeInstanceOnPoints

    class _Inputs(SocketAccessor):
        points: GeometrySocket
        """Points"""
        selection: BooleanSocket
        """Selection"""
        instance: GeometrySocket
        """Instance"""
        pick_instance: BooleanSocket
        """Pick Instance"""
        instance_index: IntegerSocket
        """Instance Index"""
        rotation: RotationSocket
        """Rotation"""
        scale: VectorSocket
        """Scale"""

    class _Outputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        points: InputGeometry = None,
        selection: InputBoolean = True,
        instance: InputGeometry = None,
        pick_instance: InputBoolean = False,
        instance_index: InputInteger = 0,
        rotation: InputRotation = None,
        scale: InputVector = None,
    ):
        super().__init__()
        key_args = {
            "Points": points,
            "Selection": selection,
            "Instance": instance,
            "Pick Instance": pick_instance,
            "Instance Index": instance_index,
            "Rotation": rotation,
            "Scale": scale,
        }

        self._establish_links(**key_args)


class InstancesToPoints(BaseNode):
    """
        Generate points at the origins of instances.
    Note: Nested instances are not affected by this node

        Parameters
        ----------
        instances : InputGeometry
            Instances
        selection : InputBoolean
            Selection
        position : InputVector
            Position
        radius : InputFloat
            Radius

        Inputs
        ------
        i.instances : GeometrySocket
            Instances
        i.selection : BooleanSocket
            Selection
        i.position : VectorSocket
            Position
        i.radius : FloatSocket
            Radius

        Outputs
        -------
        o.points : GeometrySocket
            Points
    """

    _bl_idname = "GeometryNodeInstancesToPoints"
    node: bpy.types.GeometryNodeInstancesToPoints

    class _Inputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""
        selection: BooleanSocket
        """Selection"""
        position: VectorSocket
        """Position"""
        radius: FloatSocket
        """Radius"""

    class _Outputs(SocketAccessor):
        points: GeometrySocket
        """Points"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        instances: InputGeometry = None,
        selection: InputBoolean = True,
        position: InputVector = None,
        radius: InputFloat = 0.05,
    ):
        super().__init__()
        key_args = {
            "Instances": instances,
            "Selection": selection,
            "Position": position,
            "Radius": radius,
        }

        self._establish_links(**key_args)


class InterpolateCurves(BaseNode):
    """
    Generate new curves on points by interpolating between existing curves

    Parameters
    ----------
    guide_curves : InputGeometry
        Guide Curves
    guide_up : InputVector
        Guide Up
    guide_group_id : InputInteger
        Guide Group ID
    points : InputGeometry
        Points
    point_up : InputVector
        Point Up
    point_group_id : InputInteger
        Point Group ID
    max_neighbors : InputInteger
        Max Neighbors

    Inputs
    ------
    i.guide_curves : GeometrySocket
        Guide Curves
    i.guide_up : VectorSocket
        Guide Up
    i.guide_group_id : IntegerSocket
        Guide Group ID
    i.points : GeometrySocket
        Points
    i.point_up : VectorSocket
        Point Up
    i.point_group_id : IntegerSocket
        Point Group ID
    i.max_neighbors : IntegerSocket
        Max Neighbors

    Outputs
    -------
    o.curves : GeometrySocket
        Curves
    o.closest_index : IntegerSocket
        Closest Index
    o.closest_weight : FloatSocket
        Closest Weight
    """

    _bl_idname = "GeometryNodeInterpolateCurves"
    node: bpy.types.GeometryNodeInterpolateCurves

    class _Inputs(SocketAccessor):
        guide_curves: GeometrySocket
        """Guide Curves"""
        guide_up: VectorSocket
        """Guide Up"""
        guide_group_id: IntegerSocket
        """Guide Group ID"""
        points: GeometrySocket
        """Points"""
        point_up: VectorSocket
        """Point Up"""
        point_group_id: IntegerSocket
        """Point Group ID"""
        max_neighbors: IntegerSocket
        """Max Neighbors"""

    class _Outputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""
        closest_index: IntegerSocket
        """Closest Index"""
        closest_weight: FloatSocket
        """Closest Weight"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        guide_curves: InputGeometry = None,
        guide_up: InputVector = None,
        guide_group_id: InputInteger = 0,
        points: InputGeometry = None,
        point_up: InputVector = None,
        point_group_id: InputInteger = 0,
        max_neighbors: InputInteger = 4,
    ):
        super().__init__()
        key_args = {
            "Guide Curves": guide_curves,
            "Guide Up": guide_up,
            "Guide Group ID": guide_group_id,
            "Points": points,
            "Point Up": point_up,
            "Point Group ID": point_group_id,
            "Max Neighbors": max_neighbors,
        }

        self._establish_links(**key_args)


class MaterialSelection(BaseNode):
    """
    Provide a selection of faces that use the specified material

    Parameters
    ----------
    material : InputMaterial
        Material

    Inputs
    ------
    i.material : MaterialSocket
        Material

    Outputs
    -------
    o.selection : BooleanSocket
        Selection
    """

    _bl_idname = "GeometryNodeMaterialSelection"
    node: bpy.types.GeometryNodeMaterialSelection

    class _Inputs(SocketAccessor):
        material: MaterialSocket
        """Material"""

    class _Outputs(SocketAccessor):
        selection: BooleanSocket
        """Selection"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self, material: InputMaterial = None):
        super().__init__()
        key_args = {"Material": material}

        self._establish_links(**key_args)


class MergeLayers(BaseNode):
    """
    Join groups of Grease Pencil layers into one

    Parameters
    ----------
    grease_pencil : InputGeometry
        Grease Pencil
    selection : InputBoolean
        Selection
    group_id : InputInteger
        Group ID

    Inputs
    ------
    i.grease_pencil : GeometrySocket
        Grease Pencil
    i.selection : BooleanSocket
        Selection
    i.group_id : IntegerSocket
        Group ID

    Outputs
    -------
    o.grease_pencil : GeometrySocket
        Grease Pencil
    """

    _bl_idname = "GeometryNodeMergeLayers"
    node: bpy.types.GeometryNodeMergeLayers

    class _Inputs(SocketAccessor):
        grease_pencil: GeometrySocket
        """Grease Pencil"""
        selection: BooleanSocket
        """Selection"""
        group_id: IntegerSocket
        """Group ID"""

    class _Outputs(SocketAccessor):
        grease_pencil: GeometrySocket
        """Grease Pencil"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        grease_pencil: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
        *,
        mode: Literal["MERGE_BY_NAME", "MERGE_BY_ID"] = "MERGE_BY_NAME",
    ):
        super().__init__()
        key_args = {
            "Grease Pencil": grease_pencil,
            "Selection": selection,
            "Group ID": group_id,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def by_name(
        cls, grease_pencil: InputGeometry = None, selection: InputBoolean = True
    ) -> "MergeLayers":
        """Create Merge Layers with operation 'By Name'. Combine all layers which have the same name"""
        return cls(
            mode="MERGE_BY_NAME", grease_pencil=grease_pencil, selection=selection
        )

    @classmethod
    def by_group_id(
        cls,
        grease_pencil: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
    ) -> "MergeLayers":
        """Create Merge Layers with operation 'By Group ID'. Provide a custom group ID for each layer and all layers with the same ID will be merged into one"""
        return cls(
            mode="MERGE_BY_ID",
            grease_pencil=grease_pencil,
            selection=selection,
            group_id=group_id,
        )

    @property
    def mode(self) -> Literal["MERGE_BY_NAME", "MERGE_BY_ID"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["MERGE_BY_NAME", "MERGE_BY_ID"]):
        self.node.mode = value


class MergePoints(BaseNode):
    """
    Merge points of a point cloud or mesh based on group ID and selection.

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    merge_id : InputInteger
        Merge ID

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.merge_id : IntegerSocket
        Merge ID

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeMergePoints"
    node: bpy.types.GeometryNodeMergePoints  # ty: ignore[unresolved-attribute]

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        merge_id: IntegerSocket
        """Merge ID"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        merge_id: InputInteger = 0,
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Selection": selection, "Merge ID": merge_id}

        self._establish_links(**key_args)


class MergeByDistance(BaseNode):
    """
    Merge vertices or points within a given distance

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    mode : InputMenu | Literal['All', 'Connected']
        Mode
    distance : InputFloat
        Distance

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.mode : MenuSocket
        Mode
    i.distance : FloatSocket
        Distance

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeMergeByDistance"
    node: bpy.types.GeometryNodeMergeByDistance

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        mode: MenuSocket
        """Mode"""
        distance: FloatSocket
        """Distance"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        mode: InputMenu | Literal["All", "Connected"] = "All",
        distance: InputFloat = 0.001,
    ):
        super().__init__()
        key_args = {
            "Geometry": geometry,
            "Selection": selection,
            "Mode": mode,
            "Distance": distance,
        }

        self._establish_links(**key_args)


class MeshBevel(BaseNode):
    """
    Bevel selected edges or vertices

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    selection : InputBoolean
        Selection
    affect_kind : InputMenu | Literal['Vertices', 'Edges']
        Affect Kind
    start_left_offset : InputFloat
        Start Left Offset
    start_right_offset : InputFloat
        Start Right Offset
    end_left_offset : InputFloat
        End Left Offset
    end_right_offset : InputFloat
        End Right Offset
    offset : InputFloat
        Offset
    miter : InputBoolean
        Miter
    spread : InputFloat
        Spread
    segments : InputInteger
        Segments
    shape : InputFloat
        Shape
    profile : InputGeometry
        Profile

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.selection : BooleanSocket
        Selection
    i.affect_kind : MenuSocket
        Affect Kind
    i.start_left_offset : FloatSocket
        Start Left Offset
    i.start_right_offset : FloatSocket
        Start Right Offset
    i.end_left_offset : FloatSocket
        End Left Offset
    i.end_right_offset : FloatSocket
        End Right Offset
    i.offset : FloatSocket
        Offset
    i.miter : BooleanSocket
        Miter
    i.spread : FloatSocket
        Spread
    i.segments : IntegerSocket
        Segments
    i.shape : FloatSocket
        Shape
    i.profile : GeometrySocket
        Profile

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    o.vertex_face : BooleanSocket
        Vertex Face
    o.edge_face : BooleanSocket
        Edge Face
    o.outer_edge : BooleanSocket
        Outer Edge
    o.mid_edge : BooleanSocket
        Mid Edge
    """

    _bl_idname = "GeometryNodeMeshBevel"
    node: bpy.types.GeometryNodeMeshBevel  # ty: ignore[unresolved-attribute]

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        selection: BooleanSocket
        """Selection"""
        affect_kind: MenuSocket
        """Affect Kind"""
        start_left_offset: FloatSocket
        """Start Left Offset"""
        start_right_offset: FloatSocket
        """Start Right Offset"""
        end_left_offset: FloatSocket
        """End Left Offset"""
        end_right_offset: FloatSocket
        """End Right Offset"""
        offset: FloatSocket
        """Offset"""
        miter: BooleanSocket
        """Miter"""
        spread: FloatSocket
        """Spread"""
        segments: IntegerSocket
        """Segments"""
        shape: FloatSocket
        """Shape"""
        profile: GeometrySocket
        """Profile"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        vertex_face: BooleanSocket
        """Vertex Face"""
        edge_face: BooleanSocket
        """Edge Face"""
        outer_edge: BooleanSocket
        """Outer Edge"""
        mid_edge: BooleanSocket
        """Mid Edge"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        affect_kind: InputMenu | Literal["Vertices", "Edges"] = "Edges",
        start_left_offset: InputFloat = 0.1,
        start_right_offset: InputFloat = 0.1,
        end_left_offset: InputFloat = 0.1,
        end_right_offset: InputFloat = 0.1,
        offset: InputFloat = 0.1,
        miter: InputBoolean = False,
        spread: InputFloat = 0.1,
        segments: InputInteger = 1,
        shape: InputFloat = 0.5,
        profile: InputGeometry = None,
    ):
        super().__init__()
        key_args = {
            "Mesh": mesh,
            "Selection": selection,
            "Affect Kind": affect_kind,
            "Start Left Offset": start_left_offset,
            "Start Right Offset": start_right_offset,
            "End Left Offset": end_left_offset,
            "End Right Offset": end_right_offset,
            "Offset": offset,
            "Miter": miter,
            "Spread": spread,
            "Segments": segments,
            "Shape": shape,
            "Profile": profile,
        }

        self._establish_links(**key_args)


class MeshCircle(BaseNode):
    """
    Generate a circular ring of edges

    Parameters
    ----------
    vertices : InputInteger
        Vertices
    radius : InputFloat
        Radius

    Inputs
    ------
    i.vertices : IntegerSocket
        Vertices
    i.radius : FloatSocket
        Radius

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeMeshCircle"
    node: bpy.types.GeometryNodeMeshCircle

    class _Inputs(SocketAccessor):
        vertices: IntegerSocket
        """Vertices"""
        radius: FloatSocket
        """Radius"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        vertices: InputInteger = 32,
        radius: InputFloat = 1.0,
        *,
        fill_type: Literal["NONE", "NGON", "TRIANGLE_FAN"] = "NONE",
    ):
        super().__init__()
        key_args = {"Vertices": vertices, "Radius": radius}
        self.fill_type = fill_type
        self._establish_links(**key_args)

    @classmethod
    def none(
        cls, vertices: InputInteger = 32, radius: InputFloat = 1.0
    ) -> "MeshCircle":
        """Create Mesh Circle with operation 'None'."""
        return cls(fill_type="NONE", vertices=vertices, radius=radius)

    @classmethod
    def n_gon(
        cls, vertices: InputInteger = 32, radius: InputFloat = 1.0
    ) -> "MeshCircle":
        """Create Mesh Circle with operation 'N-Gon'."""
        return cls(fill_type="NGON", vertices=vertices, radius=radius)

    @classmethod
    def triangles(
        cls, vertices: InputInteger = 32, radius: InputFloat = 1.0
    ) -> "MeshCircle":
        """Create Mesh Circle with operation 'Triangles'."""
        return cls(fill_type="TRIANGLE_FAN", vertices=vertices, radius=radius)

    @property
    def fill_type(self) -> Literal["NONE", "NGON", "TRIANGLE_FAN"]:
        return self.node.fill_type

    @fill_type.setter
    def fill_type(self, value: Literal["NONE", "NGON", "TRIANGLE_FAN"]):
        self.node.fill_type = value


class MeshLine(BaseNode):
    """
    Generate vertices in a line and connect them with edges

    Parameters
    ----------
    count : InputInteger
        Count
    resolution : InputFloat
        Resolution
    start_location : InputVector
        Start Location
    offset : InputVector
        Offset

    Inputs
    ------
    i.count : IntegerSocket
        Count
    i.resolution : FloatSocket
        Resolution
    i.start_location : VectorSocket
        Start Location
    i.offset : VectorSocket
        Offset

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeMeshLine"
    node: bpy.types.GeometryNodeMeshLine

    class _Inputs(SocketAccessor):
        count: IntegerSocket
        """Count"""
        resolution: FloatSocket
        """Resolution"""
        start_location: VectorSocket
        """Start Location"""
        offset: VectorSocket
        """Offset"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        count: InputInteger = 10,
        resolution: InputFloat = 1.0,
        start_location: InputVector = None,
        offset: InputVector = None,
        *,
        mode: Literal["OFFSET", "END_POINTS"] = "OFFSET",
        count_mode: Literal["TOTAL", "RESOLUTION"] = "TOTAL",
    ):
        super().__init__()
        key_args = {
            "Count": count,
            "Resolution": resolution,
            "Start Location": start_location,
            "Offset": offset,
        }
        self.mode = mode
        self.count_mode = count_mode
        self._establish_links(**key_args)

    @classmethod
    def offset(
        cls,
        count: InputInteger = 10,
        start_location: InputVector = None,
        offset: InputVector = None,
    ) -> "MeshLine":
        """Create Mesh Line with operation 'Offset'. Specify the offset from one vertex to the next"""
        return cls(
            mode="OFFSET", count=count, start_location=start_location, offset=offset
        )

    @classmethod
    def end_points(
        cls,
        count: InputInteger = 10,
        start_location: InputVector = None,
        offset: InputVector = None,
    ) -> "MeshLine":
        """Create Mesh Line with operation 'End Points'. Specify the line's start and end points"""
        return cls(
            mode="END_POINTS", count=count, start_location=start_location, offset=offset
        )

    @property
    def mode(self) -> Literal["OFFSET", "END_POINTS"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["OFFSET", "END_POINTS"]):
        self.node.mode = value

    @property
    def count_mode(self) -> Literal["TOTAL", "RESOLUTION"]:
        return self.node.count_mode

    @count_mode.setter
    def count_mode(self, value: Literal["TOTAL", "RESOLUTION"]):
        self.node.count_mode = value


class MeshToCurve(BaseNode):
    """
    Generate a curve from a mesh

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    selection : InputBoolean
        Selection

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.selection : BooleanSocket
        Selection

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeMeshToCurve"
    node: bpy.types.GeometryNodeMeshToCurve

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        selection: BooleanSocket
        """Selection"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        *,
        mode: Literal["EDGES", "FACES"] = "EDGES",
    ):
        super().__init__()
        key_args = {"Mesh": mesh, "Selection": selection}
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def edges(
        cls, mesh: InputGeometry = None, selection: InputBoolean = True
    ) -> "MeshToCurve":
        """Create Mesh to Curve with operation 'Edges'. Convert mesh edges to curve segments. Attributes are propagated to curve points."""
        return cls(mode="EDGES", mesh=mesh, selection=selection)

    @classmethod
    def faces(
        cls, mesh: InputGeometry = None, selection: InputBoolean = True
    ) -> "MeshToCurve":
        """Create Mesh to Curve with operation 'Faces'. Convert each mesh face to a cyclic curve. Face attributes are propagated to curves."""
        return cls(mode="FACES", mesh=mesh, selection=selection)

    @property
    def mode(self) -> Literal["EDGES", "FACES"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["EDGES", "FACES"]):
        self.node.mode = value


class MeshToPoints(BaseNode):
    """
    Generate a point cloud from a mesh's vertices

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    selection : InputBoolean
        Selection
    position : InputVector
        Position
    radius : InputFloat
        Radius

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.selection : BooleanSocket
        Selection
    i.position : VectorSocket
        Position
    i.radius : FloatSocket
        Radius

    Outputs
    -------
    o.points : GeometrySocket
        Points
    """

    _bl_idname = "GeometryNodeMeshToPoints"
    node: bpy.types.GeometryNodeMeshToPoints

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        selection: BooleanSocket
        """Selection"""
        position: VectorSocket
        """Position"""
        radius: FloatSocket
        """Radius"""

    class _Outputs(SocketAccessor):
        points: GeometrySocket
        """Points"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        position: InputVector = None,
        radius: InputFloat = 0.05,
        *,
        mode: Literal["VERTICES", "EDGES", "FACES", "CORNERS"] = "VERTICES",
    ):
        super().__init__()
        key_args = {
            "Mesh": mesh,
            "Selection": selection,
            "Position": position,
            "Radius": radius,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def vertices(
        cls,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        position: InputVector = None,
        radius: InputFloat = 0.05,
    ) -> "MeshToPoints":
        """Create Mesh to Points with operation 'Vertices'. Create a point in the point cloud for each selected vertex"""
        return cls(
            mode="VERTICES",
            mesh=mesh,
            selection=selection,
            position=position,
            radius=radius,
        )

    @classmethod
    def edges(
        cls,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        position: InputVector = None,
        radius: InputFloat = 0.05,
    ) -> "MeshToPoints":
        """Create Mesh to Points with operation 'Edges'. Create a point in the point cloud for each selected edge"""
        return cls(
            mode="EDGES",
            mesh=mesh,
            selection=selection,
            position=position,
            radius=radius,
        )

    @classmethod
    def faces(
        cls,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        position: InputVector = None,
        radius: InputFloat = 0.05,
    ) -> "MeshToPoints":
        """Create Mesh to Points with operation 'Faces'. Create a point in the point cloud for each selected face"""
        return cls(
            mode="FACES",
            mesh=mesh,
            selection=selection,
            position=position,
            radius=radius,
        )

    @classmethod
    def corners(
        cls,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        position: InputVector = None,
        radius: InputFloat = 0.05,
    ) -> "MeshToPoints":
        """Create Mesh to Points with operation 'Corners'. Create a point in the point cloud for each selected face corner"""
        return cls(
            mode="CORNERS",
            mesh=mesh,
            selection=selection,
            position=position,
            radius=radius,
        )

    @property
    def mode(self) -> Literal["VERTICES", "EDGES", "FACES", "CORNERS"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["VERTICES", "EDGES", "FACES", "CORNERS"]):
        self.node.mode = value


class Points(BaseNode):
    """
    Generate a point cloud with positions and radii defined by fields

    Parameters
    ----------
    count : InputInteger
        Count
    position : InputVector
        Position
    radius : InputFloat
        Radius

    Inputs
    ------
    i.count : IntegerSocket
        Count
    i.position : VectorSocket
        Position
    i.radius : FloatSocket
        Radius

    Outputs
    -------
    o.geometry : GeometrySocket
        Points
    """

    _bl_idname = "GeometryNodePoints"
    node: bpy.types.GeometryNodePoints

    class _Inputs(SocketAccessor):
        count: IntegerSocket
        """Count"""
        position: VectorSocket
        """Position"""
        radius: FloatSocket
        """Radius"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Points"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        count: InputInteger = 1,
        position: InputVector = None,
        radius: InputFloat = 0.1,
    ):
        super().__init__()
        key_args = {"Count": count, "Position": position, "Radius": radius}

        self._establish_links(**key_args)


class PointsToCurves(BaseNode):
    """
    Split all points to curve by its group ID and reorder by weight

    Parameters
    ----------
    points : InputGeometry
        Points
    curve_group_id : InputInteger
        Curve Group ID
    weight : InputFloat
        Weight

    Inputs
    ------
    i.points : GeometrySocket
        Points
    i.curve_group_id : IntegerSocket
        Curve Group ID
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.curves : GeometrySocket
        Curves
    """

    _bl_idname = "GeometryNodePointsToCurves"
    node: bpy.types.GeometryNodePointsToCurves

    class _Inputs(SocketAccessor):
        points: GeometrySocket
        """Points"""
        curve_group_id: IntegerSocket
        """Curve Group ID"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        points: InputGeometry = None,
        curve_group_id: InputInteger = 0,
        weight: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {
            "Points": points,
            "Curve Group ID": curve_group_id,
            "Weight": weight,
        }

        self._establish_links(**key_args)


class PointsToVertices(BaseNode):
    """
    Generate a mesh vertex for each point cloud point

    Parameters
    ----------
    points : InputGeometry
        Points
    selection : InputBoolean
        Selection

    Inputs
    ------
    i.points : GeometrySocket
        Points
    i.selection : BooleanSocket
        Selection

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodePointsToVertices"
    node: bpy.types.GeometryNodePointsToVertices

    class _Inputs(SocketAccessor):
        points: GeometrySocket
        """Points"""
        selection: BooleanSocket
        """Selection"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        points: InputGeometry = None,
        selection: InputBoolean = True,
    ):
        super().__init__()
        key_args = {"Points": points, "Selection": selection}

        self._establish_links(**key_args)


class QuadraticBezier(BaseNode):
    """
    Generate a poly spline in a parabola shape with control points positions

    Parameters
    ----------
    resolution : InputInteger
        Resolution
    start : InputVector
        Start
    middle : InputVector
        Middle
    end : InputVector
        End

    Inputs
    ------
    i.resolution : IntegerSocket
        Resolution
    i.start : VectorSocket
        Start
    i.middle : VectorSocket
        Middle
    i.end : VectorSocket
        End

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeCurveQuadraticBezier"
    node: bpy.types.GeometryNodeCurveQuadraticBezier

    class _Inputs(SocketAccessor):
        resolution: IntegerSocket
        """Resolution"""
        start: VectorSocket
        """Start"""
        middle: VectorSocket
        """Middle"""
        end: VectorSocket
        """End"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        resolution: InputInteger = 16,
        start: InputVector = None,
        middle: InputVector = None,
        end: InputVector = None,
    ):
        super().__init__()
        key_args = {
            "Resolution": resolution,
            "Start": start,
            "Middle": middle,
            "End": end,
        }

        self._establish_links(**key_args)


class Quadrilateral(BaseNode):
    """
    Generate a polygon with four points

    Parameters
    ----------
    width : InputFloat
        Width
    height : InputFloat
        Height
    bottom_width : InputFloat
        Bottom Width
    top_width : InputFloat
        Top Width
    offset : InputFloat
        Offset
    bottom_height : InputFloat
        Bottom Height
    top_height : InputFloat
        Top Height
    point_1 : InputVector
        Point 1
    point_2 : InputVector
        Point 2
    point_3 : InputVector
        Point 3
    point_4 : InputVector
        Point 4

    Inputs
    ------
    i.width : FloatSocket
        Width
    i.height : FloatSocket
        Height
    i.bottom_width : FloatSocket
        Bottom Width
    i.top_width : FloatSocket
        Top Width
    i.offset : FloatSocket
        Offset
    i.bottom_height : FloatSocket
        Bottom Height
    i.top_height : FloatSocket
        Top Height
    i.point_1 : VectorSocket
        Point 1
    i.point_2 : VectorSocket
        Point 2
    i.point_3 : VectorSocket
        Point 3
    i.point_4 : VectorSocket
        Point 4

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeCurvePrimitiveQuadrilateral"
    node: bpy.types.GeometryNodeCurvePrimitiveQuadrilateral

    class _Inputs(SocketAccessor):
        width: FloatSocket
        """Width"""
        height: FloatSocket
        """Height"""
        bottom_width: FloatSocket
        """Bottom Width"""
        top_width: FloatSocket
        """Top Width"""
        offset: FloatSocket
        """Offset"""
        bottom_height: FloatSocket
        """Bottom Height"""
        top_height: FloatSocket
        """Top Height"""
        point_1: VectorSocket
        """Point 1"""
        point_2: VectorSocket
        """Point 2"""
        point_3: VectorSocket
        """Point 3"""
        point_4: VectorSocket
        """Point 4"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        width: InputFloat = 2.0,
        height: InputFloat = 2.0,
        bottom_width: InputFloat = 4.0,
        top_width: InputFloat = 2.0,
        offset: InputFloat = 1.0,
        bottom_height: InputFloat = 3.0,
        top_height: InputFloat = 1.0,
        point_1: InputVector = None,
        point_2: InputVector = None,
        point_3: InputVector = None,
        point_4: InputVector = None,
        *,
        mode: Literal[
            "RECTANGLE", "PARALLELOGRAM", "TRAPEZOID", "KITE", "POINTS"
        ] = "RECTANGLE",
    ):
        super().__init__()
        key_args = {
            "Width": width,
            "Height": height,
            "Bottom Width": bottom_width,
            "Top Width": top_width,
            "Offset": offset,
            "Bottom Height": bottom_height,
            "Top Height": top_height,
            "Point 1": point_1,
            "Point 2": point_2,
            "Point 3": point_3,
            "Point 4": point_4,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def rectangle(
        cls, width: InputFloat = 2.0, height: InputFloat = 2.0
    ) -> "Quadrilateral":
        """Create Quadrilateral with operation 'Rectangle'. Create a rectangle"""
        return cls(mode="RECTANGLE", width=width, height=height)

    @classmethod
    def parallelogram(
        cls, width: InputFloat = 2.0, height: InputFloat = 2.0, offset: InputFloat = 1.0
    ) -> "Quadrilateral":
        """Create Quadrilateral with operation 'Parallelogram'. Create a parallelogram"""
        return cls(mode="PARALLELOGRAM", width=width, height=height, offset=offset)

    @classmethod
    def trapezoid(
        cls,
        height: InputFloat = 2.0,
        bottom_width: InputFloat = 4.0,
        top_width: InputFloat = 2.0,
        offset: InputFloat = 1.0,
    ) -> "Quadrilateral":
        """Create Quadrilateral with operation 'Trapezoid'. Create a trapezoid"""
        return cls(
            mode="TRAPEZOID",
            height=height,
            bottom_width=bottom_width,
            top_width=top_width,
            offset=offset,
        )

    @classmethod
    def kite(
        cls,
        width: InputFloat = 2.0,
        bottom_height: InputFloat = 3.0,
        top_height: InputFloat = 1.0,
    ) -> "Quadrilateral":
        """Create Quadrilateral with operation 'Kite'. Create a Kite / Dart"""
        return cls(
            mode="KITE", width=width, bottom_height=bottom_height, top_height=top_height
        )

    @classmethod
    def points(
        cls,
        point_1: InputVector = None,
        point_2: InputVector = None,
        point_3: InputVector = None,
        point_4: InputVector = None,
    ) -> "Quadrilateral":
        """Create Quadrilateral with operation 'Points'. Create a quadrilateral from four points"""
        return cls(
            mode="POINTS",
            point_1=point_1,
            point_2=point_2,
            point_3=point_3,
            point_4=point_4,
        )

    @property
    def mode(
        self,
    ) -> Literal["RECTANGLE", "PARALLELOGRAM", "TRAPEZOID", "KITE", "POINTS"]:
        return self.node.mode

    @mode.setter
    def mode(
        self,
        value: Literal["RECTANGLE", "PARALLELOGRAM", "TRAPEZOID", "KITE", "POINTS"],
    ):
        self.node.mode = value


class Raycast(BaseNode, Generic[_T]):
    """
    Cast rays from the context geometry onto a target geometry, and retrieve information from each hit point

    Parameters
    ----------
    target_geometry : InputGeometry
        Target Geometry
    attribute : InputFloat
        Attribute
    interpolation : InputMenu | Literal['Interpolated', 'Nearest']
        Interpolation
    source_position : InputVector
        Source Position
    ray_direction : InputVector
        Ray Direction
    ray_length : InputFloat
        Ray Length

    Inputs
    ------
    i.target_geometry : GeometrySocket
        Target Geometry
    i.attribute : FloatSocket
        Attribute
    i.interpolation : MenuSocket
        Interpolation
    i.source_position : VectorSocket
        Source Position
    i.ray_direction : VectorSocket
        Ray Direction
    i.ray_length : FloatSocket
        Ray Length

    Outputs
    -------
    o.is_hit : BooleanSocket
        Is Hit
    o.hit_position : VectorSocket
        Hit Position
    o.hit_normal : VectorSocket
        Hit Normal
    o.hit_distance : FloatSocket
        Hit Distance
    o.attribute : FloatSocket
        Attribute
    """

    _bl_idname = "GeometryNodeRaycast"
    node: bpy.types.GeometryNodeRaycast

    class _Inputs(SocketAccessor, Generic[_S]):
        target_geometry: GeometrySocket
        """Target Geometry"""
        attribute: _S
        """Attribute"""
        interpolation: MenuSocket
        """Interpolation"""
        source_position: VectorSocket
        """Source Position"""
        ray_direction: VectorSocket
        """Ray Direction"""
        ray_length: FloatSocket
        """Ray Length"""

    class _Outputs(SocketAccessor, Generic[_S]):
        is_hit: BooleanSocket
        """Is Hit"""
        hit_position: VectorSocket
        """Hit Position"""
        hit_normal: VectorSocket
        """Hit Normal"""
        hit_distance: FloatSocket
        """Hit Distance"""
        attribute: _S
        """Attribute"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs[_T]: ...
        @property
        def o(self) -> _Outputs[_T]: ...

    def __init__(
        self,
        target_geometry: InputGeometry = None,
        attribute: InputAny = 0.0,
        interpolation: InputMenu | Literal["Interpolated", "Nearest"] = "Interpolated",
        source_position: InputVector = None,
        ray_direction: InputVector = None,
        ray_length: InputFloat = 100.0,
        *,
        data_type: Literal[
            "FLOAT",
            "INT",
            "BOOLEAN",
            "FLOAT_VECTOR",
            "FLOAT_COLOR",
            "QUATERNION",
            "FLOAT4X4",
        ] = "FLOAT",
    ):
        super().__init__()
        key_args = {
            "Target Geometry": target_geometry,
            "Attribute": attribute,
            "Interpolation": interpolation,
            "Source Position": source_position,
            "Ray Direction": ray_direction,
            "Ray Length": ray_length,
        }
        self.data_type = data_type
        self._establish_links(**key_args)

    @classmethod
    def float(
        cls,
        target_geometry: InputGeometry = None,
        attribute: InputFloat = 0.0,
        interpolation: InputMenu | Literal["Interpolated", "Nearest"] = "Interpolated",
        source_position: InputVector = None,
        ray_direction: InputVector = None,
        ray_length: InputFloat = 100.0,
    ) -> "Raycast[FloatSocket]":
        """Create Raycast with operation 'Float'. Floating-point value"""
        return Raycast(
            data_type="FLOAT",
            target_geometry=target_geometry,
            attribute=attribute,
            interpolation=interpolation,
            source_position=source_position,
            ray_direction=ray_direction,
            ray_length=ray_length,
        )

    @classmethod
    def integer(
        cls,
        target_geometry: InputGeometry = None,
        attribute: InputInteger = 0,
        interpolation: InputMenu | Literal["Interpolated", "Nearest"] = "Interpolated",
        source_position: InputVector = None,
        ray_direction: InputVector = None,
        ray_length: InputFloat = 100.0,
    ) -> "Raycast[IntegerSocket]":
        """Create Raycast with operation 'Integer'. 32-bit integer"""
        return Raycast(
            data_type="INT",
            target_geometry=target_geometry,
            attribute=attribute,
            interpolation=interpolation,
            source_position=source_position,
            ray_direction=ray_direction,
            ray_length=ray_length,
        )

    @classmethod
    def boolean(
        cls,
        target_geometry: InputGeometry = None,
        attribute: InputBoolean = False,
        interpolation: InputMenu | Literal["Interpolated", "Nearest"] = "Interpolated",
        source_position: InputVector = None,
        ray_direction: InputVector = None,
        ray_length: InputFloat = 100.0,
    ) -> "Raycast[BooleanSocket]":
        """Create Raycast with operation 'Boolean'. True or false"""
        return Raycast(
            data_type="BOOLEAN",
            target_geometry=target_geometry,
            attribute=attribute,
            interpolation=interpolation,
            source_position=source_position,
            ray_direction=ray_direction,
            ray_length=ray_length,
        )

    @classmethod
    def vector(
        cls,
        target_geometry: InputGeometry = None,
        attribute: InputVector = None,
        interpolation: InputMenu | Literal["Interpolated", "Nearest"] = "Interpolated",
        source_position: InputVector = None,
        ray_direction: InputVector = None,
        ray_length: InputFloat = 100.0,
    ) -> "Raycast[VectorSocket]":
        """Create Raycast with operation 'Vector'. 3D vector with floating-point values"""
        return Raycast(
            data_type="FLOAT_VECTOR",
            target_geometry=target_geometry,
            attribute=attribute,
            interpolation=interpolation,
            source_position=source_position,
            ray_direction=ray_direction,
            ray_length=ray_length,
        )

    @classmethod
    def color(
        cls,
        target_geometry: InputGeometry = None,
        attribute: InputColor = None,
        interpolation: InputMenu | Literal["Interpolated", "Nearest"] = "Interpolated",
        source_position: InputVector = None,
        ray_direction: InputVector = None,
        ray_length: InputFloat = 100.0,
    ) -> "Raycast[ColorSocket]":
        """Create Raycast with operation 'Color'. RGBA color with 32-bit floating-point values"""
        return Raycast(
            data_type="FLOAT_COLOR",
            target_geometry=target_geometry,
            attribute=attribute,
            interpolation=interpolation,
            source_position=source_position,
            ray_direction=ray_direction,
            ray_length=ray_length,
        )

    @classmethod
    def quaternion(
        cls,
        target_geometry: InputGeometry = None,
        attribute: InputRotation = None,
        interpolation: InputMenu | Literal["Interpolated", "Nearest"] = "Interpolated",
        source_position: InputVector = None,
        ray_direction: InputVector = None,
        ray_length: InputFloat = 100.0,
    ) -> "Raycast[RotationSocket]":
        """Create Raycast with operation 'Quaternion'. Floating point quaternion rotation"""
        return Raycast(
            data_type="QUATERNION",
            target_geometry=target_geometry,
            attribute=attribute,
            interpolation=interpolation,
            source_position=source_position,
            ray_direction=ray_direction,
            ray_length=ray_length,
        )

    @classmethod
    def input_4x4_matrix(
        cls,
        target_geometry: InputGeometry = None,
        attribute: InputMatrix = None,
        interpolation: InputMenu | Literal["Interpolated", "Nearest"] = "Interpolated",
        source_position: InputVector = None,
        ray_direction: InputVector = None,
        ray_length: InputFloat = 100.0,
    ) -> "Raycast[MatrixSocket]":
        """Create Raycast with operation '4x4 Matrix'. Floating point matrix"""
        return Raycast(
            data_type="FLOAT4X4",
            target_geometry=target_geometry,
            attribute=attribute,
            interpolation=interpolation,
            source_position=source_position,
            ray_direction=ray_direction,
            ray_length=ray_length,
        )

    @property
    def data_type(
        self,
    ) -> Literal[
        "FLOAT",
        "INT",
        "BOOLEAN",
        "FLOAT_VECTOR",
        "FLOAT_COLOR",
        "QUATERNION",
        "FLOAT4X4",
    ]:
        return self.node.data_type  # ty: ignore[invalid-return-type]

    @data_type.setter
    def data_type(
        self,
        value: Literal[
            "FLOAT",
            "INT",
            "BOOLEAN",
            "FLOAT_VECTOR",
            "FLOAT_COLOR",
            "QUATERNION",
            "FLOAT4X4",
        ],
    ):
        self.node.data_type = value


class RealizeInstances(BaseNode):
    """
    Convert instances into real geometry data

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    realize_all : InputBoolean
        Realize All
    depth : InputInteger
        Depth

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.realize_all : BooleanSocket
        Realize All
    i.depth : IntegerSocket
        Depth

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeRealizeInstances"
    node: bpy.types.GeometryNodeRealizeInstances

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        realize_all: BooleanSocket
        """Realize All"""
        depth: IntegerSocket
        """Depth"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        realize_all: InputBoolean = True,
        depth: InputInteger = 0,
        *,
        realize_to_point_domain: bool = False,
    ):
        super().__init__()
        key_args = {
            "Geometry": geometry,
            "Selection": selection,
            "Realize All": realize_all,
            "Depth": depth,
        }
        self.realize_to_point_domain = realize_to_point_domain
        self._establish_links(**key_args)

    @property
    def realize_to_point_domain(self) -> bool:
        return self.node.realize_to_point_domain

    @realize_to_point_domain.setter
    def realize_to_point_domain(self, value: bool):
        self.node.realize_to_point_domain = value


class RenameAttribute(BaseNode):
    """
    Change the name of an attribute

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    mode : InputMenu | Literal['Single', 'Prefix']
        Mode
    old : InputString
        Old
    new : InputString
        New
    overwrite : InputBoolean
        Overwrite

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.mode : MenuSocket
        Mode
    i.old : StringSocket
        Old
    i.new : StringSocket
        New
    i.overwrite : BooleanSocket
        Overwrite

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeRenameAttribute"
    node: bpy.types.GeometryNodeRenameAttribute

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        mode: MenuSocket
        """Mode"""
        old: StringSocket
        """Old"""
        new: StringSocket
        """New"""
        overwrite: BooleanSocket
        """Overwrite"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        mode: InputMenu | Literal["Single", "Prefix"] = "Single",
        old: InputString = "",
        new: InputString = "",
        overwrite: InputBoolean = False,
    ):
        super().__init__()
        key_args = {
            "Geometry": geometry,
            "Mode": mode,
            "Old": old,
            "New": new,
            "Overwrite": overwrite,
        }

        self._establish_links(**key_args)


class ReplaceMaterial(BaseNode):
    """
    Swap one material with another

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    old : InputMaterial
        Old
    new : InputMaterial
        New

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.old : MaterialSocket
        Old
    i.new : MaterialSocket
        New

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeReplaceMaterial"
    node: bpy.types.GeometryNodeReplaceMaterial

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        old: MaterialSocket
        """Old"""
        new: MaterialSocket
        """New"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        old: InputMaterial = None,
        new: InputMaterial = None,
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Old": old, "New": new}

        self._establish_links(**key_args)


class ResampleCurve(BaseNode):
    """
    Generate a poly spline for each input spline

    Parameters
    ----------
    curve : InputGeometry
        Curve
    selection : InputBoolean
        Selection
    mode : InputMenu | Literal['Evaluated', 'Count', 'Length']
        Mode
    count : InputInteger
        Count
    length : InputFloat
        Length

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection
    i.mode : MenuSocket
        Mode
    i.count : IntegerSocket
        Count
    i.length : FloatSocket
        Length

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeResampleCurve"
    node: bpy.types.GeometryNodeResampleCurve

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""
        mode: MenuSocket
        """Mode"""
        count: IntegerSocket
        """Count"""
        length: FloatSocket
        """Length"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        mode: InputMenu | Literal["Evaluated", "Count", "Length"] = "Count",
        count: InputInteger = 10,
        length: InputFloat = 0.1,
        *,
        keep_last_segment: bool = False,
    ):
        super().__init__()
        key_args = {
            "Curve": curve,
            "Selection": selection,
            "Mode": mode,
            "Count": count,
            "Length": length,
        }
        self.keep_last_segment = keep_last_segment
        self._establish_links(**key_args)

    @property
    def keep_last_segment(self) -> bool:
        return self.node.keep_last_segment

    @keep_last_segment.setter
    def keep_last_segment(self, value: bool):
        self.node.keep_last_segment = value


class ReverseCurve(BaseNode):
    """
    Change the direction of curves by swapping their start and end data

    Parameters
    ----------
    curve : InputGeometry
        Curve
    selection : InputBoolean
        Selection

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeReverseCurve"
    node: bpy.types.GeometryNodeReverseCurve

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
    ):
        super().__init__()
        key_args = {"Curve": curve, "Selection": selection}

        self._establish_links(**key_args)


class RotateInstances(BaseNode):
    """
    Rotate geometry instances in local or global space

    Parameters
    ----------
    instances : InputGeometry
        Instances
    selection : InputBoolean
        Selection
    rotation : InputRotation
        Rotation
    pivot_point : InputVector
        Pivot Point
    local_space : InputBoolean
        Local Space

    Inputs
    ------
    i.instances : GeometrySocket
        Instances
    i.selection : BooleanSocket
        Selection
    i.rotation : RotationSocket
        Rotation
    i.pivot_point : VectorSocket
        Pivot Point
    i.local_space : BooleanSocket
        Local Space

    Outputs
    -------
    o.instances : GeometrySocket
        Instances
    """

    _bl_idname = "GeometryNodeRotateInstances"
    node: bpy.types.GeometryNodeRotateInstances

    class _Inputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""
        selection: BooleanSocket
        """Selection"""
        rotation: RotationSocket
        """Rotation"""
        pivot_point: VectorSocket
        """Pivot Point"""
        local_space: BooleanSocket
        """Local Space"""

    class _Outputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        instances: InputGeometry = None,
        selection: InputBoolean = True,
        rotation: InputRotation = None,
        pivot_point: InputVector = None,
        local_space: InputBoolean = True,
    ):
        super().__init__()
        key_args = {
            "Instances": instances,
            "Selection": selection,
            "Rotation": rotation,
            "Pivot Point": pivot_point,
            "Local Space": local_space,
        }

        self._establish_links(**key_args)


class SampleNearest(BaseNode):
    """
    Find the element of a geometry closest to a position. Similar to the "Index of Nearest" node

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    sample_position : InputVector
        Sample Position

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.sample_position : VectorSocket
        Sample Position

    Outputs
    -------
    o.index : IntegerSocket
        Index
    """

    _bl_idname = "GeometryNodeSampleNearest"
    node: bpy.types.GeometryNodeSampleNearest

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        sample_position: VectorSocket
        """Sample Position"""

    class _Outputs(SocketAccessor):
        index: IntegerSocket
        """Index"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        sample_position: InputVector = None,
        *,
        domain: Literal["POINT", "EDGE", "FACE", "CORNER"] = "POINT",
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Sample Position": sample_position}
        self.domain = domain
        self._establish_links(**key_args)

    @classmethod
    def point(
        cls, geometry: InputGeometry = None, sample_position: InputVector = None
    ) -> "SampleNearest":
        """Create Sample Nearest with operation 'Point'. Attribute on point"""
        return cls(domain="POINT", geometry=geometry, sample_position=sample_position)

    @classmethod
    def edge(
        cls, geometry: InputGeometry = None, sample_position: InputVector = None
    ) -> "SampleNearest":
        """Create Sample Nearest with operation 'Edge'. Attribute on mesh edge"""
        return cls(domain="EDGE", geometry=geometry, sample_position=sample_position)

    @classmethod
    def face(
        cls, geometry: InputGeometry = None, sample_position: InputVector = None
    ) -> "SampleNearest":
        """Create Sample Nearest with operation 'Face'. Attribute on mesh faces"""
        return cls(domain="FACE", geometry=geometry, sample_position=sample_position)

    @classmethod
    def face_corner(
        cls, geometry: InputGeometry = None, sample_position: InputVector = None
    ) -> "SampleNearest":
        """Create Sample Nearest with operation 'Face Corner'. Attribute on mesh face corner"""
        return cls(domain="CORNER", geometry=geometry, sample_position=sample_position)

    @property
    def domain(self) -> Literal["POINT", "EDGE", "FACE", "CORNER"]:
        return self.node.domain

    @domain.setter
    def domain(self, value: Literal["POINT", "EDGE", "FACE", "CORNER"]):
        self.node.domain = value


class SampleNearestSurface(BaseNode, Generic[_T]):
    """
    Calculate the interpolated value of a mesh attribute on the closest point of its surface

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    value : InputFloat
        Value
    group_id : InputInteger
        Group ID
    sample_position : InputVector
        Sample Position
    sample_group_id : InputInteger
        Sample Group ID

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.value : FloatSocket
        Value
    i.group_id : IntegerSocket
        Group ID
    i.sample_position : VectorSocket
        Sample Position
    i.sample_group_id : IntegerSocket
        Sample Group ID

    Outputs
    -------
    o.value : FloatSocket
        Value
    o.is_valid : BooleanSocket
        Is Valid
    """

    _bl_idname = "GeometryNodeSampleNearestSurface"
    node: bpy.types.GeometryNodeSampleNearestSurface

    class _Inputs(SocketAccessor, Generic[_S]):
        mesh: GeometrySocket
        """Mesh"""
        value: _S
        """Value"""
        group_id: IntegerSocket
        """Group ID"""
        sample_position: VectorSocket
        """Sample Position"""
        sample_group_id: IntegerSocket
        """Sample Group ID"""

    class _Outputs(SocketAccessor, Generic[_S]):
        value: _S
        """Value"""
        is_valid: BooleanSocket
        """Is Valid"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs[_T]: ...
        @property
        def o(self) -> _Outputs[_T]: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        value: InputAny = 0.0,
        group_id: InputInteger = 0,
        sample_position: InputVector = None,
        sample_group_id: InputInteger = 0,
        *,
        data_type: Literal[
            "FLOAT",
            "INT",
            "BOOLEAN",
            "FLOAT_VECTOR",
            "FLOAT_COLOR",
            "QUATERNION",
            "FLOAT4X4",
        ] = "FLOAT",
    ):
        super().__init__()
        key_args = {
            "Mesh": mesh,
            "Value": value,
            "Group ID": group_id,
            "Sample Position": sample_position,
            "Sample Group ID": sample_group_id,
        }
        self.data_type = data_type
        self._establish_links(**key_args)

    @classmethod
    def float(
        cls,
        mesh: InputGeometry = None,
        value: InputFloat = 0.0,
        group_id: InputInteger = 0,
        sample_position: InputVector = None,
        sample_group_id: InputInteger = 0,
    ) -> "SampleNearestSurface[FloatSocket]":
        """Create Sample Nearest Surface with operation 'Float'. Floating-point value"""
        return SampleNearestSurface(
            data_type="FLOAT",
            mesh=mesh,
            value=value,
            group_id=group_id,
            sample_position=sample_position,
            sample_group_id=sample_group_id,
        )

    @classmethod
    def integer(
        cls,
        mesh: InputGeometry = None,
        value: InputInteger = 0,
        group_id: InputInteger = 0,
        sample_position: InputVector = None,
        sample_group_id: InputInteger = 0,
    ) -> "SampleNearestSurface[IntegerSocket]":
        """Create Sample Nearest Surface with operation 'Integer'. 32-bit integer"""
        return SampleNearestSurface(
            data_type="INT",
            mesh=mesh,
            value=value,
            group_id=group_id,
            sample_position=sample_position,
            sample_group_id=sample_group_id,
        )

    @classmethod
    def boolean(
        cls,
        mesh: InputGeometry = None,
        value: InputBoolean = False,
        group_id: InputInteger = 0,
        sample_position: InputVector = None,
        sample_group_id: InputInteger = 0,
    ) -> "SampleNearestSurface[BooleanSocket]":
        """Create Sample Nearest Surface with operation 'Boolean'. True or false"""
        return SampleNearestSurface(
            data_type="BOOLEAN",
            mesh=mesh,
            value=value,
            group_id=group_id,
            sample_position=sample_position,
            sample_group_id=sample_group_id,
        )

    @classmethod
    def vector(
        cls,
        mesh: InputGeometry = None,
        value: InputVector = None,
        group_id: InputInteger = 0,
        sample_position: InputVector = None,
        sample_group_id: InputInteger = 0,
    ) -> "SampleNearestSurface[VectorSocket]":
        """Create Sample Nearest Surface with operation 'Vector'. 3D vector with floating-point values"""
        return SampleNearestSurface(
            data_type="FLOAT_VECTOR",
            mesh=mesh,
            value=value,
            group_id=group_id,
            sample_position=sample_position,
            sample_group_id=sample_group_id,
        )

    @classmethod
    def color(
        cls,
        mesh: InputGeometry = None,
        value: InputColor = None,
        group_id: InputInteger = 0,
        sample_position: InputVector = None,
        sample_group_id: InputInteger = 0,
    ) -> "SampleNearestSurface[ColorSocket]":
        """Create Sample Nearest Surface with operation 'Color'. RGBA color with 32-bit floating-point values"""
        return SampleNearestSurface(
            data_type="FLOAT_COLOR",
            mesh=mesh,
            value=value,
            group_id=group_id,
            sample_position=sample_position,
            sample_group_id=sample_group_id,
        )

    @classmethod
    def quaternion(
        cls,
        mesh: InputGeometry = None,
        value: InputRotation = None,
        group_id: InputInteger = 0,
        sample_position: InputVector = None,
        sample_group_id: InputInteger = 0,
    ) -> "SampleNearestSurface[RotationSocket]":
        """Create Sample Nearest Surface with operation 'Quaternion'. Floating point quaternion rotation"""
        return SampleNearestSurface(
            data_type="QUATERNION",
            mesh=mesh,
            value=value,
            group_id=group_id,
            sample_position=sample_position,
            sample_group_id=sample_group_id,
        )

    @classmethod
    def input_4x4_matrix(
        cls,
        mesh: InputGeometry = None,
        value: InputMatrix = None,
        group_id: InputInteger = 0,
        sample_position: InputVector = None,
        sample_group_id: InputInteger = 0,
    ) -> "SampleNearestSurface[MatrixSocket]":
        """Create Sample Nearest Surface with operation '4x4 Matrix'. Floating point matrix"""
        return SampleNearestSurface(
            data_type="FLOAT4X4",
            mesh=mesh,
            value=value,
            group_id=group_id,
            sample_position=sample_position,
            sample_group_id=sample_group_id,
        )

    @property
    def data_type(
        self,
    ) -> Literal[
        "FLOAT",
        "INT",
        "BOOLEAN",
        "FLOAT_VECTOR",
        "FLOAT_COLOR",
        "QUATERNION",
        "FLOAT4X4",
    ]:
        return self.node.data_type  # ty: ignore[invalid-return-type]

    @data_type.setter
    def data_type(
        self,
        value: Literal[
            "FLOAT",
            "INT",
            "BOOLEAN",
            "FLOAT_VECTOR",
            "FLOAT_COLOR",
            "QUATERNION",
            "FLOAT4X4",
        ],
    ):
        self.node.data_type = value


class SampleUVSurface(BaseNode, Generic[_T]):
    """
    Calculate the interpolated values of a mesh attribute at a UV coordinate

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    value : InputFloat
        Value
    source_uv_map : InputVector
        UV Map
    sample_uv : InputVector
        Sample UV

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.value : FloatSocket
        Value
    i.source_uv_map : VectorSocket
        UV Map
    i.sample_uv : VectorSocket
        Sample UV

    Outputs
    -------
    o.value : FloatSocket
        Value
    o.is_valid : BooleanSocket
        Is Valid
    """

    _bl_idname = "GeometryNodeSampleUVSurface"
    node: bpy.types.GeometryNodeSampleUVSurface

    class _Inputs(SocketAccessor, Generic[_S]):
        mesh: GeometrySocket
        """Mesh"""
        value: _S
        """Value"""
        source_uv_map: VectorSocket
        """UV Map"""
        sample_uv: VectorSocket
        """Sample UV"""

    class _Outputs(SocketAccessor, Generic[_S]):
        value: _S
        """Value"""
        is_valid: BooleanSocket
        """Is Valid"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs[_T]: ...
        @property
        def o(self) -> _Outputs[_T]: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        value: InputAny = 0.0,
        source_uv_map: InputVector = None,
        sample_uv: InputVector = None,
        *,
        data_type: Literal[
            "FLOAT",
            "INT",
            "BOOLEAN",
            "FLOAT_VECTOR",
            "FLOAT_COLOR",
            "QUATERNION",
            "FLOAT4X4",
        ] = "FLOAT",
    ):
        super().__init__()
        key_args = {
            "Mesh": mesh,
            "Value": value,
            "Source UV Map": source_uv_map,
            "Sample UV": sample_uv,
        }
        self.data_type = data_type
        self._establish_links(**key_args)

    @classmethod
    def float(
        cls,
        mesh: InputGeometry = None,
        value: InputFloat = 0.0,
        source_uv_map: InputVector = None,
        sample_uv: InputVector = None,
    ) -> "SampleUVSurface[FloatSocket]":
        """Create Sample UV Surface with operation 'Float'. Floating-point value"""
        return SampleUVSurface(
            data_type="FLOAT",
            mesh=mesh,
            value=value,
            source_uv_map=source_uv_map,
            sample_uv=sample_uv,
        )

    @classmethod
    def integer(
        cls,
        mesh: InputGeometry = None,
        value: InputInteger = 0,
        source_uv_map: InputVector = None,
        sample_uv: InputVector = None,
    ) -> "SampleUVSurface[IntegerSocket]":
        """Create Sample UV Surface with operation 'Integer'. 32-bit integer"""
        return SampleUVSurface(
            data_type="INT",
            mesh=mesh,
            value=value,
            source_uv_map=source_uv_map,
            sample_uv=sample_uv,
        )

    @classmethod
    def boolean(
        cls,
        mesh: InputGeometry = None,
        value: InputBoolean = False,
        source_uv_map: InputVector = None,
        sample_uv: InputVector = None,
    ) -> "SampleUVSurface[BooleanSocket]":
        """Create Sample UV Surface with operation 'Boolean'. True or false"""
        return SampleUVSurface(
            data_type="BOOLEAN",
            mesh=mesh,
            value=value,
            source_uv_map=source_uv_map,
            sample_uv=sample_uv,
        )

    @classmethod
    def vector(
        cls,
        mesh: InputGeometry = None,
        value: InputVector = None,
        source_uv_map: InputVector = None,
        sample_uv: InputVector = None,
    ) -> "SampleUVSurface[VectorSocket]":
        """Create Sample UV Surface with operation 'Vector'. 3D vector with floating-point values"""
        return SampleUVSurface(
            data_type="FLOAT_VECTOR",
            mesh=mesh,
            value=value,
            source_uv_map=source_uv_map,
            sample_uv=sample_uv,
        )

    @classmethod
    def color(
        cls,
        mesh: InputGeometry = None,
        value: InputColor = None,
        source_uv_map: InputVector = None,
        sample_uv: InputVector = None,
    ) -> "SampleUVSurface[ColorSocket]":
        """Create Sample UV Surface with operation 'Color'. RGBA color with 32-bit floating-point values"""
        return SampleUVSurface(
            data_type="FLOAT_COLOR",
            mesh=mesh,
            value=value,
            source_uv_map=source_uv_map,
            sample_uv=sample_uv,
        )

    @classmethod
    def quaternion(
        cls,
        mesh: InputGeometry = None,
        value: InputRotation = None,
        source_uv_map: InputVector = None,
        sample_uv: InputVector = None,
    ) -> "SampleUVSurface[RotationSocket]":
        """Create Sample UV Surface with operation 'Quaternion'. Floating point quaternion rotation"""
        return SampleUVSurface(
            data_type="QUATERNION",
            mesh=mesh,
            value=value,
            source_uv_map=source_uv_map,
            sample_uv=sample_uv,
        )

    @classmethod
    def input_4x4_matrix(
        cls,
        mesh: InputGeometry = None,
        value: InputMatrix = None,
        source_uv_map: InputVector = None,
        sample_uv: InputVector = None,
    ) -> "SampleUVSurface[MatrixSocket]":
        """Create Sample UV Surface with operation '4x4 Matrix'. Floating point matrix"""
        return SampleUVSurface(
            data_type="FLOAT4X4",
            mesh=mesh,
            value=value,
            source_uv_map=source_uv_map,
            sample_uv=sample_uv,
        )

    @property
    def data_type(
        self,
    ) -> Literal[
        "FLOAT",
        "INT",
        "BOOLEAN",
        "FLOAT_VECTOR",
        "FLOAT_COLOR",
        "QUATERNION",
        "FLOAT4X4",
    ]:
        return self.node.data_type  # ty: ignore[invalid-return-type]

    @data_type.setter
    def data_type(
        self,
        value: Literal[
            "FLOAT",
            "INT",
            "BOOLEAN",
            "FLOAT_VECTOR",
            "FLOAT_COLOR",
            "QUATERNION",
            "FLOAT4X4",
        ],
    ):
        self.node.data_type = value


class ScaleElements(BaseNode):
    """
    Scale groups of connected edges and faces

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    scale : InputFloat
        Scale
    center : InputVector
        Center
    scale_mode : InputMenu | Literal['Uniform', 'Single Axis']
        Scale Mode
    axis : InputVector
        Axis

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.scale : FloatSocket
        Scale
    i.center : VectorSocket
        Center
    i.scale_mode : MenuSocket
        Scale Mode
    i.axis : VectorSocket
        Axis

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeScaleElements"
    node: bpy.types.GeometryNodeScaleElements

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        scale: FloatSocket
        """Scale"""
        center: VectorSocket
        """Center"""
        scale_mode: MenuSocket
        """Scale Mode"""
        axis: VectorSocket
        """Axis"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        scale: InputFloat = 1.0,
        center: InputVector = None,
        scale_mode: InputMenu | Literal["Uniform", "Single Axis"] = "Uniform",
        axis: InputVector = None,
        *,
        domain: Literal["FACE", "EDGE"] = "FACE",
    ):
        super().__init__()
        key_args = {
            "Geometry": geometry,
            "Selection": selection,
            "Scale": scale,
            "Center": center,
            "Scale Mode": scale_mode,
            "Axis": axis,
        }
        self.domain = domain
        self._establish_links(**key_args)

    @classmethod
    def face(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        scale: InputFloat = 1.0,
        center: InputVector = None,
        scale_mode: InputMenu | Literal["Uniform", "Single Axis"] = "Uniform",
    ) -> "ScaleElements":
        """Create Scale Elements with operation 'Face'. Scale individual faces or neighboring face islands"""
        return cls(
            domain="FACE",
            geometry=geometry,
            selection=selection,
            scale=scale,
            center=center,
            scale_mode=scale_mode,
        )

    @classmethod
    def edge(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        scale: InputFloat = 1.0,
        center: InputVector = None,
        scale_mode: InputMenu | Literal["Uniform", "Single Axis"] = "Uniform",
    ) -> "ScaleElements":
        """Create Scale Elements with operation 'Edge'. Scale individual edges or neighboring edge islands"""
        return cls(
            domain="EDGE",
            geometry=geometry,
            selection=selection,
            scale=scale,
            center=center,
            scale_mode=scale_mode,
        )

    @property
    def domain(self) -> Literal["FACE", "EDGE"]:
        return self.node.domain

    @domain.setter
    def domain(self, value: Literal["FACE", "EDGE"]):
        self.node.domain = value


class ScaleInstances(BaseNode):
    """
    Scale geometry instances in local or global space

    Parameters
    ----------
    instances : InputGeometry
        Instances
    selection : InputBoolean
        Selection
    scale : InputVector
        Scale
    center : InputVector
        Center
    local_space : InputBoolean
        Local Space

    Inputs
    ------
    i.instances : GeometrySocket
        Instances
    i.selection : BooleanSocket
        Selection
    i.scale : VectorSocket
        Scale
    i.center : VectorSocket
        Center
    i.local_space : BooleanSocket
        Local Space

    Outputs
    -------
    o.instances : GeometrySocket
        Instances
    """

    _bl_idname = "GeometryNodeScaleInstances"
    node: bpy.types.GeometryNodeScaleInstances

    class _Inputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""
        selection: BooleanSocket
        """Selection"""
        scale: VectorSocket
        """Scale"""
        center: VectorSocket
        """Center"""
        local_space: BooleanSocket
        """Local Space"""

    class _Outputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        instances: InputGeometry = None,
        selection: InputBoolean = True,
        scale: InputVector = None,
        center: InputVector = None,
        local_space: InputBoolean = True,
    ):
        super().__init__()
        key_args = {
            "Instances": instances,
            "Selection": selection,
            "Scale": scale,
            "Center": center,
            "Local Space": local_space,
        }

        self._establish_links(**key_args)


class SeparateComponents(BaseNode):
    """
    Split a geometry into a separate output for each type of data in the geometry

    Parameters
    ----------
    geometry : InputGeometry
        Geometry

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    o.curve : GeometrySocket
        Curve
    o.grease_pencil : GeometrySocket
        Grease Pencil
    o.point_cloud : GeometrySocket
        Point Cloud
    o.volume : GeometrySocket
        Volume
    o.instances : GeometrySocket
        Instances
    """

    _bl_idname = "GeometryNodeSeparateComponents"
    node: bpy.types.GeometryNodeSeparateComponents

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        curve: GeometrySocket
        """Curve"""
        grease_pencil: GeometrySocket
        """Grease Pencil"""
        point_cloud: GeometrySocket
        """Point Cloud"""
        volume: GeometrySocket
        """Volume"""
        instances: GeometrySocket
        """Instances"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(self, geometry: InputGeometry = None):
        super().__init__()
        key_args = {"Geometry": geometry}

        self._establish_links(**key_args)


class SeparateGeometry(BaseNode):
    """
    Split a geometry into two geometry outputs based on a selection

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection

    Outputs
    -------
    o.selection : GeometrySocket
        Selection
    o.inverted : GeometrySocket
        Inverted
    """

    _bl_idname = "GeometryNodeSeparateGeometry"
    node: bpy.types.GeometryNodeSeparateGeometry

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""

    class _Outputs(SocketAccessor):
        selection: GeometrySocket
        """Selection"""
        inverted: GeometrySocket
        """Inverted"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        *,
        domain: Literal[
            "POINT", "EDGE", "FACE", "CURVE", "INSTANCE", "LAYER"
        ] = "POINT",
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Selection": selection}
        self.domain = domain
        self._establish_links(**key_args)

    @classmethod
    def point(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SeparateGeometry":
        """Create Separate Geometry with operation 'Point'. Attribute on point"""
        return cls(domain="POINT", geometry=geometry, selection=selection)

    @classmethod
    def edge(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SeparateGeometry":
        """Create Separate Geometry with operation 'Edge'. Attribute on mesh edge"""
        return cls(domain="EDGE", geometry=geometry, selection=selection)

    @classmethod
    def face(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SeparateGeometry":
        """Create Separate Geometry with operation 'Face'. Attribute on mesh faces"""
        return cls(domain="FACE", geometry=geometry, selection=selection)

    @classmethod
    def spline(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SeparateGeometry":
        """Create Separate Geometry with operation 'Spline'. Attribute on spline"""
        return cls(domain="CURVE", geometry=geometry, selection=selection)

    @classmethod
    def instance(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SeparateGeometry":
        """Create Separate Geometry with operation 'Instance'. Attribute on instance"""
        return cls(domain="INSTANCE", geometry=geometry, selection=selection)

    @classmethod
    def layer(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SeparateGeometry":
        """Create Separate Geometry with operation 'Layer'. Attribute on Grease Pencil layer"""
        return cls(domain="LAYER", geometry=geometry, selection=selection)

    @property
    def domain(self) -> Literal["POINT", "EDGE", "FACE", "CURVE", "INSTANCE", "LAYER"]:
        return self.node.domain

    @domain.setter
    def domain(
        self, value: Literal["POINT", "EDGE", "FACE", "CURVE", "INSTANCE", "LAYER"]
    ):
        self.node.domain = value


class SetCurveNormal(BaseNode):
    """
    Set the evaluation mode for curve normals

    Parameters
    ----------
    curve : InputGeometry
        Curve
    selection : InputBoolean
        Selection
    mode : InputMenu | Literal['Minimum Twist', 'Z Up', 'Free']
        Mode
    normal : InputVector
        Normal

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection
    i.mode : MenuSocket
        Mode
    i.normal : VectorSocket
        Normal

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeSetCurveNormal"
    node: bpy.types.GeometryNodeSetCurveNormal

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""
        mode: MenuSocket
        """Mode"""
        normal: VectorSocket
        """Normal"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        mode: InputMenu | Literal["Minimum Twist", "Z Up", "Free"] = "Minimum Twist",
        normal: InputVector = None,
    ):
        super().__init__()
        key_args = {
            "Curve": curve,
            "Selection": selection,
            "Mode": mode,
            "Normal": normal,
        }

        self._establish_links(**key_args)


class SetCurveRadius(BaseNode):
    """
    Set the radius of the curve at each control point

    Parameters
    ----------
    curve : InputGeometry
        Curve
    selection : InputBoolean
        Selection
    radius : InputFloat
        Radius

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection
    i.radius : FloatSocket
        Radius

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeSetCurveRadius"
    node: bpy.types.GeometryNodeSetCurveRadius

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""
        radius: FloatSocket
        """Radius"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        radius: InputFloat = 0.005,
    ):
        super().__init__()
        key_args = {"Curve": curve, "Selection": selection, "Radius": radius}

        self._establish_links(**key_args)


class SetCurveTilt(BaseNode):
    """
    Set the tilt angle at each curve control point

    Parameters
    ----------
    curve : InputGeometry
        Curve
    selection : InputBoolean
        Selection
    tilt : InputFloat
        Tilt

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection
    i.tilt : FloatSocket
        Tilt

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeSetCurveTilt"
    node: bpy.types.GeometryNodeSetCurveTilt

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""
        tilt: FloatSocket
        """Tilt"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        tilt: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {"Curve": curve, "Selection": selection, "Tilt": tilt}

        self._establish_links(**key_args)


class SetFaceSet(BaseNode):
    """
    Set sculpt face set values for faces

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    selection : InputBoolean
        Selection
    face_set : InputInteger
        Face Set

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.selection : BooleanSocket
        Selection
    i.face_set : IntegerSocket
        Face Set

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeToolSetFaceSet"
    node: bpy.types.GeometryNodeToolSetFaceSet

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        selection: BooleanSocket
        """Selection"""
        face_set: IntegerSocket
        """Face Set"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        face_set: InputInteger = 0,
    ):
        super().__init__()
        key_args = {"Mesh": mesh, "Selection": selection, "Face Set": face_set}

        self._establish_links(**key_args)


class SetGeometryBundle(BaseNode):
    """
    Set the bundle of a geometry

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    bundle : InputBundle
        Bundle

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.bundle : BundleSocket
        Bundle

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeSetGeometryBundle"
    node: bpy.types.GeometryNodeSetGeometryBundle

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        bundle: BundleSocket
        """Bundle"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        bundle: InputBundle = None,
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Bundle": bundle}

        self._establish_links(**key_args)


class SetGeometryName(BaseNode):
    """
    Set the name of a geometry for easier debugging

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    name : InputString
        Name

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.name : StringSocket
        Name

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeSetGeometryName"
    node: bpy.types.GeometryNodeSetGeometryName

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        name: StringSocket
        """Name"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        name: InputString = "",
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Name": name}

        self._establish_links(**key_args)


class SetGreasePencilColor(BaseNode):
    """
    Set color and opacity attributes on Grease Pencil geometry

    Parameters
    ----------
    grease_pencil : InputGeometry
        Grease Pencil
    selection : InputBoolean
        Selection
    color : InputColor
        Color
    opacity : InputFloat
        Opacity

    Inputs
    ------
    i.grease_pencil : GeometrySocket
        Grease Pencil
    i.selection : BooleanSocket
        Selection
    i.color : ColorSocket
        Color
    i.opacity : FloatSocket
        Opacity

    Outputs
    -------
    o.grease_pencil : GeometrySocket
        Grease Pencil
    """

    _bl_idname = "GeometryNodeSetGreasePencilColor"
    node: bpy.types.GeometryNodeSetGreasePencilColor

    class _Inputs(SocketAccessor):
        grease_pencil: GeometrySocket
        """Grease Pencil"""
        selection: BooleanSocket
        """Selection"""
        color: ColorSocket
        """Color"""
        opacity: FloatSocket
        """Opacity"""

    class _Outputs(SocketAccessor):
        grease_pencil: GeometrySocket
        """Grease Pencil"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        grease_pencil: InputGeometry = None,
        selection: InputBoolean = True,
        color: InputColor = None,
        opacity: InputFloat = 1.0,
        *,
        mode: Literal["STROKE", "FILL"] = "STROKE",
    ):
        super().__init__()
        key_args = {
            "Grease Pencil": grease_pencil,
            "Selection": selection,
            "Color": color,
            "Opacity": opacity,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def stroke(
        cls,
        grease_pencil: InputGeometry = None,
        selection: InputBoolean = True,
        color: InputColor = None,
        opacity: InputFloat = 1.0,
    ) -> "SetGreasePencilColor":
        """Create Set Grease Pencil Color with operation 'Stroke'. Set the color and opacity for the points of the stroke"""
        return cls(
            mode="STROKE",
            grease_pencil=grease_pencil,
            selection=selection,
            color=color,
            opacity=opacity,
        )

    @classmethod
    def fill(
        cls,
        grease_pencil: InputGeometry = None,
        selection: InputBoolean = True,
        color: InputColor = None,
        opacity: InputFloat = 1.0,
    ) -> "SetGreasePencilColor":
        """Create Set Grease Pencil Color with operation 'Fill'. Set the color and opacity for the stroke fills"""
        return cls(
            mode="FILL",
            grease_pencil=grease_pencil,
            selection=selection,
            color=color,
            opacity=opacity,
        )

    @property
    def mode(self) -> Literal["STROKE", "FILL"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["STROKE", "FILL"]):
        self.node.mode = value


class SetGreasePencilDepth(BaseNode):
    """
    Set the Grease Pencil depth order to use

    Parameters
    ----------
    grease_pencil : InputGeometry
        Grease Pencil

    Inputs
    ------
    i.grease_pencil : GeometrySocket
        Grease Pencil

    Outputs
    -------
    o.grease_pencil : GeometrySocket
        Grease Pencil
    """

    _bl_idname = "GeometryNodeSetGreasePencilDepth"
    node: bpy.types.GeometryNodeSetGreasePencilDepth

    class _Inputs(SocketAccessor):
        grease_pencil: GeometrySocket
        """Grease Pencil"""

    class _Outputs(SocketAccessor):
        grease_pencil: GeometrySocket
        """Grease Pencil"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        grease_pencil: InputGeometry = None,
        *,
        depth_order: Literal["2D", "3D"] = "2D",
    ):
        super().__init__()
        key_args = {"Grease Pencil": grease_pencil}
        self.depth_order = depth_order
        self._establish_links(**key_args)

    @property
    def depth_order(self) -> Literal["2D", "3D"]:
        return self.node.depth_order

    @depth_order.setter
    def depth_order(self, value: Literal["2D", "3D"]):
        self.node.depth_order = value


class SetGreasePencilSoftness(BaseNode):
    """
    Set softness attribute on Grease Pencil geometry

    Parameters
    ----------
    grease_pencil : InputGeometry
        Grease Pencil
    selection : InputBoolean
        Selection
    softness : InputFloat
        Softness

    Inputs
    ------
    i.grease_pencil : GeometrySocket
        Grease Pencil
    i.selection : BooleanSocket
        Selection
    i.softness : FloatSocket
        Softness

    Outputs
    -------
    o.grease_pencil : GeometrySocket
        Grease Pencil
    """

    _bl_idname = "GeometryNodeSetGreasePencilSoftness"
    node: bpy.types.GeometryNodeSetGreasePencilSoftness

    class _Inputs(SocketAccessor):
        grease_pencil: GeometrySocket
        """Grease Pencil"""
        selection: BooleanSocket
        """Selection"""
        softness: FloatSocket
        """Softness"""

    class _Outputs(SocketAccessor):
        grease_pencil: GeometrySocket
        """Grease Pencil"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        grease_pencil: InputGeometry = None,
        selection: InputBoolean = True,
        softness: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {
            "Grease Pencil": grease_pencil,
            "Selection": selection,
            "Softness": softness,
        }

        self._establish_links(**key_args)


class SetHandlePositions(BaseNode):
    """
    Set the positions for the handles of Bézier curves

    Parameters
    ----------
    curve : InputGeometry
        Curve
    selection : InputBoolean
        Selection
    position : InputVector
        Position
    offset : InputVector
        Offset

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection
    i.position : VectorSocket
        Position
    i.offset : VectorSocket
        Offset

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeSetCurveHandlePositions"
    node: bpy.types.GeometryNodeSetCurveHandlePositions

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""
        position: VectorSocket
        """Position"""
        offset: VectorSocket
        """Offset"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        position: InputVector = None,
        offset: InputVector = None,
        *,
        mode: Literal["LEFT", "RIGHT"] = "LEFT",
    ):
        super().__init__()
        key_args = {
            "Curve": curve,
            "Selection": selection,
            "Position": position,
            "Offset": offset,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def left(
        cls,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        position: InputVector = None,
        offset: InputVector = None,
    ) -> "SetHandlePositions":
        """Create Set Handle Positions with operation 'Left'. Use the left handles"""
        return cls(
            mode="LEFT",
            curve=curve,
            selection=selection,
            position=position,
            offset=offset,
        )

    @classmethod
    def right(
        cls,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        position: InputVector = None,
        offset: InputVector = None,
    ) -> "SetHandlePositions":
        """Create Set Handle Positions with operation 'Right'. Use the right handles"""
        return cls(
            mode="RIGHT",
            curve=curve,
            selection=selection,
            position=position,
            offset=offset,
        )

    @property
    def mode(self) -> Literal["LEFT", "RIGHT"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["LEFT", "RIGHT"]):
        self.node.mode = value


class SetHandleType(_HandleModeMixin, BaseNode):
    """
    Set the handle type for the control points of a Bézier curve

    Parameters
    ----------
    curve : InputGeometry
        Curve
    selection : InputBoolean
        Selection

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeCurveSetHandles"
    node: bpy.types.GeometryNodeCurveSetHandles

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    @classmethod
    def free(
        cls, curve: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetHandleType":
        """Create Set Handle Type with operation 'Free'. The handle can be moved anywhere, and does not influence the point's other handle"""
        return cls(handle_type="FREE", curve=curve, selection=selection)

    @classmethod
    def auto(
        cls, curve: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetHandleType":
        """Create Set Handle Type with operation 'Auto'. The location is automatically calculated to be smooth"""
        return cls(handle_type="AUTO", curve=curve, selection=selection)

    @classmethod
    def vector(
        cls, curve: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetHandleType":
        """Create Set Handle Type with operation 'Vector'. The location is calculated to point to the next/previous control point"""
        return cls(handle_type="VECTOR", curve=curve, selection=selection)

    @classmethod
    def align(
        cls, curve: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetHandleType":
        """Create Set Handle Type with operation 'Align'. The location is constrained to point in the opposite direction as the other handle"""
        return cls(handle_type="ALIGN", curve=curve, selection=selection)

    @property
    def handle_type(self) -> Literal["FREE", "AUTO", "VECTOR", "ALIGN"]:
        return self.node.handle_type

    @handle_type.setter
    def handle_type(self, value: Literal["FREE", "AUTO", "VECTOR", "ALIGN"]):
        self.node.handle_type = value

    def __init__(
        self,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        *,
        left: bool = True,
        right: bool = True,
        handle_type: Literal["FREE", "AUTO", "VECTOR", "ALIGN"] = "AUTO",
    ):
        super().__init__()
        self.handle_type = handle_type
        self.left = left
        self.right = right
        self._establish_links(Curve=curve, Selection=selection)


class SetID(BaseNode):
    """
    Set the id attribute on the input geometry, mainly used internally for randomizing

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    id : InputInteger
        ID

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.id : IntegerSocket
        ID

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeSetID"
    node: bpy.types.GeometryNodeSetID

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        id: IntegerSocket
        """ID"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        id: InputInteger = 0,
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Selection": selection, "ID": id}

        self._establish_links(**key_args)


class SetInstanceTransform(BaseNode):
    """
    Set the transformation matrix of every instance

    Parameters
    ----------
    instances : InputGeometry
        Instances
    selection : InputBoolean
        Selection
    transform : InputMatrix
        Transform

    Inputs
    ------
    i.instances : GeometrySocket
        Instances
    i.selection : BooleanSocket
        Selection
    i.transform : MatrixSocket
        Transform

    Outputs
    -------
    o.instances : GeometrySocket
        Instances
    """

    _bl_idname = "GeometryNodeSetInstanceTransform"
    node: bpy.types.GeometryNodeSetInstanceTransform

    class _Inputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""
        selection: BooleanSocket
        """Selection"""
        transform: MatrixSocket
        """Transform"""

    class _Outputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        instances: InputGeometry = None,
        selection: InputBoolean = True,
        transform: InputMatrix = None,
    ):
        super().__init__()
        key_args = {
            "Instances": instances,
            "Selection": selection,
            "Transform": transform,
        }

        self._establish_links(**key_args)


class SetMaterial(BaseNode):
    """
    Assign a material to geometry elements

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    material : InputMaterial
        Material

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.material : MaterialSocket
        Material

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeSetMaterial"
    node: bpy.types.GeometryNodeSetMaterial

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        material: MaterialSocket
        """Material"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        material: InputMaterial = None,
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Selection": selection, "Material": material}

        self._establish_links(**key_args)


class SetMaterialIndex(BaseNode):
    """
    Set the material index for each selected geometry element

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    material_index : InputInteger
        Material Index

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.material_index : IntegerSocket
        Material Index

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeSetMaterialIndex"
    node: bpy.types.GeometryNodeSetMaterialIndex

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        material_index: IntegerSocket
        """Material Index"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        material_index: InputInteger = 0,
    ):
        super().__init__()
        key_args = {
            "Geometry": geometry,
            "Selection": selection,
            "Material Index": material_index,
        }

        self._establish_links(**key_args)


class SetMeshNormal(BaseNode):
    """
    Store a normal vector for each mesh element

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    remove_custom : InputBoolean
        Remove Custom
    edge_sharpness : InputBoolean
        Edge Sharpness
    face_sharpness : InputBoolean
        Face Sharpness
    custom_normal : InputVector
        Custom Normal

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.remove_custom : BooleanSocket
        Remove Custom
    i.edge_sharpness : BooleanSocket
        Edge Sharpness
    i.face_sharpness : BooleanSocket
        Face Sharpness
    i.custom_normal : VectorSocket
        Custom Normal

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeSetMeshNormal"
    node: bpy.types.GeometryNodeSetMeshNormal

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        remove_custom: BooleanSocket
        """Remove Custom"""
        edge_sharpness: BooleanSocket
        """Edge Sharpness"""
        face_sharpness: BooleanSocket
        """Face Sharpness"""
        custom_normal: VectorSocket
        """Custom Normal"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        remove_custom: InputBoolean = True,
        edge_sharpness: InputBoolean = False,
        face_sharpness: InputBoolean = False,
        custom_normal: InputVector = None,
        *,
        mode: Literal["SHARPNESS", "FREE", "TANGENT_SPACE"] = "SHARPNESS",
        domain: Literal["POINT", "FACE", "CORNER"] = "POINT",
    ):
        super().__init__()
        self.mode = mode
        self.domain = domain
        _all_args = {
            "Mesh": mesh,
            "Remove Custom": remove_custom,
            "Edge Sharpness": edge_sharpness,
            "Face Sharpness": face_sharpness,
            "Custom Normal": custom_normal,
        }
        _socket_ids = {s.identifier for s in self.node.inputs}
        key_args = {k: v for k, v in _all_args.items() if k in _socket_ids}
        self._establish_links(**key_args)

    @classmethod
    def sharpness(
        cls,
        mesh: InputGeometry = None,
        remove_custom: InputBoolean = True,
        edge_sharpness: InputBoolean = False,
        face_sharpness: InputBoolean = False,
    ) -> "SetMeshNormal":
        """Create Set Mesh Normal with operation 'Sharpness'. Store the sharpness of each face or edge. Similar to the "Shade Smooth" and "Shade Flat" operators."""
        return cls(
            mode="SHARPNESS",
            mesh=mesh,
            remove_custom=remove_custom,
            edge_sharpness=edge_sharpness,
            face_sharpness=face_sharpness,
        )

    @classmethod
    def free(
        cls, mesh: InputGeometry = None, custom_normal: InputVector = None
    ) -> "SetMeshNormal":
        """Create Set Mesh Normal with operation 'Free'. Store custom normals as simple vectors in the local space of the mesh. Values are not necessarily updated automatically later on as the mesh is deformed."""
        return cls(mode="FREE", mesh=mesh, custom_normal=custom_normal)

    @classmethod
    def tangent_space(
        cls, mesh: InputGeometry = None, custom_normal: InputVector = None
    ) -> "SetMeshNormal":
        """Create Set Mesh Normal with operation 'Tangent Space'. Store normals in a deformation dependent custom transformation space. This method is slower, but can be better when subsequent operations change the mesh without handling normals specifically."""
        return cls(mode="TANGENT_SPACE", mesh=mesh, custom_normal=custom_normal)

    @classmethod
    def point(
        cls,
        mesh: InputGeometry = None,
        remove_custom: InputBoolean = True,
        edge_sharpness: InputBoolean = False,
        face_sharpness: InputBoolean = False,
    ) -> "SetMeshNormal":
        """Create Set Mesh Normal with operation 'Point'. Attribute on point"""
        return cls(
            domain="POINT",
            mesh=mesh,
            remove_custom=remove_custom,
            edge_sharpness=edge_sharpness,
            face_sharpness=face_sharpness,
        )

    @classmethod
    def face(
        cls,
        mesh: InputGeometry = None,
        remove_custom: InputBoolean = True,
        edge_sharpness: InputBoolean = False,
        face_sharpness: InputBoolean = False,
    ) -> "SetMeshNormal":
        """Create Set Mesh Normal with operation 'Face'. Attribute on mesh faces"""
        return cls(
            domain="FACE",
            mesh=mesh,
            remove_custom=remove_custom,
            edge_sharpness=edge_sharpness,
            face_sharpness=face_sharpness,
        )

    @classmethod
    def face_corner(
        cls,
        mesh: InputGeometry = None,
        remove_custom: InputBoolean = True,
        edge_sharpness: InputBoolean = False,
        face_sharpness: InputBoolean = False,
    ) -> "SetMeshNormal":
        """Create Set Mesh Normal with operation 'Face Corner'. Attribute on mesh face corner"""
        return cls(
            domain="CORNER",
            mesh=mesh,
            remove_custom=remove_custom,
            edge_sharpness=edge_sharpness,
            face_sharpness=face_sharpness,
        )

    @property
    def mode(self) -> Literal["SHARPNESS", "FREE", "TANGENT_SPACE"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["SHARPNESS", "FREE", "TANGENT_SPACE"]):
        self.node.mode = value

    @property
    def domain(self) -> Literal["POINT", "FACE", "CORNER"]:
        return self.node.domain

    @domain.setter
    def domain(self, value: Literal["POINT", "FACE", "CORNER"]):
        self.node.domain = value


class SetNurbsOrder(BaseNode):
    """
    Control how many curve control points influence each evaluated point by changing the "nurbs_order" attribute

    Parameters
    ----------
    curves : InputGeometry
        Curves
    selection : InputBoolean
        Selection
    order : InputInteger
        Order

    Inputs
    ------
    i.curves : GeometrySocket
        Curves
    i.selection : BooleanSocket
        Selection
    i.order : IntegerSocket
        Order

    Outputs
    -------
    o.curves : GeometrySocket
        Curves
    """

    _bl_idname = "GeometryNodeSetNURBSOrder"
    node: bpy.types.GeometryNodeSetNURBSOrder

    class _Inputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""
        selection: BooleanSocket
        """Selection"""
        order: IntegerSocket
        """Order"""

    class _Outputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curves: InputGeometry = None,
        selection: InputBoolean = True,
        order: InputInteger = 4,
    ):
        super().__init__()
        key_args = {"Curves": curves, "Selection": selection, "Order": order}

        self._establish_links(**key_args)


class SetNurbsWeight(BaseNode):
    """
    Control the influence of each NURBS control point on the curve by changing the "nurbs_weight" attribute

    Parameters
    ----------
    curves : InputGeometry
        Curves
    selection : InputBoolean
        Selection
    weight : InputFloat
        Weight

    Inputs
    ------
    i.curves : GeometrySocket
        Curves
    i.selection : BooleanSocket
        Selection
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.curves : GeometrySocket
        Curves
    """

    _bl_idname = "GeometryNodeSetNURBSWeight"
    node: bpy.types.GeometryNodeSetNURBSWeight

    class _Inputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""
        selection: BooleanSocket
        """Selection"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        curves: GeometrySocket
        """Curves"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curves: InputGeometry = None,
        selection: InputBoolean = True,
        weight: InputFloat = 1.0,
    ):
        super().__init__()
        key_args = {"Curves": curves, "Selection": selection, "Weight": weight}

        self._establish_links(**key_args)


class SetPointRadius(BaseNode):
    """
    Set the display size of point cloud points

    Parameters
    ----------
    points : InputGeometry
        Points
    selection : InputBoolean
        Selection
    radius : InputFloat
        Radius

    Inputs
    ------
    i.points : GeometrySocket
        Points
    i.selection : BooleanSocket
        Selection
    i.radius : FloatSocket
        Radius

    Outputs
    -------
    o.points : GeometrySocket
        Points
    """

    _bl_idname = "GeometryNodeSetPointRadius"
    node: bpy.types.GeometryNodeSetPointRadius

    class _Inputs(SocketAccessor):
        points: GeometrySocket
        """Points"""
        selection: BooleanSocket
        """Selection"""
        radius: FloatSocket
        """Radius"""

    class _Outputs(SocketAccessor):
        points: GeometrySocket
        """Points"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        points: InputGeometry = None,
        selection: InputBoolean = True,
        radius: InputFloat = 0.05,
    ):
        super().__init__()
        key_args = {"Points": points, "Selection": selection, "Radius": radius}

        self._establish_links(**key_args)


class SetPosition(BaseNode):
    """
    Set the location of each point

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    position : InputVector
        Position
    offset : InputVector
        Offset

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.position : VectorSocket
        Position
    i.offset : VectorSocket
        Offset

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeSetPosition"
    node: bpy.types.GeometryNodeSetPosition

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        position: VectorSocket
        """Position"""
        offset: VectorSocket
        """Offset"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        position: InputVector = None,
        offset: InputVector = None,
    ):
        super().__init__()
        key_args = {
            "Geometry": geometry,
            "Selection": selection,
            "Position": position,
            "Offset": offset,
        }

        self._establish_links(**key_args)


class SetSelection(BaseNode, Generic[_T]):
    """
    Set selection of the edited geometry, for tool execution

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeToolSetSelection"
    node: bpy.types.GeometryNodeToolSetSelection

    class _Inputs(SocketAccessor, Generic[_S]):
        geometry: GeometrySocket
        """Geometry"""
        selection: _S
        """Selection"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs[_T]: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputAny = True,
        *,
        domain: Literal["POINT", "EDGE", "FACE", "CURVE"] = "POINT",
        selection_type: Literal["BOOLEAN", "FLOAT"] = "BOOLEAN",
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Selection": selection}
        self.domain = domain
        self.selection_type = selection_type
        self._establish_links(**key_args)

    @classmethod
    def point(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetSelection[BooleanSocket]":
        """Create Set Selection with operation 'Point'. Attribute on point"""
        return SetSelection(domain="POINT", geometry=geometry, selection=selection)

    @classmethod
    def edge(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetSelection[BooleanSocket]":
        """Create Set Selection with operation 'Edge'. Attribute on mesh edge"""
        return SetSelection(domain="EDGE", geometry=geometry, selection=selection)

    @classmethod
    def face(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetSelection[BooleanSocket]":
        """Create Set Selection with operation 'Face'. Attribute on mesh faces"""
        return SetSelection(domain="FACE", geometry=geometry, selection=selection)

    @classmethod
    def spline(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetSelection[BooleanSocket]":
        """Create Set Selection with operation 'Spline'. Attribute on spline"""
        return SetSelection(domain="CURVE", geometry=geometry, selection=selection)

    @classmethod
    def boolean(
        cls, geometry: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetSelection[BooleanSocket]":
        """Create Set Selection with operation 'Boolean'. Store true or false selection values in edit mode"""
        return SetSelection(
            selection_type="BOOLEAN", geometry=geometry, selection=selection
        )

    @classmethod
    def float(
        cls, geometry: InputGeometry = None, selection: InputFloat = 1.0
    ) -> "SetSelection[FloatSocket]":
        """Create Set Selection with operation 'Float'. Store floating point selection values. For mesh geometry, stored inverted as the sculpt mode mask"""
        return SetSelection(
            selection_type="FLOAT", geometry=geometry, selection=selection
        )

    @property
    def domain(self) -> Literal["POINT", "EDGE", "FACE", "CURVE"]:
        return self.node.domain

    @domain.setter
    def domain(self, value: Literal["POINT", "EDGE", "FACE", "CURVE"]):
        self.node.domain = value

    @property
    def selection_type(self) -> Literal["BOOLEAN", "FLOAT"]:
        return self.node.selection_type

    @selection_type.setter
    def selection_type(self, value: Literal["BOOLEAN", "FLOAT"]):
        self.node.selection_type = value


class SetShadeSmooth(BaseNode):
    """
    Control the smoothness of mesh normals around each face by changing the "shade smooth" attribute

    Parameters
    ----------
    geometry : InputGeometry
        Mesh
    selection : InputBoolean
        Selection
    shade_smooth : InputBoolean
        Shade Smooth

    Inputs
    ------
    i.geometry : GeometrySocket
        Mesh
    i.selection : BooleanSocket
        Selection
    i.shade_smooth : BooleanSocket
        Shade Smooth

    Outputs
    -------
    o.geometry : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeSetShadeSmooth"
    node: bpy.types.GeometryNodeSetShadeSmooth

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Mesh"""
        selection: BooleanSocket
        """Selection"""
        shade_smooth: BooleanSocket
        """Shade Smooth"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        shade_smooth: InputBoolean = True,
        *,
        domain: Literal["EDGE", "FACE"] = "FACE",
    ):
        super().__init__()
        key_args = {
            "Geometry": geometry,
            "Selection": selection,
            "Shade Smooth": shade_smooth,
        }
        self.domain = domain
        self._establish_links(**key_args)

    @classmethod
    def edge(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        shade_smooth: InputBoolean = True,
    ) -> "SetShadeSmooth":
        """Create Set Shade Smooth with operation 'Edge'. Attribute on mesh edge"""
        return cls(
            domain="EDGE",
            geometry=geometry,
            selection=selection,
            shade_smooth=shade_smooth,
        )

    @classmethod
    def face(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        shade_smooth: InputBoolean = True,
    ) -> "SetShadeSmooth":
        """Create Set Shade Smooth with operation 'Face'. Attribute on mesh faces"""
        return cls(
            domain="FACE",
            geometry=geometry,
            selection=selection,
            shade_smooth=shade_smooth,
        )

    @property
    def domain(self) -> Literal["EDGE", "FACE"]:
        return self.node.domain

    @domain.setter
    def domain(self, value: Literal["EDGE", "FACE"]):
        self.node.domain = value


class SetSplineCyclic(BaseNode):
    """
    Control whether each spline loops back on itself by changing the "cyclic" attribute

    Parameters
    ----------
    geometry : InputGeometry
        Curve
    selection : InputBoolean
        Selection
    cyclic : InputBoolean
        Cyclic

    Inputs
    ------
    i.geometry : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection
    i.cyclic : BooleanSocket
        Cyclic

    Outputs
    -------
    o.geometry : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeSetSplineCyclic"
    node: bpy.types.GeometryNodeSetSplineCyclic

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""
        cyclic: BooleanSocket
        """Cyclic"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        cyclic: InputBoolean = False,
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Selection": selection, "Cyclic": cyclic}

        self._establish_links(**key_args)


class SetSplineResolution(BaseNode):
    """
    Control how many evaluated points should be generated on every curve segment

    Parameters
    ----------
    geometry : InputGeometry
        Curve
    selection : InputBoolean
        Selection
    resolution : InputInteger
        Resolution

    Inputs
    ------
    i.geometry : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection
    i.resolution : IntegerSocket
        Resolution

    Outputs
    -------
    o.geometry : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeSetSplineResolution"
    node: bpy.types.GeometryNodeSetSplineResolution

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""
        resolution: IntegerSocket
        """Resolution"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        resolution: InputInteger = 12,
    ):
        super().__init__()
        key_args = {
            "Geometry": geometry,
            "Selection": selection,
            "Resolution": resolution,
        }

        self._establish_links(**key_args)


class SetSplineType(BaseNode):
    """
    Change the type of curves

    Parameters
    ----------
    curve : InputGeometry
        Curve
    selection : InputBoolean
        Selection

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeCurveSplineType"
    node: bpy.types.GeometryNodeCurveSplineType

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        *,
        spline_type: Literal["CATMULL_ROM", "POLY", "BEZIER", "NURBS"] = "POLY",
    ):
        super().__init__()
        key_args = {"Curve": curve, "Selection": selection}
        self.spline_type = spline_type
        self._establish_links(**key_args)

    @classmethod
    def catmull_rom(
        cls, curve: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetSplineType":
        """Create Set Spline Type with operation 'Catmull Rom'."""
        return cls(spline_type="CATMULL_ROM", curve=curve, selection=selection)

    @classmethod
    def poly(
        cls, curve: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetSplineType":
        """Create Set Spline Type with operation 'Poly'."""
        return cls(spline_type="POLY", curve=curve, selection=selection)

    @classmethod
    def bézier(
        cls, curve: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetSplineType":
        """Create Set Spline Type with operation 'Bézier'."""
        return cls(spline_type="BEZIER", curve=curve, selection=selection)

    @classmethod
    def nurbs(
        cls, curve: InputGeometry = None, selection: InputBoolean = True
    ) -> "SetSplineType":
        """Create Set Spline Type with operation 'NURBS'."""
        return cls(spline_type="NURBS", curve=curve, selection=selection)

    @property
    def spline_type(self) -> Literal["CATMULL_ROM", "POLY", "BEZIER", "NURBS"]:
        return self.node.spline_type

    @spline_type.setter
    def spline_type(self, value: Literal["CATMULL_ROM", "POLY", "BEZIER", "NURBS"]):
        self.node.spline_type = value


class SortElements(BaseNode):
    """
    Rearrange geometry elements, changing their indices

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    group_id : InputInteger
        Group ID
    sort_weight : InputFloat
        Sort Weight

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.group_id : IntegerSocket
        Group ID
    i.sort_weight : FloatSocket
        Sort Weight

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeSortElements"
    node: bpy.types.GeometryNodeSortElements

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        group_id: IntegerSocket
        """Group ID"""
        sort_weight: FloatSocket
        """Sort Weight"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
        sort_weight: InputFloat = 0.0,
        *,
        domain: Literal["POINT", "EDGE", "FACE", "CURVE", "INSTANCE"] = "POINT",
    ):
        super().__init__()
        key_args = {
            "Geometry": geometry,
            "Selection": selection,
            "Group ID": group_id,
            "Sort Weight": sort_weight,
        }
        self.domain = domain
        self._establish_links(**key_args)

    @classmethod
    def point(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
        sort_weight: InputFloat = 0.0,
    ) -> "SortElements":
        """Create Sort Elements with operation 'Point'. Attribute on point"""
        return cls(
            domain="POINT",
            geometry=geometry,
            selection=selection,
            group_id=group_id,
            sort_weight=sort_weight,
        )

    @classmethod
    def edge(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
        sort_weight: InputFloat = 0.0,
    ) -> "SortElements":
        """Create Sort Elements with operation 'Edge'. Attribute on mesh edge"""
        return cls(
            domain="EDGE",
            geometry=geometry,
            selection=selection,
            group_id=group_id,
            sort_weight=sort_weight,
        )

    @classmethod
    def face(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
        sort_weight: InputFloat = 0.0,
    ) -> "SortElements":
        """Create Sort Elements with operation 'Face'. Attribute on mesh faces"""
        return cls(
            domain="FACE",
            geometry=geometry,
            selection=selection,
            group_id=group_id,
            sort_weight=sort_weight,
        )

    @classmethod
    def spline(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
        sort_weight: InputFloat = 0.0,
    ) -> "SortElements":
        """Create Sort Elements with operation 'Spline'. Attribute on spline"""
        return cls(
            domain="CURVE",
            geometry=geometry,
            selection=selection,
            group_id=group_id,
            sort_weight=sort_weight,
        )

    @classmethod
    def instance(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
        sort_weight: InputFloat = 0.0,
    ) -> "SortElements":
        """Create Sort Elements with operation 'Instance'. Attribute on instance"""
        return cls(
            domain="INSTANCE",
            geometry=geometry,
            selection=selection,
            group_id=group_id,
            sort_weight=sort_weight,
        )

    @property
    def domain(self) -> Literal["POINT", "EDGE", "FACE", "CURVE", "INSTANCE"]:
        return self.node.domain

    @domain.setter
    def domain(self, value: Literal["POINT", "EDGE", "FACE", "CURVE", "INSTANCE"]):
        self.node.domain = value


class Spiral(BaseNode):
    """
    Generate a poly spline in a spiral shape

    Parameters
    ----------
    resolution : InputInteger
        Resolution
    rotations : InputFloat
        Rotations
    start_radius : InputFloat
        Start Radius
    end_radius : InputFloat
        End Radius
    height : InputFloat
        Height
    reverse : InputBoolean
        Reverse

    Inputs
    ------
    i.resolution : IntegerSocket
        Resolution
    i.rotations : FloatSocket
        Rotations
    i.start_radius : FloatSocket
        Start Radius
    i.end_radius : FloatSocket
        End Radius
    i.height : FloatSocket
        Height
    i.reverse : BooleanSocket
        Reverse

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeCurveSpiral"
    node: bpy.types.GeometryNodeCurveSpiral

    class _Inputs(SocketAccessor):
        resolution: IntegerSocket
        """Resolution"""
        rotations: FloatSocket
        """Rotations"""
        start_radius: FloatSocket
        """Start Radius"""
        end_radius: FloatSocket
        """End Radius"""
        height: FloatSocket
        """Height"""
        reverse: BooleanSocket
        """Reverse"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        resolution: InputInteger = 32,
        rotations: InputFloat = 2.0,
        start_radius: InputFloat = 1.0,
        end_radius: InputFloat = 2.0,
        height: InputFloat = 2.0,
        reverse: InputBoolean = False,
    ):
        super().__init__()
        key_args = {
            "Resolution": resolution,
            "Rotations": rotations,
            "Start Radius": start_radius,
            "End Radius": end_radius,
            "Height": height,
            "Reverse": reverse,
        }

        self._establish_links(**key_args)


class SplitEdges(BaseNode):
    """
    Duplicate mesh edges and break connections with the surrounding faces

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    selection : InputBoolean
        Selection

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.selection : BooleanSocket
        Selection

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeSplitEdges"
    node: bpy.types.GeometryNodeSplitEdges

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        selection: BooleanSocket
        """Selection"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
    ):
        super().__init__()
        key_args = {"Mesh": mesh, "Selection": selection}

        self._establish_links(**key_args)


class SplitToInstances(BaseNode):
    """
    Create separate geometries containing the elements from the same group

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    selection : InputBoolean
        Selection
    group_id : InputInteger
        Group ID

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.selection : BooleanSocket
        Selection
    i.group_id : IntegerSocket
        Group ID

    Outputs
    -------
    o.instances : GeometrySocket
        Instances
    o.group_id : IntegerSocket
        Group ID
    """

    _bl_idname = "GeometryNodeSplitToInstances"
    node: bpy.types.GeometryNodeSplitToInstances

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        selection: BooleanSocket
        """Selection"""
        group_id: IntegerSocket
        """Group ID"""

    class _Outputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""
        group_id: IntegerSocket
        """Group ID"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
        *,
        domain: Literal[
            "POINT", "EDGE", "FACE", "CURVE", "INSTANCE", "LAYER"
        ] = "POINT",
    ):
        super().__init__()
        key_args = {"Geometry": geometry, "Selection": selection, "Group ID": group_id}
        self.domain = domain
        self._establish_links(**key_args)

    @classmethod
    def point(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
    ) -> "SplitToInstances":
        """Create Split to Instances with operation 'Point'. Attribute on point"""
        return cls(
            domain="POINT", geometry=geometry, selection=selection, group_id=group_id
        )

    @classmethod
    def edge(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
    ) -> "SplitToInstances":
        """Create Split to Instances with operation 'Edge'. Attribute on mesh edge"""
        return cls(
            domain="EDGE", geometry=geometry, selection=selection, group_id=group_id
        )

    @classmethod
    def face(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
    ) -> "SplitToInstances":
        """Create Split to Instances with operation 'Face'. Attribute on mesh faces"""
        return cls(
            domain="FACE", geometry=geometry, selection=selection, group_id=group_id
        )

    @classmethod
    def spline(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
    ) -> "SplitToInstances":
        """Create Split to Instances with operation 'Spline'. Attribute on spline"""
        return cls(
            domain="CURVE", geometry=geometry, selection=selection, group_id=group_id
        )

    @classmethod
    def instance(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
    ) -> "SplitToInstances":
        """Create Split to Instances with operation 'Instance'. Attribute on instance"""
        return cls(
            domain="INSTANCE", geometry=geometry, selection=selection, group_id=group_id
        )

    @classmethod
    def layer(
        cls,
        geometry: InputGeometry = None,
        selection: InputBoolean = True,
        group_id: InputInteger = 0,
    ) -> "SplitToInstances":
        """Create Split to Instances with operation 'Layer'. Attribute on Grease Pencil layer"""
        return cls(
            domain="LAYER", geometry=geometry, selection=selection, group_id=group_id
        )

    @property
    def domain(self) -> Literal["POINT", "EDGE", "FACE", "CURVE", "INSTANCE", "LAYER"]:
        return self.node.domain

    @domain.setter
    def domain(
        self, value: Literal["POINT", "EDGE", "FACE", "CURVE", "INSTANCE", "LAYER"]
    ):
        self.node.domain = value


class Star(BaseNode):
    """
    Generate a poly spline in a star pattern by connecting alternating points of two circles

    Parameters
    ----------
    points : InputInteger
        Points
    inner_radius : InputFloat
        Inner Radius
    outer_radius : InputFloat
        Outer Radius
    twist : InputFloat
        Twist

    Inputs
    ------
    i.points : IntegerSocket
        Points
    i.inner_radius : FloatSocket
        Inner Radius
    i.outer_radius : FloatSocket
        Outer Radius
    i.twist : FloatSocket
        Twist

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    o.outer_points : BooleanSocket
        Outer Points
    """

    _bl_idname = "GeometryNodeCurveStar"
    node: bpy.types.GeometryNodeCurveStar

    class _Inputs(SocketAccessor):
        points: IntegerSocket
        """Points"""
        inner_radius: FloatSocket
        """Inner Radius"""
        outer_radius: FloatSocket
        """Outer Radius"""
        twist: FloatSocket
        """Twist"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        outer_points: BooleanSocket
        """Outer Points"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        points: InputInteger = 8,
        inner_radius: InputFloat = 1.0,
        outer_radius: InputFloat = 2.0,
        twist: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {
            "Points": points,
            "Inner Radius": inner_radius,
            "Outer Radius": outer_radius,
            "Twist": twist,
        }

        self._establish_links(**key_args)


class StringToCurves(BaseNode):
    """
    Generate a paragraph of text with a specific font, using a curve instance to store each character

    Parameters
    ----------
    string : InputString
        String
    size : InputFloat
        Size
    font : InputFont
        Font
    align_x : InputMenu | Literal['Left', 'Center', 'Right', 'Justify', 'Flush']
        Align X
    align_y : InputMenu | Literal['Top', 'Top Baseline', 'Middle', 'Bottom Baseline', 'Bottom']
        Align Y
    pivot_point : InputMenu | Literal['Midpoint', 'Top Left', 'Top Center', 'Top Right', 'Bottom Left', 'Bottom Center', 'Bottom Right']
        Pivot Point
    character_spacing : InputFloat
        Character Spacing
    word_spacing : InputFloat
        Word Spacing
    line_spacing : InputFloat
        Line Spacing
    overflow : InputMenu | Literal['Overflow', 'Scale To Fit', 'Truncate']
        Overflow
    text_box_width : InputFloat
        Text Box Width
    text_box_height : InputFloat
        Text Box Height

    Inputs
    ------
    i.string : StringSocket
        String
    i.size : FloatSocket
        Size
    i.font : FontSocket
        Font
    i.align_x : MenuSocket
        Align X
    i.align_y : MenuSocket
        Align Y
    i.pivot_point : MenuSocket
        Pivot Point
    i.character_spacing : FloatSocket
        Character Spacing
    i.word_spacing : FloatSocket
        Word Spacing
    i.line_spacing : FloatSocket
        Line Spacing
    i.overflow : MenuSocket
        Overflow
    i.text_box_width : FloatSocket
        Text Box Width
    i.text_box_height : FloatSocket
        Text Box Height

    Outputs
    -------
    o.curve_instances : GeometrySocket
        Curve Instances
    o.remainder : StringSocket
        Remainder
    o.line : IntegerSocket
        Line
    o.word : IntegerSocket
        Word
    o.pivot_point : VectorSocket
        Pivot Point
    """

    _bl_idname = "GeometryNodeStringToCurves"
    node: bpy.types.GeometryNodeStringToCurves

    class _Inputs(SocketAccessor):
        string: StringSocket
        """String"""
        size: FloatSocket
        """Size"""
        font: FontSocket
        """Font"""
        align_x: MenuSocket
        """Align X"""
        align_y: MenuSocket
        """Align Y"""
        pivot_point: MenuSocket
        """Pivot Point"""
        character_spacing: FloatSocket
        """Character Spacing"""
        word_spacing: FloatSocket
        """Word Spacing"""
        line_spacing: FloatSocket
        """Line Spacing"""
        overflow: MenuSocket
        """Overflow"""
        text_box_width: FloatSocket
        """Text Box Width"""
        text_box_height: FloatSocket
        """Text Box Height"""

    class _Outputs(SocketAccessor):
        curve_instances: GeometrySocket
        """Curve Instances"""
        remainder: StringSocket
        """Remainder"""
        line: IntegerSocket
        """Line"""
        word: IntegerSocket
        """Word"""
        pivot_point: VectorSocket
        """Pivot Point"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        string: InputString = "",
        size: InputFloat = 1.0,
        font: InputFont = None,
        align_x: InputMenu
        | Literal["Left", "Center", "Right", "Justify", "Flush"] = "Left",
        align_y: InputMenu
        | Literal[
            "Top", "Top Baseline", "Middle", "Bottom Baseline", "Bottom"
        ] = "Top Baseline",
        pivot_point: InputMenu
        | Literal[
            "Midpoint",
            "Top Left",
            "Top Center",
            "Top Right",
            "Bottom Left",
            "Bottom Center",
            "Bottom Right",
        ] = "Midpoint",
        character_spacing: InputFloat = 1.0,
        word_spacing: InputFloat = 1.0,
        line_spacing: InputFloat = 1.0,
        overflow: InputMenu
        | Literal["Overflow", "Scale To Fit", "Truncate"] = "Overflow",
        text_box_width: InputFloat = 0.0,
        text_box_height: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {
            "String": string,
            "Size": size,
            "Font": font,
            "Align X": align_x,
            "Align Y": align_y,
            "Pivot Point": pivot_point,
            "Character Spacing": character_spacing,
            "Word Spacing": word_spacing,
            "Line Spacing": line_spacing,
            "Overflow": overflow,
            "Text Box Width": text_box_width,
            "Text Box Height": text_box_height,
        }

        self._establish_links(**key_args)


class SubdivideCurve(BaseNode):
    """
    Dividing each curve segment into a specified number of pieces

    Parameters
    ----------
    curve : InputGeometry
        Curve
    cuts : InputInteger
        Cuts

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.cuts : IntegerSocket
        Cuts

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeSubdivideCurve"
    node: bpy.types.GeometryNodeSubdivideCurve

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        cuts: IntegerSocket
        """Cuts"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        cuts: InputInteger = 1,
    ):
        super().__init__()
        key_args = {"Curve": curve, "Cuts": cuts}

        self._establish_links(**key_args)


class SubdivideMesh(BaseNode):
    """
    Divide mesh faces into smaller ones without changing the shape or volume, using linear interpolation to place the new vertices

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    level : InputInteger
        Level

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.level : IntegerSocket
        Level

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeSubdivideMesh"
    node: bpy.types.GeometryNodeSubdivideMesh

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        level: IntegerSocket
        """Level"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        level: InputInteger = 1,
    ):
        super().__init__()
        key_args = {"Mesh": mesh, "Level": level}

        self._establish_links(**key_args)


class SubdivisionSurface(BaseNode):
    """
    Divide mesh faces to form a smooth surface, using the Catmull-Clark subdivision method

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    level : InputInteger
        Level
    edge_crease : InputFloat
        Edge Crease
    vertex_crease : InputFloat
        Vertex Crease
    limit_surface : InputBoolean
        Limit Surface
    quality : InputInteger
        Quality
    uv_smooth : InputMenu | Literal['None', 'Keep Corners', 'Keep Corners, Junctions', 'Keep Corners, Junctions, Concave', 'Keep Boundaries', 'All']
        UV Smooth
    boundary_smooth : InputMenu | Literal['Keep Corners', 'All']
        Boundary Smooth

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.level : IntegerSocket
        Level
    i.edge_crease : FloatSocket
        Edge Crease
    i.vertex_crease : FloatSocket
        Vertex Crease
    i.limit_surface : BooleanSocket
        Limit Surface
    i.quality : IntegerSocket
        Quality
    i.uv_smooth : MenuSocket
        UV Smooth
    i.boundary_smooth : MenuSocket
        Boundary Smooth

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeSubdivisionSurface"
    node: bpy.types.GeometryNodeSubdivisionSurface

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        level: IntegerSocket
        """Level"""
        edge_crease: FloatSocket
        """Edge Crease"""
        vertex_crease: FloatSocket
        """Vertex Crease"""
        limit_surface: BooleanSocket
        """Limit Surface"""
        quality: IntegerSocket
        """Quality"""
        uv_smooth: MenuSocket
        """UV Smooth"""
        boundary_smooth: MenuSocket
        """Boundary Smooth"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        level: InputInteger = 1,
        edge_crease: InputFloat = 0.0,
        vertex_crease: InputFloat = 0.0,
        limit_surface: InputBoolean = True,
        quality: InputInteger = 3,
        uv_smooth: InputMenu
        | Literal[
            "None",
            "Keep Corners",
            "Keep Corners, Junctions",
            "Keep Corners, Junctions, Concave",
            "Keep Boundaries",
            "All",
        ] = "Keep Boundaries",
        boundary_smooth: InputMenu | Literal["Keep Corners", "All"] = "All",
    ):
        super().__init__()
        key_args = {
            "Mesh": mesh,
            "Level": level,
            "Edge Crease": edge_crease,
            "Vertex Crease": vertex_crease,
            "Limit Surface": limit_surface,
            "Quality": quality,
            "UV Smooth": uv_smooth,
            "Boundary Smooth": boundary_smooth,
        }

        self._establish_links(**key_args)


class TransferAttributes(BaseNode):
    """
    Copy attributes from one geometry to another

    Parameters
    ----------
    target : InputGeometry
        Target
    target_point_id : InputInteger
        Target Point ID
    target_edge_id : InputInteger
        Target Edge ID
    target_face_id : InputInteger
        Target Face ID
    target_corner_id : InputInteger
        Target Corner ID
    target_curve_id : InputInteger
        Target Curve ID
    target_instance_id : InputInteger
        Target Instance ID
    source : InputGeometry
        Source
    source_point_id : InputInteger
        Source Point ID
    source_edge_id : InputInteger
        Source Edge ID
    source_face_id : InputInteger
        Source Face ID
    source_corner_id : InputInteger
        Source Corner ID
    source_curve_id : InputInteger
        Source Curve ID
    source_instance_id : InputInteger
        Source Instance ID
    pattern_mode : InputMenu | Literal['Exact', 'Wildcard']
        Pattern Mode
    attribute_names : InputString
        Attribute Names
    exclude_names : InputBoolean
        Exclude Names

    Inputs
    ------
    i.target : GeometrySocket
        Target
    i.target_point_id : IntegerSocket
        Target Point ID
    i.target_edge_id : IntegerSocket
        Target Edge ID
    i.target_face_id : IntegerSocket
        Target Face ID
    i.target_corner_id : IntegerSocket
        Target Corner ID
    i.target_curve_id : IntegerSocket
        Target Curve ID
    i.target_instance_id : IntegerSocket
        Target Instance ID
    i.source : GeometrySocket
        Source
    i.source_point_id : IntegerSocket
        Source Point ID
    i.source_edge_id : IntegerSocket
        Source Edge ID
    i.source_face_id : IntegerSocket
        Source Face ID
    i.source_corner_id : IntegerSocket
        Source Corner ID
    i.source_curve_id : IntegerSocket
        Source Curve ID
    i.source_instance_id : IntegerSocket
        Source Instance ID
    i.pattern_mode : MenuSocket
        Pattern Mode
    i.attribute_names : StringSocket
        Attribute Names
    i.exclude_names : BooleanSocket
        Exclude Names

    Outputs
    -------
    o.target : GeometrySocket
        Target
    o.transferred_names : StringSocket
        Transferred Names
    """

    _bl_idname = "GeometryNodeTransferAttributes"
    node: bpy.types.GeometryNodeTransferAttributes  # ty: ignore[unresolved-attribute]

    class _Inputs(SocketAccessor):
        target: GeometrySocket
        """Target"""
        target_point_id: IntegerSocket
        """Target Point ID"""
        target_edge_id: IntegerSocket
        """Target Edge ID"""
        target_face_id: IntegerSocket
        """Target Face ID"""
        target_corner_id: IntegerSocket
        """Target Corner ID"""
        target_curve_id: IntegerSocket
        """Target Curve ID"""
        target_instance_id: IntegerSocket
        """Target Instance ID"""
        source: GeometrySocket
        """Source"""
        source_point_id: IntegerSocket
        """Source Point ID"""
        source_edge_id: IntegerSocket
        """Source Edge ID"""
        source_face_id: IntegerSocket
        """Source Face ID"""
        source_corner_id: IntegerSocket
        """Source Corner ID"""
        source_curve_id: IntegerSocket
        """Source Curve ID"""
        source_instance_id: IntegerSocket
        """Source Instance ID"""
        pattern_mode: MenuSocket
        """Pattern Mode"""
        attribute_names: StringSocket
        """Attribute Names"""
        exclude_names: BooleanSocket
        """Exclude Names"""

    class _Outputs(SocketAccessor):
        target: GeometrySocket
        """Target"""
        transferred_names: StringSocketList
        """Transferred Names"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        target: InputGeometry = None,
        target_point_id: InputInteger = 0,
        target_edge_id: InputInteger = 0,
        target_face_id: InputInteger = 0,
        target_corner_id: InputInteger = 0,
        target_curve_id: InputInteger = 0,
        target_instance_id: InputInteger = 0,
        source: InputGeometry = None,
        source_point_id: InputInteger = 0,
        source_edge_id: InputInteger = 0,
        source_face_id: InputInteger = 0,
        source_corner_id: InputInteger = 0,
        source_curve_id: InputInteger = 0,
        source_instance_id: InputInteger = 0,
        pattern_mode: InputMenu | Literal["Exact", "Wildcard"] = "Wildcard",
        attribute_names: InputString = "",
        exclude_names: InputBoolean = False,
    ):
        super().__init__()
        key_args = {
            "Target": target,
            "Target Point ID": target_point_id,
            "Target Edge ID": target_edge_id,
            "Target Face ID": target_face_id,
            "Target Corner ID": target_corner_id,
            "Target Curve ID": target_curve_id,
            "Target Instance ID": target_instance_id,
            "Source": source,
            "Source Point ID": source_point_id,
            "Source Edge ID": source_edge_id,
            "Source Face ID": source_face_id,
            "Source Corner ID": source_corner_id,
            "Source Curve ID": source_curve_id,
            "Source Instance ID": source_instance_id,
            "Pattern Mode": pattern_mode,
            "Attribute Names": attribute_names,
            "Exclude Names": exclude_names,
        }

        self._establish_links(**key_args)


class TransformGeometry(BaseNode):
    """
    Translate, rotate or scale the geometry

    Parameters
    ----------
    geometry : InputGeometry
        Geometry
    mode : InputMenu | Literal['Components', 'Matrix']
        Mode
    translation : InputVector
        Translation
    rotation : InputRotation
        Rotation
    scale : InputVector
        Scale
    transform : InputMatrix
        Transform

    Inputs
    ------
    i.geometry : GeometrySocket
        Geometry
    i.mode : MenuSocket
        Mode
    i.translation : VectorSocket
        Translation
    i.rotation : RotationSocket
        Rotation
    i.scale : VectorSocket
        Scale
    i.transform : MatrixSocket
        Transform

    Outputs
    -------
    o.geometry : GeometrySocket
        Geometry
    """

    _bl_idname = "GeometryNodeTransform"
    node: bpy.types.GeometryNodeTransform

    class _Inputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""
        mode: MenuSocket
        """Mode"""
        translation: VectorSocket
        """Translation"""
        rotation: RotationSocket
        """Rotation"""
        scale: VectorSocket
        """Scale"""
        transform: MatrixSocket
        """Transform"""

    class _Outputs(SocketAccessor):
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        geometry: InputGeometry = None,
        mode: InputMenu | Literal["Components", "Matrix"] = "Components",
        translation: InputVector = None,
        rotation: InputRotation = None,
        scale: InputVector = None,
        transform: InputMatrix = None,
    ):
        super().__init__()
        key_args = {
            "Geometry": geometry,
            "Mode": mode,
            "Translation": translation,
            "Rotation": rotation,
            "Scale": scale,
            "Transform": transform,
        }

        self._establish_links(**key_args)


class TranslateInstances(BaseNode):
    """
    Move top-level geometry instances in local or global space

    Parameters
    ----------
    instances : InputGeometry
        Instances
    selection : InputBoolean
        Selection
    translation : InputVector
        Translation
    local_space : InputBoolean
        Local Space

    Inputs
    ------
    i.instances : GeometrySocket
        Instances
    i.selection : BooleanSocket
        Selection
    i.translation : VectorSocket
        Translation
    i.local_space : BooleanSocket
        Local Space

    Outputs
    -------
    o.instances : GeometrySocket
        Instances
    """

    _bl_idname = "GeometryNodeTranslateInstances"
    node: bpy.types.GeometryNodeTranslateInstances

    class _Inputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""
        selection: BooleanSocket
        """Selection"""
        translation: VectorSocket
        """Translation"""
        local_space: BooleanSocket
        """Local Space"""

    class _Outputs(SocketAccessor):
        instances: GeometrySocket
        """Instances"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        instances: InputGeometry = None,
        selection: InputBoolean = True,
        translation: InputVector = None,
        local_space: InputBoolean = True,
    ):
        super().__init__()
        key_args = {
            "Instances": instances,
            "Selection": selection,
            "Translation": translation,
            "Local Space": local_space,
        }

        self._establish_links(**key_args)


class Triangulate(BaseNode):
    """
    Convert all faces in a mesh to triangular faces

    Parameters
    ----------
    mesh : InputGeometry
        Mesh
    selection : InputBoolean
        Selection
    quad_method : InputMenu | Literal['Beauty', 'Fixed', 'Fixed Alternate', 'Shortest Diagonal', 'Longest Diagonal']
        Quad Method
    n_gon_method : InputMenu | Literal['Beauty', 'Clip']
        N-gon Method

    Inputs
    ------
    i.mesh : GeometrySocket
        Mesh
    i.selection : BooleanSocket
        Selection
    i.quad_method : MenuSocket
        Quad Method
    i.n_gon_method : MenuSocket
        N-gon Method

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    """

    _bl_idname = "GeometryNodeTriangulate"
    node: bpy.types.GeometryNodeTriangulate

    class _Inputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        selection: BooleanSocket
        """Selection"""
        quad_method: MenuSocket
        """Quad Method"""
        n_gon_method: MenuSocket
        """N-gon Method"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        mesh: InputGeometry = None,
        selection: InputBoolean = True,
        quad_method: InputMenu
        | Literal[
            "Beauty",
            "Fixed",
            "Fixed Alternate",
            "Shortest Diagonal",
            "Longest Diagonal",
        ] = "Shortest Diagonal",
        n_gon_method: InputMenu | Literal["Beauty", "Clip"] = "Beauty",
    ):
        super().__init__()
        key_args = {
            "Mesh": mesh,
            "Selection": selection,
            "Quad Method": quad_method,
            "N-gon Method": n_gon_method,
        }

        self._establish_links(**key_args)


class TrimCurve(BaseNode):
    """
    Shorten curves by removing portions at the start or end

    Parameters
    ----------
    curve : InputGeometry
        Curve
    selection : InputBoolean
        Selection
    start : InputFloat
        Start
    end : InputFloat
        End
    start_001 : InputFloat
        Start
    end_001 : InputFloat
        End

    Inputs
    ------
    i.curve : GeometrySocket
        Curve
    i.selection : BooleanSocket
        Selection
    i.start : FloatSocket
        Start
    i.end : FloatSocket
        End
    i.start_001 : FloatSocket
        Start
    i.end_001 : FloatSocket
        End

    Outputs
    -------
    o.curve : GeometrySocket
        Curve
    """

    _bl_idname = "GeometryNodeTrimCurve"
    node: bpy.types.GeometryNodeTrimCurve

    class _Inputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""
        selection: BooleanSocket
        """Selection"""
        start: FloatSocket
        """Start"""
        end: FloatSocket
        """End"""
        start_001: FloatSocket
        """Start"""
        end_001: FloatSocket
        """End"""

    class _Outputs(SocketAccessor):
        curve: GeometrySocket
        """Curve"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        start: InputFloat = 0.0,
        end: InputFloat = 1.0,
        start_001: InputFloat = 0.0,
        end_001: InputFloat = 1.0,
        *,
        mode: Literal["FACTOR", "LENGTH"] = "FACTOR",
    ):
        super().__init__()
        key_args = {
            "Curve": curve,
            "Selection": selection,
            "Start": start,
            "End": end,
            "Start_001": start_001,
            "End_001": end_001,
        }
        self.mode = mode
        self._establish_links(**key_args)

    @classmethod
    def factor(
        cls,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        start: InputFloat = 0.0,
        end: InputFloat = 1.0,
    ) -> "TrimCurve":
        """Create Trim Curve with operation 'Factor'. Find the endpoint positions using a factor of each spline's length"""
        return cls(
            mode="FACTOR", curve=curve, selection=selection, start=start, end=end
        )

    @classmethod
    def length(
        cls,
        curve: InputGeometry = None,
        selection: InputBoolean = True,
        start_001: InputFloat = 0.0,
        end_001: InputFloat = 1.0,
    ) -> "TrimCurve":
        """Create Trim Curve with operation 'Length'. Find the endpoint positions using a length from the start of each spline"""
        return cls(
            mode="LENGTH",
            curve=curve,
            selection=selection,
            start_001=start_001,
            end_001=end_001,
        )

    @property
    def mode(self) -> Literal["FACTOR", "LENGTH"]:
        return self.node.mode

    @mode.setter
    def mode(self, value: Literal["FACTOR", "LENGTH"]):
        self.node.mode = value


class UVSphere(BaseNode):
    """
    Generate a spherical mesh with quads, except for triangles at the top and bottom

    Parameters
    ----------
    segments : InputInteger
        Segments
    rings : InputInteger
        Rings
    radius : InputFloat
        Radius

    Inputs
    ------
    i.segments : IntegerSocket
        Segments
    i.rings : IntegerSocket
        Rings
    i.radius : FloatSocket
        Radius

    Outputs
    -------
    o.mesh : GeometrySocket
        Mesh
    o.uv_map : VectorSocket
        UV Map
    """

    _bl_idname = "GeometryNodeMeshUVSphere"
    node: bpy.types.GeometryNodeMeshUVSphere

    class _Inputs(SocketAccessor):
        segments: IntegerSocket
        """Segments"""
        rings: IntegerSocket
        """Rings"""
        radius: FloatSocket
        """Radius"""

    class _Outputs(SocketAccessor):
        mesh: GeometrySocket
        """Mesh"""
        uv_map: VectorSocket
        """UV Map"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        segments: InputInteger = 32,
        rings: InputInteger = 16,
        radius: InputFloat = 1.0,
    ):
        super().__init__()
        key_args = {"Segments": segments, "Rings": rings, "Radius": radius}

        self._establish_links(**key_args)


class XpbdSolver(BaseNode):
    """
    Simulate physics using the XPBD framework

    Parameters
    ----------
    world : InputBundle
        World
    delta_time : InputFloat
        Delta Time
    filter : InputString
        Filter
    simulation_to_world : InputMatrix
        Simulation to World
    substeps : InputInteger
        Substeps
    constraint_iterations : InputInteger
        Constraint Iterations
    solver_path : InputString
        Solver Path
    begin : InputFloat
        Begin
    end : InputFloat
        End

    Inputs
    ------
    i.world : BundleSocket
        World
    i.delta_time : FloatSocket
        Delta Time
    i.filter : StringSocket
        Filter
    i.simulation_to_world : MatrixSocket
        Simulation to World
    i.substeps : IntegerSocket
        Substeps
    i.constraint_iterations : IntegerSocket
        Constraint Iterations
    i.solver_path : StringSocket
        Solver Path
    i.begin : FloatSocket
        Begin
    i.end : FloatSocket
        End

    Outputs
    -------
    o.world : BundleSocket
        World
    """

    _bl_idname = "GeometryNodeXPBDSolver"
    node: bpy.types.GeometryNodeXPBDSolver  # ty: ignore[unresolved-attribute]

    class _Inputs(SocketAccessor):
        world: BundleSocket
        """World"""
        delta_time: FloatSocket
        """Delta Time"""
        filter: StringSocket
        """Filter"""
        simulation_to_world: MatrixSocket
        """Simulation to World"""
        substeps: IntegerSocket
        """Substeps"""
        constraint_iterations: IntegerSocket
        """Constraint Iterations"""
        solver_path: StringSocket
        """Solver Path"""
        begin: FloatSocket
        """Begin"""
        end: FloatSocket
        """End"""

    class _Outputs(SocketAccessor):
        world: BundleSocket
        """World"""

    if TYPE_CHECKING:

        @property
        def i(self) -> _Inputs: ...
        @property
        def o(self) -> _Outputs: ...

    def __init__(
        self,
        world: InputBundle = None,
        delta_time: InputFloat = 0.04,
        filter: InputString = "",
        simulation_to_world: InputMatrix = None,
        substeps: InputInteger = 10,
        constraint_iterations: InputInteger = 1,
        solver_path: InputString = "",
        begin: InputFloat = 0.0,
        end: InputFloat = 1.0,
    ):
        super().__init__()
        key_args = {
            "World": world,
            "Delta Time": delta_time,
            "Filter": filter,
            "Simulation to World": simulation_to_world,
            "Substeps": substeps,
            "Constraint Iterations": constraint_iterations,
            "Solver Path": solver_path,
            "Begin": begin,
            "End": end,
        }

        self._establish_links(**key_args)
