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

from typing import TYPE_CHECKING, Generic, Literal

import bpy

from mathutils import Euler, Vector

from ...builder import BaseNode, SocketAccessor

from ...types import (
    InputBoolean,
    InputCollection,
    InputFloat,
    InputImage,
    InputInteger,
    InputMenu,
    InputObject,
    InputString,
    InputVector,
)

from ...builder.socket import (
    BooleanSocket,
    CollectionSocket,
    ColorSocket,
    FloatSocket,
    FontSocket,
    GeometrySocket,
    ImageSocket,
    IntegerSocket,
    MatrixSocket,
    MenuSocket,
    ObjectSocket,
    RotationSocket,
    StringSocket,
    VectorSocket,
    CollectionSocketList,
    ObjectSocketList,
    _T,
    _S,
)

from .._mixins import _HandleModeMixin


class Cursor3D(BaseNode):
    """
    The scene's 3D cursor location and rotation

    Outputs
    -------
    o.location : VectorSocket
        Location
    o.rotation : RotationSocket
        Rotation
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        location: VectorSocket
        """Location"""
        rotation: RotationSocket
        """Rotation"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class ActiveCamera(BaseNode):
    """
    Retrieve the scene's active camera

    Outputs
    -------
    o.active_camera : ObjectSocket
        Active Camera
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        active_camera: ObjectSocket
        """Active Camera"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class ActiveElement(BaseNode):
    """
    Active element indices of the edited geometry, for tool execution

    Outputs
    -------
    o.index : IntegerSocket
        Index
    o.exists : BooleanSocket
        Exists
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        index: IntegerSocket
        """Index"""
        exists: BooleanSocket
        """Exists"""

    if TYPE_CHECKING:

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

    def __init__(self, domain: Literal["POINT", "EDGE", "FACE", "LAYER"] = "POINT"):
        super().__init__()
        key_args = {}
        self.domain = domain
        self._establish_links(**key_args)

    @classmethod
    def point(cls) -> "ActiveElement":
        """Create Active Element with operation 'Point'."""
        return cls(domain="POINT")

    @classmethod
    def edge(cls) -> "ActiveElement":
        """Create Active Element with operation 'Edge'."""
        return cls(domain="EDGE")

    @classmethod
    def face(cls) -> "ActiveElement":
        """Create Active Element with operation 'Face'."""
        return cls(domain="FACE")

    @classmethod
    def layer(cls) -> "ActiveElement":
        """Create Active Element with operation 'Layer'."""
        return cls(domain="LAYER")

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

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


class BoneInfo(BaseNode):
    """
    Retrieve information of armature bones

    Parameters
    ----------
    armature : InputObject
        Armature
    bone_name : InputString
        Bone Name

    Inputs
    ------
    i.armature : ObjectSocket
        Armature
    i.bone_name : StringSocket
        Bone Name

    Outputs
    -------
    o.pose : MatrixSocket
        Pose
    o.local_pose : MatrixSocket
        Local Pose
    o.transform_pose : MatrixSocket
        Transform Pose
    o.rest_pose : MatrixSocket
        Rest Pose
    o.rest_length : FloatSocket
        Rest Length
    o.exists : BooleanSocket
        Exists
    """

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

    class _Inputs(SocketAccessor):
        armature: ObjectSocket
        """Armature"""
        bone_name: StringSocket
        """Bone Name"""

    class _Outputs(SocketAccessor):
        pose: MatrixSocket
        """Pose"""
        local_pose: MatrixSocket
        """Local Pose"""
        transform_pose: MatrixSocket
        """Transform Pose"""
        rest_pose: MatrixSocket
        """Rest Pose"""
        rest_length: FloatSocket
        """Rest Length"""
        exists: BooleanSocket
        """Exists"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        armature: InputObject = None,
        bone_name: InputString = "",
        *,
        transform_space: Literal["ORIGINAL", "RELATIVE"] = "ORIGINAL",
    ):
        super().__init__()
        key_args = {"Armature": armature, "Bone Name": bone_name}
        self.transform_space = transform_space
        self._establish_links(**key_args)

    @property
    def transform_space(self) -> Literal["ORIGINAL", "RELATIVE"]:
        return self.node.transform_space

    @transform_space.setter
    def transform_space(self, value: Literal["ORIGINAL", "RELATIVE"]):
        self.node.transform_space = value


class Boolean(BaseNode):
    """
    Provide a True/False value that can be connected to other nodes in the tree

    Outputs
    -------
    o.boolean : BooleanSocket
        Boolean
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        boolean: BooleanSocket
        """Boolean"""

    if TYPE_CHECKING:

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

    def __init__(self, boolean: bool = False):
        super().__init__()
        key_args = {}
        self.boolean = boolean
        self._establish_links(**key_args)

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

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


class CameraInfo(BaseNode):
    """
    Retrieve information from a camera object

    Parameters
    ----------
    camera : InputObject
        Camera

    Inputs
    ------
    i.camera : ObjectSocket
        Camera

    Outputs
    -------
    o.projection_matrix : MatrixSocket
        Projection Matrix
    o.focal_length : FloatSocket
        Focal Length
    o.sensor : VectorSocket
        Sensor
    o.shift : VectorSocket
        Shift
    o.clip_start : FloatSocket
        Clip Start
    o.clip_end : FloatSocket
        Clip End
    o.focus_distance : FloatSocket
        Focus Distance
    o.is_orthographic : BooleanSocket
        Is Orthographic
    o.orthographic_scale : FloatSocket
        Orthographic Scale
    """

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

    class _Inputs(SocketAccessor):
        camera: ObjectSocket
        """Camera"""

    class _Outputs(SocketAccessor):
        projection_matrix: MatrixSocket
        """Projection Matrix"""
        focal_length: FloatSocket
        """Focal Length"""
        sensor: VectorSocket
        """Sensor"""
        shift: VectorSocket
        """Shift"""
        clip_start: FloatSocket
        """Clip Start"""
        clip_end: FloatSocket
        """Clip End"""
        focus_distance: FloatSocket
        """Focus Distance"""
        is_orthographic: BooleanSocket
        """Is Orthographic"""
        orthographic_scale: FloatSocket
        """Orthographic Scale"""

    if TYPE_CHECKING:

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

    def __init__(self, camera: InputObject = None):
        super().__init__()
        key_args = {"Camera": camera}

        self._establish_links(**key_args)


class CollectionChildren(BaseNode):
    """
    Retrieve a collection's object and collection children, in a name-based order

    Parameters
    ----------
    collection : InputCollection
        Collection
    recursive : InputBoolean
        Recursive

    Inputs
    ------
    i.collection : CollectionSocket
        Collection
    i.recursive : BooleanSocket
        Recursive

    Outputs
    -------
    o.collections : CollectionSocket
        Collections
    o.objects : ObjectSocket
        Objects
    """

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

    class _Inputs(SocketAccessor):
        collection: CollectionSocket
        """Collection"""
        recursive: BooleanSocket
        """Recursive"""

    class _Outputs(SocketAccessor):
        collections: CollectionSocketList
        """Collections"""
        objects: ObjectSocketList
        """Objects"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        collection: InputCollection = None,
        recursive: InputBoolean = False,
    ):
        super().__init__()
        key_args = {"Collection": collection, "Recursive": recursive}

        self._establish_links(**key_args)


class CollectionInfo(BaseNode):
    """
    Retrieve geometry instances from a collection

    Parameters
    ----------
    collection : InputCollection
        Collection
    separate_children : InputBoolean
        Separate Children
    reset_children : InputBoolean
        Reset Children

    Inputs
    ------
    i.collection : CollectionSocket
        Collection
    i.separate_children : BooleanSocket
        Separate Children
    i.reset_children : BooleanSocket
        Reset Children

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

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

    class _Inputs(SocketAccessor):
        collection: CollectionSocket
        """Collection"""
        separate_children: BooleanSocket
        """Separate Children"""
        reset_children: BooleanSocket
        """Reset Children"""

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

    if TYPE_CHECKING:

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

    def __init__(
        self,
        collection: InputCollection = None,
        separate_children: InputBoolean = False,
        reset_children: InputBoolean = False,
        *,
        transform_space: Literal["ORIGINAL", "RELATIVE"] = "ORIGINAL",
    ):
        super().__init__()
        key_args = {
            "Collection": collection,
            "Separate Children": separate_children,
            "Reset Children": reset_children,
        }
        self.transform_space = transform_space
        self._establish_links(**key_args)

    @property
    def transform_space(self) -> Literal["ORIGINAL", "RELATIVE"]:
        return self.node.transform_space

    @transform_space.setter
    def transform_space(self, value: Literal["ORIGINAL", "RELATIVE"]):
        self.node.transform_space = value


class Color(BaseNode):
    """
    Output a color value chosen with the color picker widget

    Outputs
    -------
    o.color : ColorSocket
        Color
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""

    if TYPE_CHECKING:

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

    def __init__(
        self, value: tuple[float, float, float, float] = (0.735, 0.735, 0.735, 1.0)
    ):
        super().__init__()
        key_args = {}
        self.value = value
        self._establish_links(**key_args)

    @property
    def value(self) -> tuple[float, float, float, float]:
        return self.node.value

    @value.setter
    def value(self, value: tuple[float, float, float, float]):
        self.node.value = value


class CornersOfEdge(BaseNode):
    """
    Retrieve face corners connected to edges

    Parameters
    ----------
    edge_index : InputInteger
        Edge Index
    weights : InputFloat
        Weights
    sort_index : InputInteger
        Sort Index

    Inputs
    ------
    i.edge_index : IntegerSocket
        Edge Index
    i.weights : FloatSocket
        Weights
    i.sort_index : IntegerSocket
        Sort Index

    Outputs
    -------
    o.corner_index : IntegerSocket
        Corner Index
    o.total : IntegerSocket
        Total
    """

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

    class _Inputs(SocketAccessor):
        edge_index: IntegerSocket
        """Edge Index"""
        weights: FloatSocket
        """Weights"""
        sort_index: IntegerSocket
        """Sort Index"""

    class _Outputs(SocketAccessor):
        corner_index: IntegerSocket
        """Corner Index"""
        total: IntegerSocket
        """Total"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        edge_index: InputInteger = 0,
        weights: InputFloat = 0.0,
        sort_index: InputInteger = 0,
    ):
        super().__init__()
        key_args = {
            "Edge Index": edge_index,
            "Weights": weights,
            "Sort Index": sort_index,
        }

        self._establish_links(**key_args)


class CornersOfFace(BaseNode):
    """
    Retrieve corners that make up a face

    Parameters
    ----------
    face_index : InputInteger
        Face Index
    weights : InputFloat
        Weights
    sort_index : InputInteger
        Sort Index

    Inputs
    ------
    i.face_index : IntegerSocket
        Face Index
    i.weights : FloatSocket
        Weights
    i.sort_index : IntegerSocket
        Sort Index

    Outputs
    -------
    o.corner_index : IntegerSocket
        Corner Index
    o.total : IntegerSocket
        Total
    """

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

    class _Inputs(SocketAccessor):
        face_index: IntegerSocket
        """Face Index"""
        weights: FloatSocket
        """Weights"""
        sort_index: IntegerSocket
        """Sort Index"""

    class _Outputs(SocketAccessor):
        corner_index: IntegerSocket
        """Corner Index"""
        total: IntegerSocket
        """Total"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        face_index: InputInteger = 0,
        weights: InputFloat = 0.0,
        sort_index: InputInteger = 0,
    ):
        super().__init__()
        key_args = {
            "Face Index": face_index,
            "Weights": weights,
            "Sort Index": sort_index,
        }

        self._establish_links(**key_args)


class CornersOfVertex(BaseNode):
    """
    Retrieve face corners connected to vertices

    Parameters
    ----------
    vertex_index : InputInteger
        Vertex Index
    weights : InputFloat
        Weights
    sort_index : InputInteger
        Sort Index

    Inputs
    ------
    i.vertex_index : IntegerSocket
        Vertex Index
    i.weights : FloatSocket
        Weights
    i.sort_index : IntegerSocket
        Sort Index

    Outputs
    -------
    o.corner_index : IntegerSocket
        Corner Index
    o.total : IntegerSocket
        Total
    """

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

    class _Inputs(SocketAccessor):
        vertex_index: IntegerSocket
        """Vertex Index"""
        weights: FloatSocket
        """Weights"""
        sort_index: IntegerSocket
        """Sort Index"""

    class _Outputs(SocketAccessor):
        corner_index: IntegerSocket
        """Corner Index"""
        total: IntegerSocket
        """Total"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vertex_index: InputInteger = 0,
        weights: InputFloat = 0.0,
        sort_index: InputInteger = 0,
    ):
        super().__init__()
        key_args = {
            "Vertex Index": vertex_index,
            "Weights": weights,
            "Sort Index": sort_index,
        }

        self._establish_links(**key_args)


class CurveHandlePositions(BaseNode):
    """
    Retrieve the position of each Bézier control point's handles

    Parameters
    ----------
    relative : InputBoolean
        Relative

    Inputs
    ------
    i.relative : BooleanSocket
        Relative

    Outputs
    -------
    o.left : VectorSocket
        Left
    o.right : VectorSocket
        Right
    """

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

    class _Inputs(SocketAccessor):
        relative: BooleanSocket
        """Relative"""

    class _Outputs(SocketAccessor):
        left: VectorSocket
        """Left"""
        right: VectorSocket
        """Right"""

    if TYPE_CHECKING:

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

    def __init__(self, relative: InputBoolean = False):
        super().__init__()
        key_args = {"Relative": relative}

        self._establish_links(**key_args)


class CurveTangent(BaseNode):
    """
    Retrieve the direction of curves at each control point

    Outputs
    -------
    o.tangent : VectorSocket
        Tangent
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        tangent: VectorSocket
        """Tangent"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class CurveTilt(BaseNode):
    """
    Retrieve the angle at each control point used to twist the curve's normal around its tangent

    Outputs
    -------
    o.tilt : FloatSocket
        Tilt
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        tilt: FloatSocket
        """Tilt"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class CurveOfPoint(BaseNode):
    """
    Retrieve the curve a control point is part of

    Parameters
    ----------
    point_index : InputInteger
        Point Index

    Inputs
    ------
    i.point_index : IntegerSocket
        Point Index

    Outputs
    -------
    o.curve_index : IntegerSocket
        Curve Index
    o.index_in_curve : IntegerSocket
        Index in Curve
    """

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

    class _Inputs(SocketAccessor):
        point_index: IntegerSocket
        """Point Index"""

    class _Outputs(SocketAccessor):
        curve_index: IntegerSocket
        """Curve Index"""
        index_in_curve: IntegerSocket
        """Index in Curve"""

    if TYPE_CHECKING:

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

    def __init__(self, point_index: InputInteger = 0):
        super().__init__()
        key_args = {"Point Index": point_index}

        self._establish_links(**key_args)


class EdgeAngle(BaseNode):
    """
    The angle between the normals of connected manifold faces

    Outputs
    -------
    o.unsigned_angle : FloatSocket
        Unsigned Angle
    o.signed_angle : FloatSocket
        Signed Angle
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        unsigned_angle: FloatSocket
        """Unsigned Angle"""
        signed_angle: FloatSocket
        """Signed Angle"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class EdgeNeighbors(BaseNode):
    """
    Retrieve the number of faces that use each edge as one of their sides

    Outputs
    -------
    o.face_count : IntegerSocket
        Face Count
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        face_count: IntegerSocket
        """Face Count"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class EdgePathsToSelection(BaseNode):
    """
    Output a selection of edges by following paths across mesh edges

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

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

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

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

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

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

    if TYPE_CHECKING:

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

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

        self._establish_links(**key_args)


class EdgeVertices(BaseNode):
    """
    Retrieve topology information relating to each edge of a mesh

    Outputs
    -------
    o.vertex_index_1 : IntegerSocket
        Vertex Index 1
    o.vertex_index_2 : IntegerSocket
        Vertex Index 2
    o.position_1 : VectorSocket
        Position 1
    o.position_2 : VectorSocket
        Position 2
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        vertex_index_1: IntegerSocket
        """Vertex Index 1"""
        vertex_index_2: IntegerSocket
        """Vertex Index 2"""
        position_1: VectorSocket
        """Position 1"""
        position_2: VectorSocket
        """Position 2"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class EdgesOfCorner(BaseNode):
    """
    Retrieve the edges on both sides of a face corner

    Parameters
    ----------
    corner_index : InputInteger
        Corner Index

    Inputs
    ------
    i.corner_index : IntegerSocket
        Corner Index

    Outputs
    -------
    o.next_edge_index : IntegerSocket
        Next Edge Index
    o.previous_edge_index : IntegerSocket
        Previous Edge Index
    """

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

    class _Inputs(SocketAccessor):
        corner_index: IntegerSocket
        """Corner Index"""

    class _Outputs(SocketAccessor):
        next_edge_index: IntegerSocket
        """Next Edge Index"""
        previous_edge_index: IntegerSocket
        """Previous Edge Index"""

    if TYPE_CHECKING:

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

    def __init__(self, corner_index: InputInteger = 0):
        super().__init__()
        key_args = {"Corner Index": corner_index}

        self._establish_links(**key_args)


class EdgesOfVertex(BaseNode):
    """
    Retrieve the edges connected to each vertex

    Parameters
    ----------
    vertex_index : InputInteger
        Vertex Index
    weights : InputFloat
        Weights
    sort_index : InputInteger
        Sort Index

    Inputs
    ------
    i.vertex_index : IntegerSocket
        Vertex Index
    i.weights : FloatSocket
        Weights
    i.sort_index : IntegerSocket
        Sort Index

    Outputs
    -------
    o.edge_index : IntegerSocket
        Edge Index
    o.total : IntegerSocket
        Total
    """

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

    class _Inputs(SocketAccessor):
        vertex_index: IntegerSocket
        """Vertex Index"""
        weights: FloatSocket
        """Weights"""
        sort_index: IntegerSocket
        """Sort Index"""

    class _Outputs(SocketAccessor):
        edge_index: IntegerSocket
        """Edge Index"""
        total: IntegerSocket
        """Total"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vertex_index: InputInteger = 0,
        weights: InputFloat = 0.0,
        sort_index: InputInteger = 0,
    ):
        super().__init__()
        key_args = {
            "Vertex Index": vertex_index,
            "Weights": weights,
            "Sort Index": sort_index,
        }

        self._establish_links(**key_args)


class EdgesToFaceGroups(BaseNode):
    """
    Group faces into regions surrounded by the selected boundary edges

    Parameters
    ----------
    boundary_edges : InputBoolean
        Boundary Edges

    Inputs
    ------
    i.boundary_edges : BooleanSocket
        Boundary Edges

    Outputs
    -------
    o.face_group_id : IntegerSocket
        Face Group ID
    """

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

    class _Inputs(SocketAccessor):
        boundary_edges: BooleanSocket
        """Boundary Edges"""

    class _Outputs(SocketAccessor):
        face_group_id: IntegerSocket
        """Face Group ID"""

    if TYPE_CHECKING:

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

    def __init__(self, boundary_edges: InputBoolean = True):
        super().__init__()
        key_args = {"Boundary Edges": boundary_edges}

        self._establish_links(**key_args)


class EndpointSelection(BaseNode):
    """
    Provide a selection for an arbitrary number of endpoints in each spline

    Parameters
    ----------
    start_size : InputInteger
        Start Size
    end_size : InputInteger
        End Size

    Inputs
    ------
    i.start_size : IntegerSocket
        Start Size
    i.end_size : IntegerSocket
        End Size

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

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

    class _Inputs(SocketAccessor):
        start_size: IntegerSocket
        """Start Size"""
        end_size: IntegerSocket
        """End Size"""

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

    if TYPE_CHECKING:

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

    def __init__(
        self,
        start_size: InputInteger = 1,
        end_size: InputInteger = 1,
    ):
        super().__init__()
        key_args = {"Start Size": start_size, "End Size": end_size}

        self._establish_links(**key_args)


class FaceArea(BaseNode):
    """
    Calculate the surface area of a mesh's faces

    Outputs
    -------
    o.area : FloatSocket
        Area
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        area: FloatSocket
        """Area"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class FaceGroupBoundaries(BaseNode):
    """
    Find edges on the boundaries between groups of faces with the same ID value

    Parameters
    ----------
    face_set : InputInteger
        Face Group ID

    Inputs
    ------
    i.face_set : IntegerSocket
        Face Group ID

    Outputs
    -------
    o.boundary_edges : BooleanSocket
        Boundary Edges
    """

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

    class _Inputs(SocketAccessor):
        face_set: IntegerSocket
        """Face Group ID"""

    class _Outputs(SocketAccessor):
        boundary_edges: BooleanSocket
        """Boundary Edges"""

    if TYPE_CHECKING:

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

    def __init__(self, face_set: InputInteger = 0):
        super().__init__()
        key_args = {"Face Set": face_set}

        self._establish_links(**key_args)


class FaceNeighbors(BaseNode):
    """
    Retrieve topology information relating to each face of a mesh

    Outputs
    -------
    o.vertex_count : IntegerSocket
        Vertex Count
    o.face_count : IntegerSocket
        Face Count
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        vertex_count: IntegerSocket
        """Vertex Count"""
        face_count: IntegerSocket
        """Face Count"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class FaceSet(BaseNode):
    """
    Each face's sculpt face set value

    Outputs
    -------
    o.face_set : IntegerSocket
        Face Set
    o.exists : BooleanSocket
        Exists
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        face_set: IntegerSocket
        """Face Set"""
        exists: BooleanSocket
        """Exists"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class FaceOfCorner(BaseNode):
    """
    Retrieve the face each face corner is part of

    Parameters
    ----------
    corner_index : InputInteger
        Corner Index

    Inputs
    ------
    i.corner_index : IntegerSocket
        Corner Index

    Outputs
    -------
    o.face_index : IntegerSocket
        Face Index
    o.index_in_face : IntegerSocket
        Index in Face
    """

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

    class _Inputs(SocketAccessor):
        corner_index: IntegerSocket
        """Corner Index"""

    class _Outputs(SocketAccessor):
        face_index: IntegerSocket
        """Face Index"""
        index_in_face: IntegerSocket
        """Index in Face"""

    if TYPE_CHECKING:

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

    def __init__(self, corner_index: InputInteger = 0):
        super().__init__()
        key_args = {"Corner Index": corner_index}

        self._establish_links(**key_args)


class Font(BaseNode):
    """
    Output a font

    Outputs
    -------
    o.font : FontSocket
        Font
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        font: FontSocket
        """Font"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class HandleTypeSelection(_HandleModeMixin, BaseNode):
    """
    Provide a selection based on the handle types of Bézier control points

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

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

    class _Inputs(SocketAccessor):
        pass

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

    if TYPE_CHECKING:

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

    @classmethod
    def free(cls) -> "HandleTypeSelection":
        """Create Handle Type Selection with operation 'Free'. The handle can be moved anywhere, and does not influence the point's other handle"""
        return cls(handle_type="FREE")

    @classmethod
    def auto(cls) -> "HandleTypeSelection":
        """Create Handle Type Selection with operation 'Auto'. The location is automatically calculated to be smooth"""
        return cls(handle_type="AUTO")

    @classmethod
    def vector(cls) -> "HandleTypeSelection":
        """Create Handle Type Selection with operation 'Vector'. The location is calculated to point to the next/previous control point"""
        return cls(handle_type="VECTOR")

    @classmethod
    def align(cls) -> "HandleTypeSelection":
        """Create Handle Type Selection with operation 'Align'. The location is constrained to point in the opposite direction as the other handle"""
        return cls(handle_type="ALIGN")

    @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,
        handle_type: Literal["FREE", "AUTO", "VECTOR", "ALIGN"] = "AUTO",
        left: bool = True,
        right: bool = True,
    ):
        super().__init__()
        self.handle_type = handle_type
        self.left = left
        self.right = right


class ID(BaseNode):
    """
    Retrieve a stable random identifier value from the "id" attribute on the point domain, or the index if the attribute does not exist

    Outputs
    -------
    o.id : IntegerSocket
        ID
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        id: IntegerSocket
        """ID"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class Image(BaseNode):
    """
    Input an image data-block

    Outputs
    -------
    o.image : ImageSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        image: ImageSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class ImageInfo(BaseNode):
    """
    Retrieve information about an image

    Parameters
    ----------
    image : InputImage
        Image
    frame : InputInteger
        Frame

    Inputs
    ------
    i.image : ImageSocket
        Image
    i.frame : IntegerSocket
        Frame

    Outputs
    -------
    o.width : IntegerSocket
        Width
    o.height : IntegerSocket
        Height
    o.has_alpha : BooleanSocket
        Has Alpha
    o.frame_count : IntegerSocket
        Frame Count
    o.fps : FloatSocket
        FPS
    """

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

    class _Inputs(SocketAccessor):
        image: ImageSocket
        """Image"""
        frame: IntegerSocket
        """Frame"""

    class _Outputs(SocketAccessor):
        width: IntegerSocket
        """Width"""
        height: IntegerSocket
        """Height"""
        has_alpha: BooleanSocket
        """Has Alpha"""
        frame_count: IntegerSocket
        """Frame Count"""
        fps: FloatSocket
        """FPS"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputImage = None,
        frame: InputInteger = 0,
    ):
        super().__init__()
        key_args = {"Image": image, "Frame": frame}

        self._establish_links(**key_args)


class ImportCSV(BaseNode):
    """
    Import geometry from an CSV file

    Parameters
    ----------
    path : InputString
        Path
    delimiter : InputString
        Delimiter

    Inputs
    ------
    i.path : StringSocket
        Path
    i.delimiter : StringSocket
        Delimiter

    Outputs
    -------
    o.point_cloud : GeometrySocket
        Point Cloud
    """

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

    class _Inputs(SocketAccessor):
        path: StringSocket
        """Path"""
        delimiter: StringSocket
        """Delimiter"""

    class _Outputs(SocketAccessor):
        point_cloud: GeometrySocket
        """Point Cloud"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        path: InputString = "",
        delimiter: InputString = ",",
    ):
        super().__init__()
        key_args = {"Path": path, "Delimiter": delimiter}

        self._establish_links(**key_args)


class ImportOBJ(BaseNode):
    """
    Import geometry from an OBJ file

    Parameters
    ----------
    path : InputString
        Path

    Inputs
    ------
    i.path : StringSocket
        Path

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

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

    class _Inputs(SocketAccessor):
        path: StringSocket
        """Path"""

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

    if TYPE_CHECKING:

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

    def __init__(self, path: InputString = ""):
        super().__init__()
        key_args = {"Path": path}

        self._establish_links(**key_args)


class ImportPLY(BaseNode):
    """
    Import a point cloud from a PLY file

    Parameters
    ----------
    path : InputString
        Path

    Inputs
    ------
    i.path : StringSocket
        Path

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

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

    class _Inputs(SocketAccessor):
        path: StringSocket
        """Path"""

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

    if TYPE_CHECKING:

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

    def __init__(self, path: InputString = ""):
        super().__init__()
        key_args = {"Path": path}

        self._establish_links(**key_args)


class ImportSTL(BaseNode):
    """
    Import a mesh from an STL file

    Parameters
    ----------
    path : InputString
        Path

    Inputs
    ------
    i.path : StringSocket
        Path

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

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

    class _Inputs(SocketAccessor):
        path: StringSocket
        """Path"""

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

    if TYPE_CHECKING:

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

    def __init__(self, path: InputString = ""):
        super().__init__()
        key_args = {"Path": path}

        self._establish_links(**key_args)


class ImportText(BaseNode):
    """
    Import a string from a text file

    Parameters
    ----------
    path : InputString
        Path

    Inputs
    ------
    i.path : StringSocket
        Path

    Outputs
    -------
    o.string : StringSocket
        String
    """

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

    class _Inputs(SocketAccessor):
        path: StringSocket
        """Path"""

    class _Outputs(SocketAccessor):
        string: StringSocket
        """String"""

    if TYPE_CHECKING:

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

    def __init__(self, path: InputString = ""):
        super().__init__()
        key_args = {"Path": path}

        self._establish_links(**key_args)


class ImportVDB(BaseNode):
    """
    Import volume data from a .vdb file

    Parameters
    ----------
    path : InputString
        Path

    Inputs
    ------
    i.path : StringSocket
        Path

    Outputs
    -------
    o.volume : GeometrySocket
        Volume
    """

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

    class _Inputs(SocketAccessor):
        path: StringSocket
        """Path"""

    class _Outputs(SocketAccessor):
        volume: GeometrySocket
        """Volume"""

    if TYPE_CHECKING:

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

    def __init__(self, path: InputString = ""):
        super().__init__()
        key_args = {"Path": path}

        self._establish_links(**key_args)


class Index(BaseNode):
    """
    Retrieve an integer value indicating the position of each element in the list, starting at zero

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

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

    class _Inputs(SocketAccessor):
        pass

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

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class InstanceBounds(BaseNode):
    """
    Calculate position bounds of each instance's geometry set

    Parameters
    ----------
    use_radius : InputBoolean
        Use Radius

    Inputs
    ------
    i.use_radius : BooleanSocket
        Use Radius

    Outputs
    -------
    o.min : VectorSocket
        Min
    o.max : VectorSocket
        Max
    """

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

    class _Inputs(SocketAccessor):
        use_radius: BooleanSocket
        """Use Radius"""

    class _Outputs(SocketAccessor):
        min: VectorSocket
        """Min"""
        max: VectorSocket
        """Max"""

    if TYPE_CHECKING:

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

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

        self._establish_links(**key_args)


class InstanceReference(BaseNode):
    """
    Output the reference index of the instance

    Outputs
    -------
    o.reference_index : IntegerSocket
        Reference Index
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        reference_index: IntegerSocket
        """Reference Index"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class InstanceRotation(BaseNode):
    """
    Retrieve the rotation of each instance in the geometry

    Outputs
    -------
    o.rotation : RotationSocket
        Rotation
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        rotation: RotationSocket
        """Rotation"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class InstanceScale(BaseNode):
    """
    Retrieve the scale of each instance in the geometry

    Outputs
    -------
    o.scale : VectorSocket
        Scale
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        scale: VectorSocket
        """Scale"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class InstanceTransform(BaseNode):
    """
    Retrieve the full transformation of each instance in the geometry

    Outputs
    -------
    o.transform : MatrixSocket
        Transform
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        transform: MatrixSocket
        """Transform"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class Integer(BaseNode):
    """
    Provide an integer value that can be connected to other nodes in the tree

    Outputs
    -------
    o.integer : IntegerSocket
        Integer
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        integer: IntegerSocket
        """Integer"""

    if TYPE_CHECKING:

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

    def __init__(self, integer: int = 1):
        super().__init__()
        key_args = {}
        self.integer = integer
        self._establish_links(**key_args)

    @property
    def integer(self) -> int:
        return self.node.integer

    @integer.setter
    def integer(self, value: int):
        self.node.integer = value


class IsEdgeSmooth(BaseNode):
    """
    Retrieve whether each edge is marked for smooth or split normals

    Outputs
    -------
    o.smooth : BooleanSocket
        Smooth
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        smooth: BooleanSocket
        """Smooth"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class IsFacePlanar(BaseNode):
    """
    Retrieve whether all triangles in a face are on the same plane, i.e. whether they have the same normal

    Parameters
    ----------
    threshold : InputFloat
        Threshold

    Inputs
    ------
    i.threshold : FloatSocket
        Threshold

    Outputs
    -------
    o.planar : BooleanSocket
        Planar
    """

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

    class _Inputs(SocketAccessor):
        threshold: FloatSocket
        """Threshold"""

    class _Outputs(SocketAccessor):
        planar: BooleanSocket
        """Planar"""

    if TYPE_CHECKING:

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

    def __init__(self, threshold: InputFloat = 0.01):
        super().__init__()
        key_args = {"Threshold": threshold}

        self._establish_links(**key_args)


class IsFaceSmooth(BaseNode):
    """
    Retrieve whether each face is marked for smooth or sharp normals

    Outputs
    -------
    o.smooth : BooleanSocket
        Smooth
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        smooth: BooleanSocket
        """Smooth"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class IsSplineCyclic(BaseNode):
    """
    Retrieve whether each spline endpoint connects to the beginning

    Outputs
    -------
    o.cyclic : BooleanSocket
        Cyclic
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        cyclic: BooleanSocket
        """Cyclic"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class IsViewport(BaseNode):
    """
    Retrieve whether the nodes are being evaluated for the viewport rather than the final render

    Outputs
    -------
    o.is_viewport : BooleanSocket
        Is Viewport
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        is_viewport: BooleanSocket
        """Is Viewport"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class MaterialIndex(BaseNode):
    """
    Retrieve the index of the material used for each element in the geometry's list of materials

    Outputs
    -------
    o.material_index : IntegerSocket
        Material Index
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        material_index: IntegerSocket
        """Material Index"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class MeshIsland(BaseNode):
    """
    Retrieve information about separate connected regions in a mesh

    Outputs
    -------
    o.island_index : IntegerSocket
        Island Index
    o.island_count : IntegerSocket
        Island Count
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        island_index: IntegerSocket
        """Island Index"""
        island_count: IntegerSocket
        """Island Count"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class MousePosition(BaseNode):
    """
    Retrieve the position of the mouse cursor

    Outputs
    -------
    o.mouse_x : IntegerSocket
        Mouse X
    o.mouse_y : IntegerSocket
        Mouse Y
    o.region_width : IntegerSocket
        Region Width
    o.region_height : IntegerSocket
        Region Height
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        mouse_x: IntegerSocket
        """Mouse X"""
        mouse_y: IntegerSocket
        """Mouse Y"""
        region_width: IntegerSocket
        """Region Width"""
        region_height: IntegerSocket
        """Region Height"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class NamedAttribute(BaseNode, Generic[_T]):
    """
    Retrieve the data of a specified attribute

    Parameters
    ----------
    name : InputString
        Name

    Inputs
    ------
    i.name : StringSocket
        Name

    Outputs
    -------
    o.attribute : FloatSocket
        Attribute
    o.exists : BooleanSocket
        Exists
    """

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

    class _Inputs(SocketAccessor):
        name: StringSocket
        """Name"""

    class _Outputs(SocketAccessor, Generic[_S]):
        attribute: _S
        """Attribute"""
        exists: BooleanSocket
        """Exists"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        name: InputString = "",
        *,
        data_type: Literal[
            "FLOAT",
            "INT",
            "BOOLEAN",
            "FLOAT_VECTOR",
            "FLOAT_COLOR",
            "QUATERNION",
            "FLOAT4X4",
        ] = "FLOAT",
    ):
        super().__init__()
        key_args = {"Name": name}
        self.data_type = data_type
        self._establish_links(**key_args)

    @classmethod
    def float(cls, name: InputString = "") -> "NamedAttribute[FloatSocket]":
        """Create Named Attribute with operation 'Float'. Floating-point value"""
        return NamedAttribute(data_type="FLOAT", name=name)

    @classmethod
    def integer(cls, name: InputString = "") -> "NamedAttribute[IntegerSocket]":
        """Create Named Attribute with operation 'Integer'. 32-bit integer"""
        return NamedAttribute(data_type="INT", name=name)

    @classmethod
    def boolean(cls, name: InputString = "") -> "NamedAttribute[BooleanSocket]":
        """Create Named Attribute with operation 'Boolean'. True or false"""
        return NamedAttribute(data_type="BOOLEAN", name=name)

    @classmethod
    def vector(cls, name: InputString = "") -> "NamedAttribute[VectorSocket]":
        """Create Named Attribute with operation 'Vector'. 3D vector with floating-point values"""
        return NamedAttribute(data_type="FLOAT_VECTOR", name=name)

    @classmethod
    def color(cls, name: InputString = "") -> "NamedAttribute[ColorSocket]":
        """Create Named Attribute with operation 'Color'. RGBA color with 32-bit floating-point values"""
        return NamedAttribute(data_type="FLOAT_COLOR", name=name)

    @classmethod
    def quaternion(cls, name: InputString = "") -> "NamedAttribute[RotationSocket]":
        """Create Named Attribute with operation 'Quaternion'. Floating point quaternion rotation"""
        return NamedAttribute(data_type="QUATERNION", name=name)

    @classmethod
    def input_4x4_matrix(cls, name: InputString = "") -> "NamedAttribute[MatrixSocket]":
        """Create Named Attribute with operation '4x4 Matrix'. Floating point matrix"""
        return NamedAttribute(data_type="FLOAT4X4", name=name)

    @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 NamedLayerSelection(BaseNode):
    """
    Output a selection of a Grease Pencil layer

    Parameters
    ----------
    name : InputString
        Name

    Inputs
    ------
    i.name : StringSocket
        Name

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

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

    class _Inputs(SocketAccessor):
        name: StringSocket
        """Name"""

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

    if TYPE_CHECKING:

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

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

        self._establish_links(**key_args)


class Normal(BaseNode):
    """
    Retrieve a unit length vector indicating the direction pointing away from the geometry at each element

    Outputs
    -------
    o.normal : VectorSocket
        Normal
    o.true_normal : VectorSocket
        True Normal
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        normal: VectorSocket
        """Normal"""
        true_normal: VectorSocket
        """True Normal"""

    if TYPE_CHECKING:

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

    def __init__(self, legacy_corner_normals: bool = False):
        super().__init__()
        key_args = {}
        self.legacy_corner_normals = legacy_corner_normals
        self._establish_links(**key_args)

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

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


class ObjectInfo(BaseNode):
    """
    Retrieve information from an object

    Parameters
    ----------
    object : InputObject
        Object
    as_instance : InputBoolean
        As Instance

    Inputs
    ------
    i.object : ObjectSocket
        Object
    i.as_instance : BooleanSocket
        As Instance

    Outputs
    -------
    o.transform : MatrixSocket
        Transform
    o.location : VectorSocket
        Location
    o.rotation : RotationSocket
        Rotation
    o.scale : VectorSocket
        Scale
    o.geometry : GeometrySocket
        Geometry
    """

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

    class _Inputs(SocketAccessor):
        object: ObjectSocket
        """Object"""
        as_instance: BooleanSocket
        """As Instance"""

    class _Outputs(SocketAccessor):
        transform: MatrixSocket
        """Transform"""
        location: VectorSocket
        """Location"""
        rotation: RotationSocket
        """Rotation"""
        scale: VectorSocket
        """Scale"""
        geometry: GeometrySocket
        """Geometry"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        object: InputObject = None,
        as_instance: InputBoolean = False,
        *,
        transform_space: Literal["ORIGINAL", "RELATIVE"] = "ORIGINAL",
    ):
        super().__init__()
        key_args = {"Object": object, "As Instance": as_instance}
        self.transform_space = transform_space
        self._establish_links(**key_args)

    @property
    def transform_space(self) -> Literal["ORIGINAL", "RELATIVE"]:
        return self.node.transform_space

    @transform_space.setter
    def transform_space(self, value: Literal["ORIGINAL", "RELATIVE"]):
        self.node.transform_space = value


class OffsetCornerInFace(BaseNode):
    """
    Retrieve corners in the same face as another

    Parameters
    ----------
    corner_index : InputInteger
        Corner Index
    offset : InputInteger
        Offset

    Inputs
    ------
    i.corner_index : IntegerSocket
        Corner Index
    i.offset : IntegerSocket
        Offset

    Outputs
    -------
    o.corner_index : IntegerSocket
        Corner Index
    """

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

    class _Inputs(SocketAccessor):
        corner_index: IntegerSocket
        """Corner Index"""
        offset: IntegerSocket
        """Offset"""

    class _Outputs(SocketAccessor):
        corner_index: IntegerSocket
        """Corner Index"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        corner_index: InputInteger = 0,
        offset: InputInteger = 0,
    ):
        super().__init__()
        key_args = {"Corner Index": corner_index, "Offset": offset}

        self._establish_links(**key_args)


class OffsetPointInCurve(BaseNode):
    """
    Offset a control point index within its curve

    Parameters
    ----------
    point_index : InputInteger
        Point Index
    offset : InputInteger
        Offset

    Inputs
    ------
    i.point_index : IntegerSocket
        Point Index
    i.offset : IntegerSocket
        Offset

    Outputs
    -------
    o.is_valid_offset : BooleanSocket
        Is Valid Offset
    o.point_index : IntegerSocket
        Point Index
    """

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

    class _Inputs(SocketAccessor):
        point_index: IntegerSocket
        """Point Index"""
        offset: IntegerSocket
        """Offset"""

    class _Outputs(SocketAccessor):
        is_valid_offset: BooleanSocket
        """Is Valid Offset"""
        point_index: IntegerSocket
        """Point Index"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        point_index: InputInteger = 0,
        offset: InputInteger = 0,
    ):
        super().__init__()
        key_args = {"Point Index": point_index, "Offset": offset}

        self._establish_links(**key_args)


class PointsOfCurve(BaseNode):
    """
    Retrieve a point index within a curve

    Parameters
    ----------
    curve_index : InputInteger
        Curve Index
    weights : InputFloat
        Weights
    sort_index : InputInteger
        Sort Index

    Inputs
    ------
    i.curve_index : IntegerSocket
        Curve Index
    i.weights : FloatSocket
        Weights
    i.sort_index : IntegerSocket
        Sort Index

    Outputs
    -------
    o.point_index : IntegerSocket
        Point Index
    o.total : IntegerSocket
        Total
    """

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

    class _Inputs(SocketAccessor):
        curve_index: IntegerSocket
        """Curve Index"""
        weights: FloatSocket
        """Weights"""
        sort_index: IntegerSocket
        """Sort Index"""

    class _Outputs(SocketAccessor):
        point_index: IntegerSocket
        """Point Index"""
        total: IntegerSocket
        """Total"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        curve_index: InputInteger = 0,
        weights: InputFloat = 0.0,
        sort_index: InputInteger = 0,
    ):
        super().__init__()
        key_args = {
            "Curve Index": curve_index,
            "Weights": weights,
            "Sort Index": sort_index,
        }

        self._establish_links(**key_args)


class Position(BaseNode):
    """
    Retrieve a vector indicating the location of each element

    Outputs
    -------
    o.position : VectorSocket
        Position
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        position: VectorSocket
        """Position"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class Radius(BaseNode):
    """
    Retrieve the radius at each point on curve or point cloud geometry

    Outputs
    -------
    o.radius : FloatSocket
        Radius
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        radius: FloatSocket
        """Radius"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class Rotation(BaseNode):
    """
    Provide a rotation value that can be connected to other nodes in the tree

    Outputs
    -------
    o.rotation : RotationSocket
        Rotation
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        rotation: RotationSocket
        """Rotation"""

    if TYPE_CHECKING:

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

    def __init__(self, rotation_euler: tuple[float, float, float] = (0.0, 0.0, 0.0)):
        super().__init__()
        key_args = {}
        self.rotation_euler = rotation_euler
        self._establish_links(**key_args)

    @property
    def rotation_euler(self) -> Euler:
        return self.node.rotation_euler

    @rotation_euler.setter
    def rotation_euler(self, value: Euler | tuple[float, float, float]):
        self.node.rotation_euler = value


class SceneTime(BaseNode):
    """
    Retrieve the current time in the scene's animation in units of seconds or frames

    Outputs
    -------
    o.seconds : FloatSocket
        Seconds
    o.frame : FloatSocket
        Frame
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        seconds: FloatSocket
        """Seconds"""
        frame: FloatSocket
        """Frame"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class Selection(BaseNode):
    """
    User selection of the edited geometry, for tool execution

    Outputs
    -------
    o.selection : BooleanSocket
        Boolean
    o.float : FloatSocket
        Float
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        selection: BooleanSocket
        """Boolean"""
        float: FloatSocket
        """Float"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class SelfObject(BaseNode):
    """
    Retrieve the object that contains the geometry nodes modifier currently being executed

    Outputs
    -------
    o.self_object : ObjectSocket
        Self Object
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        self_object: ObjectSocket
        """Self Object"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class ShortestEdgePaths(BaseNode):
    """
    Find the shortest paths along mesh edges to selected end vertices, with customizable cost per edge

    Parameters
    ----------
    end_vertex : InputBoolean
        End Vertex
    edge_cost : InputFloat
        Edge Cost

    Inputs
    ------
    i.end_vertex : BooleanSocket
        End Vertex
    i.edge_cost : FloatSocket
        Edge Cost

    Outputs
    -------
    o.next_vertex_index : IntegerSocket
        Next Vertex Index
    o.total_cost : FloatSocket
        Total Cost
    """

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

    class _Inputs(SocketAccessor):
        end_vertex: BooleanSocket
        """End Vertex"""
        edge_cost: FloatSocket
        """Edge Cost"""

    class _Outputs(SocketAccessor):
        next_vertex_index: IntegerSocket
        """Next Vertex Index"""
        total_cost: FloatSocket
        """Total Cost"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        end_vertex: InputBoolean = False,
        edge_cost: InputFloat = 1.0,
    ):
        super().__init__()
        key_args = {"End Vertex": end_vertex, "Edge Cost": edge_cost}

        self._establish_links(**key_args)


class SpecialCharacters(BaseNode):
    """
    Output string characters that cannot be typed directly with the keyboard

    Outputs
    -------
    o.line_break : StringSocket
        Line Break
    o.tab : StringSocket
        Tab
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        line_break: StringSocket
        """Line Break"""
        tab: StringSocket
        """Tab"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class SplineLength(BaseNode):
    """
    Retrieve the total length of each spline, as a distance or as a number of points

    Outputs
    -------
    o.length : FloatSocket
        Length
    o.point_count : IntegerSocket
        Point Count
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        length: FloatSocket
        """Length"""
        point_count: IntegerSocket
        """Point Count"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class SplineParameter(BaseNode):
    """
    Retrieve how far along each spline a control point is

    Outputs
    -------
    o.factor : FloatSocket
        Factor
    o.length : FloatSocket
        Length
    o.index : IntegerSocket
        Index
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        factor: FloatSocket
        """Factor"""
        length: FloatSocket
        """Length"""
        index: IntegerSocket
        """Index"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class SplineResolution(BaseNode):
    """
    Retrieve the number of evaluated points that will be generated for every control point on curves

    Outputs
    -------
    o.resolution : IntegerSocket
        Resolution
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        resolution: IntegerSocket
        """Resolution"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class String(BaseNode):
    """
    Provide a string value that can be connected to other nodes in the tree

    Outputs
    -------
    o.string : StringSocket
        String
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        string: StringSocket
        """String"""

    if TYPE_CHECKING:

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

    def __init__(self, string: str = ""):
        super().__init__()
        key_args = {}
        self.string = string
        self._establish_links(**key_args)

    @property
    def string(self) -> str:
        return self.node.string

    @string.setter
    def string(self, value: str):
        self.node.string = value


class UVTangent(BaseNode):
    """
    Generate tangent directions based on a UV map

    Parameters
    ----------
    method : InputMenu | Literal['Exact', 'Fast']
        Method
    uv : InputVector
        UV

    Inputs
    ------
    i.method : MenuSocket
        Method
    i.uv : VectorSocket
        UV

    Outputs
    -------
    o.tangent : VectorSocket
        Tangent
    """

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

    class _Inputs(SocketAccessor):
        method: MenuSocket
        """Method"""
        uv: VectorSocket
        """UV"""

    class _Outputs(SocketAccessor):
        tangent: VectorSocket
        """Tangent"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        method: InputMenu | Literal["Exact", "Fast"] = "Exact",
        uv: InputVector = None,
    ):
        super().__init__()
        key_args = {"Method": method, "UV": uv}

        self._establish_links(**key_args)


class Vector(BaseNode):
    """
    Provide a vector value that can be connected to other nodes in the tree

    Outputs
    -------
    o.vector : VectorSocket
        Vector
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        vector: VectorSocket
        """Vector"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vector: tuple[float, float, float] = (0.0, 0.0, 0.0),
        vector_dimensions: int = 3,
    ):
        super().__init__()
        key_args = {}
        self.vector = vector
        self.vector_dimensions = vector_dimensions
        self._establish_links(**key_args)

    @property
    def vector(self) -> Vector:
        return self.node.vector

    @vector.setter
    def vector(self, value: Vector | tuple[float, float, float]):
        self.node.vector = value

    @property
    def vector_dimensions(self) -> int:
        return self.node.vector_dimensions

    @vector_dimensions.setter
    def vector_dimensions(self, value: int):
        self.node.vector_dimensions = value


class VertexNeighbors(BaseNode):
    """
    Retrieve topology information relating to each vertex of a mesh

    Outputs
    -------
    o.vertex_count : IntegerSocket
        Vertex Count
    o.face_count : IntegerSocket
        Face Count
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        vertex_count: IntegerSocket
        """Vertex Count"""
        face_count: IntegerSocket
        """Face Count"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class VertexOfCorner(BaseNode):
    """
    Retrieve the vertex each face corner is attached to

    Parameters
    ----------
    corner_index : InputInteger
        Corner Index

    Inputs
    ------
    i.corner_index : IntegerSocket
        Corner Index

    Outputs
    -------
    o.vertex_index : IntegerSocket
        Vertex Index
    """

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

    class _Inputs(SocketAccessor):
        corner_index: IntegerSocket
        """Corner Index"""

    class _Outputs(SocketAccessor):
        vertex_index: IntegerSocket
        """Vertex Index"""

    if TYPE_CHECKING:

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

    def __init__(self, corner_index: InputInteger = 0):
        super().__init__()
        key_args = {"Corner Index": corner_index}

        self._establish_links(**key_args)


class ViewportTransform(BaseNode):
    """
    Retrieve the view direction and location of the 3D viewport

    Outputs
    -------
    o.projection : MatrixSocket
        Projection
    o.view : MatrixSocket
        View
    o.is_orthographic : BooleanSocket
        Is Orthographic
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        projection: MatrixSocket
        """Projection"""
        view: MatrixSocket
        """View"""
        is_orthographic: BooleanSocket
        """Is Orthographic"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)


class VoxelIndex(BaseNode):
    """
    Retrieve the integer coordinates of the voxel that the field is evaluated on

    Outputs
    -------
    o.x : IntegerSocket
        X
    o.y : IntegerSocket
        Y
    o.z : IntegerSocket
        Z
    o.is_tile : BooleanSocket
        Is Tile
    o.extent_x : IntegerSocket
        Extent X
    o.extent_y : IntegerSocket
        Extent Y
    o.extent_z : IntegerSocket
        Extent Z
    """

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

    class _Inputs(SocketAccessor):
        pass

    class _Outputs(SocketAccessor):
        x: IntegerSocket
        """X"""
        y: IntegerSocket
        """Y"""
        z: IntegerSocket
        """Z"""
        is_tile: BooleanSocket
        """Is Tile"""
        extent_x: IntegerSocket
        """Extent X"""
        extent_y: IntegerSocket
        """Extent Y"""
        extent_z: IntegerSocket
        """Extent Z"""

    if TYPE_CHECKING:

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

    def __init__(self):
        super().__init__()
        key_args = {}

        self._establish_links(**key_args)
