nodebpy 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

nodebpy/nodes/utilities.py

@@ -1,2344 +0,0 @@
-"""
-Auto-generated Blender Geometry Node classes.
-
-DO NOT EDIT THIS FILE MANUALLY.
-This file is generated by molecularnodes/nodes/generator.py
-
-To regenerate: Run generator.py from within Blender
-
-KNOWN LIMITATIONS:
-- Dynamic multi-input/output sockets are not yet supported
-  (these are the unnamed sockets that appear in the UI for nodes like
-  "Evaluate Closure", "Join Geometry", etc. that allow dragging in
-  multiple connections)
-- TODO: Add support for dynamic socket creation
-"""
-
-from __future__ import annotations
-import bpy
-from typing_extensions import Literal
-from ..builder import NodeBuilder, NodeSocket
-from .types import LINKABLE, TYPE_INPUT_VECTOR
-
-
-class AlignEulerToVector(NodeBuilder):
-    """Orient an Euler rotation along the given direction"""
-
-    name = "FunctionNodeAlignEulerToVector"
-    node: bpy.types.FunctionNodeAlignEulerToVector
-
-    def __init__(
-        self,
-        rotation: LINKABLE | None = [0.0, 0.0, 0.0],
-        factor: LINKABLE | None = 1.0,
-        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 1.0],
-        axis: Literal["X", "Y", "Z"] = "X",
-        pivot_axis: Literal["AUTO", "X", "Y", "Z"] = "AUTO",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Rotation": rotation, "Factor": factor, "Vector": vector}
-        key_args.update(kwargs)
-        self.axis = axis
-        self.pivot_axis = pivot_axis
-        self._establish_links(**key_args)
-
-    @property
-    def i_rotation(self) -> NodeSocket:
-        """Input socket: Rotation"""
-        return self._input("Rotation")
-
-    @property
-    def i_factor(self) -> NodeSocket:
-        """Input socket: Factor"""
-        return self._input("Factor")
-
-    @property
-    def i_vector(self) -> bpy.types.NodeSocketVector:
-        """Input socket: Vector"""
-        return self._input("Vector")
-
-    @property
-    def o_rotation(self) -> NodeSocket:
-        """Output socket: Rotation"""
-        return self._output("Rotation")
-
-    @property
-    def axis(self) -> Literal["X", "Y", "Z"]:
-        return self.node.axis
-
-    @axis.setter
-    def axis(self, value: Literal["X", "Y", "Z"]):
-        self.node.axis = value
-
-    @property
-    def pivot_axis(self) -> Literal["AUTO", "X", "Y", "Z"]:
-        return self.node.pivot_axis
-
-    @pivot_axis.setter
-    def pivot_axis(self, value: Literal["AUTO", "X", "Y", "Z"]):
-        self.node.pivot_axis = value
-
-
-class AlignRotationToVector(NodeBuilder):
-    """Orient a rotation along the given direction"""
-
-    name = "FunctionNodeAlignRotationToVector"
-    node: bpy.types.FunctionNodeAlignRotationToVector
-
-    def __init__(
-        self,
-        rotation: TYPE_INPUT_ROTATION = [0.0, 0.0, 0.0],
-        factor: LINKABLE | None = 1.0,
-        vector: LINKABLE | None = [0.0, 0.0, 1.0],
-        axis: Literal["X", "Y", "Z"] = "Z",
-        pivot_axis: Literal["AUTO", "X", "Y", "Z"] = "AUTO",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Rotation": rotation, "Factor": factor, "Vector": vector}
-        key_args.update(kwargs)
-        self.axis = axis
-        self.pivot_axis = pivot_axis
-        self._establish_links(**key_args)
-
-    @property
-    def i_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Input socket: Rotation"""
-        return self._input("Rotation")
-
-    @property
-    def i_factor(self) -> NodeSocket:
-        """Input socket: Factor"""
-        return self._input("Factor")
-
-    @property
-    def i_vector(self) -> NodeSocket:
-        """Input socket: Vector"""
-        return self._input("Vector")
-
-    @property
-    def o_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Output socket: Rotation"""
-        return self._output("Rotation")
-
-    @property
-    def axis(self) -> Literal["X", "Y", "Z"]:
-        return self.node.axis
-
-    @axis.setter
-    def axis(self, value: Literal["X", "Y", "Z"]):
-        self.node.axis = value
-
-    @property
-    def pivot_axis(self) -> Literal["AUTO", "X", "Y", "Z"]:
-        return self.node.pivot_axis
-
-    @pivot_axis.setter
-    def pivot_axis(self, value: Literal["AUTO", "X", "Y", "Z"]):
-        self.node.pivot_axis = value
-
-
-class AxesToRotation(NodeBuilder):
-    """Create a rotation from a primary and (ideally orthogonal) secondary axis"""
-
-    name = "FunctionNodeAxesToRotation"
-    node: bpy.types.FunctionNodeAxesToRotation
-
-    def __init__(
-        self,
-        primary_axis: TYPE_INPUT_VECTOR = [0.0, 0.0, 1.0],
-        secondary_axis: TYPE_INPUT_VECTOR = [1.0, 0.0, 0.0],
-        primary_axis_axis: Literal["X", "Y", "Z"] = "Z",
-        secondary_axis_axis: Literal["X", "Y", "Z"] = "X",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Primary Axis": primary_axis, "Secondary Axis": secondary_axis}
-        key_args.update(kwargs)
-        self.primary_axis = primary_axis
-        self.secondary_axis = secondary_axis
-        self._establish_links(**key_args)
-
-    @property
-    def i_primary_axis(self) -> bpy.types.NodeSocketVector:
-        """Input socket: Primary Axis"""
-        return self._input("Primary Axis")
-
-    @property
-    def i_secondary_axis(self) -> bpy.types.NodeSocketVector:
-        """Input socket: Secondary Axis"""
-        return self._input("Secondary Axis")
-
-    @property
-    def o_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Output socket: Rotation"""
-        return self._output("Rotation")
-
-    @property
-    def primary_axis(self) -> Literal["X", "Y", "Z"]:
-        return self.node.primary_axis
-
-    @primary_axis.setter
-    def primary_axis(self, value: Literal["X", "Y", "Z"]):
-        self.node.primary_axis = value
-
-    @property
-    def secondary_axis(self) -> Literal["X", "Y", "Z"]:
-        return self.node.secondary_axis
-
-    @secondary_axis.setter
-    def secondary_axis(self, value: Literal["X", "Y", "Z"]):
-        self.node.secondary_axis = value
-
-
-class AxisAngleToRotation(NodeBuilder):
-    """Build a rotation from an axis and a rotation around that axis"""
-
-    name = "FunctionNodeAxisAngleToRotation"
-    node: bpy.types.FunctionNodeAxisAngleToRotation
-
-    def __init__(
-        self,
-        axis: TYPE_INPUT_VECTOR = [0.0, 0.0, 1.0],
-        angle: LINKABLE | None = 0.0,
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Axis": axis, "Angle": angle}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_axis(self) -> bpy.types.NodeSocketVector:
-        """Input socket: Axis"""
-        return self._input("Axis")
-
-    @property
-    def i_angle(self) -> NodeSocket:
-        """Input socket: Angle"""
-        return self._input("Angle")
-
-    @property
-    def o_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Output socket: Rotation"""
-        return self._output("Rotation")
-
-
-class BitMath(NodeBuilder):
-    """Perform bitwise operations on 32-bit integers"""
-
-    name = "FunctionNodeBitMath"
-    node: bpy.types.FunctionNodeBitMath
-
-    def __init__(
-        self,
-        a: int | LINKABLE | None = 0,
-        b: int | LINKABLE | None = 0,
-        operation: Literal["AND", "OR", "XOR", "NOT", "SHIFT", "ROTATE"] = "AND",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"A": a, "B": b}
-        key_args.update(kwargs)
-        self.operation = operation
-        self._establish_links(**key_args)
-
-    @classmethod
-    def l_and(
-        cls, a: int | LINKABLE | None = 0, b: int | LINKABLE | None = 0
-    ) -> "BitMath":
-        """Create Bit Math with operation 'And'."""
-        return cls(operation="AND", a=a, b=b)
-
-    @classmethod
-    def l_or(
-        cls, a: int | LINKABLE | None = 0, b: int | LINKABLE | None = 0
-    ) -> "BitMath":
-        """Create Bit Math with operation 'Or'."""
-        return cls(operation="OR", a=a, b=b)
-
-    @classmethod
-    def xor(
-        cls, a: int | LINKABLE | None = 0, b: int | LINKABLE | None = 0
-    ) -> "BitMath":
-        """Create Bit Math with operation 'Exclusive Or'."""
-        return cls(operation="XOR", a=a, b=b)
-
-    @classmethod
-    def l_not(
-        cls, a: int | LINKABLE | None = 0, b: int | LINKABLE | None = 0
-    ) -> "BitMath":
-        """Create Bit Math with operation 'Not'."""
-        return cls(operation="NOT", a=a, b=b)
-
-    @classmethod
-    def shift(
-        cls, a: int | LINKABLE | None = 0, b: int | LINKABLE | None = 0
-    ) -> "BitMath":
-        """Create Bit Math with operation 'Shift'."""
-        return cls(operation="SHIFT", a=a, b=b)
-
-    @classmethod
-    def rotate(
-        cls, a: int | LINKABLE | None = 0, b: int | LINKABLE | None = 0
-    ) -> "BitMath":
-        """Create Bit Math with operation 'Rotate'."""
-        return cls(operation="ROTATE", a=a, b=b)
-
-    @property
-    def i_a(self) -> bpy.types.NodeSocketInt:
-        """Input socket: A"""
-        return self._input("A")
-
-    @property
-    def i_b(self) -> bpy.types.NodeSocketInt:
-        """Input socket: B"""
-        return self._input("B")
-
-    @property
-    def o_value(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Value"""
-        return self._output("Value")
-
-    @property
-    def operation(self) -> Literal["AND", "OR", "XOR", "NOT", "SHIFT", "ROTATE"]:
-        return self.node.operation
-
-    @operation.setter
-    def operation(self, value: Literal["AND", "OR", "XOR", "NOT", "SHIFT", "ROTATE"]):
-        self.node.operation = value
-
-
-class CombineColor(NodeBuilder):
-    """Combine four channels into a single color, based on a particular color model"""
-
-    name = "FunctionNodeCombineColor"
-    node: bpy.types.FunctionNodeCombineColor
-
-    def __init__(
-        self,
-        red: LINKABLE | None = 0.0,
-        green: LINKABLE | None = 0.0,
-        blue: LINKABLE | None = 0.0,
-        alpha: LINKABLE | None = 1.0,
-        mode: Literal["RGB", "HSV", "HSL"] = "RGB",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Red": red, "Green": green, "Blue": blue, "Alpha": alpha}
-        key_args.update(kwargs)
-        self.mode = mode
-        self._establish_links(**key_args)
-
-    @property
-    def i_red(self) -> NodeSocket:
-        """Input socket: Red"""
-        return self._input("Red")
-
-    @property
-    def i_green(self) -> NodeSocket:
-        """Input socket: Green"""
-        return self._input("Green")
-
-    @property
-    def i_blue(self) -> NodeSocket:
-        """Input socket: Blue"""
-        return self._input("Blue")
-
-    @property
-    def i_alpha(self) -> NodeSocket:
-        """Input socket: Alpha"""
-        return self._input("Alpha")
-
-    @property
-    def o_color(self) -> bpy.types.NodeSocketColor:
-        """Output socket: Color"""
-        return self._output("Color")
-
-    @property
-    def mode(self) -> Literal["RGB", "HSV", "HSL"]:
-        return self.node.mode
-
-    @mode.setter
-    def mode(self, value: Literal["RGB", "HSV", "HSL"]):
-        self.node.mode = value
-
-
-class CombineMatrix(NodeBuilder):
-    """Construct a 4x4 matrix from its individual values"""
-
-    name = "FunctionNodeCombineMatrix"
-    node: bpy.types.FunctionNodeCombineMatrix
-
-    def __init__(
-        self,
-        column_1_row_1: float | LINKABLE | None = 1.0,
-        column_1_row_2: float | LINKABLE | None = 0.0,
-        column_1_row_3: float | LINKABLE | None = 0.0,
-        column_1_row_4: float | LINKABLE | None = 0.0,
-        column_2_row_1: float | LINKABLE | None = 0.0,
-        column_2_row_2: float | LINKABLE | None = 1.0,
-        column_2_row_3: float | LINKABLE | None = 0.0,
-        column_2_row_4: float | LINKABLE | None = 0.0,
-        column_3_row_1: float | LINKABLE | None = 0.0,
-        column_3_row_2: float | LINKABLE | None = 0.0,
-        column_3_row_3: float | LINKABLE | None = 1.0,
-        column_3_row_4: float | LINKABLE | None = 0.0,
-        column_4_row_1: float | LINKABLE | None = 0.0,
-        column_4_row_2: float | LINKABLE | None = 0.0,
-        column_4_row_3: float | LINKABLE | None = 0.0,
-        column_4_row_4: float | LINKABLE | None = 1.0,
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {
-            "Column 1 Row 1": column_1_row_1,
-            "Column 1 Row 2": column_1_row_2,
-            "Column 1 Row 3": column_1_row_3,
-            "Column 1 Row 4": column_1_row_4,
-            "Column 2 Row 1": column_2_row_1,
-            "Column 2 Row 2": column_2_row_2,
-            "Column 2 Row 3": column_2_row_3,
-            "Column 2 Row 4": column_2_row_4,
-            "Column 3 Row 1": column_3_row_1,
-            "Column 3 Row 2": column_3_row_2,
-            "Column 3 Row 3": column_3_row_3,
-            "Column 3 Row 4": column_3_row_4,
-            "Column 4 Row 1": column_4_row_1,
-            "Column 4 Row 2": column_4_row_2,
-            "Column 4 Row 3": column_4_row_3,
-            "Column 4 Row 4": column_4_row_4,
-        }
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_column_1_row_1(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 1 Row 1"""
-        return self._input("Column 1 Row 1")
-
-    @property
-    def i_column_1_row_2(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 1 Row 2"""
-        return self._input("Column 1 Row 2")
-
-    @property
-    def i_column_1_row_3(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 1 Row 3"""
-        return self._input("Column 1 Row 3")
-
-    @property
-    def i_column_1_row_4(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 1 Row 4"""
-        return self._input("Column 1 Row 4")
-
-    @property
-    def i_column_2_row_1(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 2 Row 1"""
-        return self._input("Column 2 Row 1")
-
-    @property
-    def i_column_2_row_2(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 2 Row 2"""
-        return self._input("Column 2 Row 2")
-
-    @property
-    def i_column_2_row_3(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 2 Row 3"""
-        return self._input("Column 2 Row 3")
-
-    @property
-    def i_column_2_row_4(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 2 Row 4"""
-        return self._input("Column 2 Row 4")
-
-    @property
-    def i_column_3_row_1(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 3 Row 1"""
-        return self._input("Column 3 Row 1")
-
-    @property
-    def i_column_3_row_2(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 3 Row 2"""
-        return self._input("Column 3 Row 2")
-
-    @property
-    def i_column_3_row_3(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 3 Row 3"""
-        return self._input("Column 3 Row 3")
-
-    @property
-    def i_column_3_row_4(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 3 Row 4"""
-        return self._input("Column 3 Row 4")
-
-    @property
-    def i_column_4_row_1(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 4 Row 1"""
-        return self._input("Column 4 Row 1")
-
-    @property
-    def i_column_4_row_2(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 4 Row 2"""
-        return self._input("Column 4 Row 2")
-
-    @property
-    def i_column_4_row_3(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 4 Row 3"""
-        return self._input("Column 4 Row 3")
-
-    @property
-    def i_column_4_row_4(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Column 4 Row 4"""
-        return self._input("Column 4 Row 4")
-
-    @property
-    def o_matrix(self) -> NodeSocket:
-        """Output socket: Matrix"""
-        return self._output("Matrix")
-
-
-class CombineTransform(NodeBuilder):
-    """Combine a translation vector, a rotation, and a scale vector into a transformation matrix"""
-
-    name = "FunctionNodeCombineTransform"
-    node: bpy.types.FunctionNodeCombineTransform
-
-    def __init__(
-        self,
-        translation: LINKABLE | None = [0.0, 0.0, 0.0],
-        rotation: TYPE_INPUT_ROTATION = [0.0, 0.0, 0.0],
-        scale: LINKABLE | None = [1.0, 1.0, 1.0],
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Translation": translation, "Rotation": rotation, "Scale": scale}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_translation(self) -> NodeSocket:
-        """Input socket: Translation"""
-        return self._input("Translation")
-
-    @property
-    def i_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Input socket: Rotation"""
-        return self._input("Rotation")
-
-    @property
-    def i_scale(self) -> NodeSocket:
-        """Input socket: Scale"""
-        return self._input("Scale")
-
-    @property
-    def o_transform(self) -> NodeSocket:
-        """Output socket: Transform"""
-        return self._output("Transform")
-
-
-class Compare(NodeBuilder):
-    """Perform a comparison operation on the two given inputs"""
-
-    name = "FunctionNodeCompare"
-    node: bpy.types.FunctionNodeCompare
-
-    def __init__(
-        self,
-        a: float | LINKABLE | None = 0.0,
-        b: float | LINKABLE | None = 0.0,
-        operation: Literal[
-            "LESS_THAN",
-            "LESS_EQUAL",
-            "GREATER_THAN",
-            "GREATER_EQUAL",
-            "EQUAL",
-            "NOT_EQUAL",
-            "BRIGHTER",
-            "DARKER",
-        ] = "GREATER_THAN",
-        data_type: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "VECTOR",
-            "RGBA",
-            "ROTATION",
-            "MATRIX",
-            "STRING",
-            "MENU",
-            "SHADER",
-            "OBJECT",
-            "IMAGE",
-            "GEOMETRY",
-            "COLLECTION",
-            "TEXTURE",
-            "MATERIAL",
-            "BUNDLE",
-            "CLOSURE",
-        ] = "FLOAT",
-        mode: Literal[
-            "ELEMENT", "LENGTH", "AVERAGE", "DOT_PRODUCT", "DIRECTION"
-        ] = "ELEMENT",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"A": a, "B": b}
-        key_args.update(kwargs)
-        self.operation = operation
-        self.data_type = data_type
-        self.mode = mode
-        self._establish_links(**key_args)
-
-    @classmethod
-    def lessthan(
-        cls, a: float | LINKABLE | None = 0.0, b: float | LINKABLE | None = 0.0
-    ) -> "Compare":
-        """Create Compare with operation 'Less Than'."""
-        return cls(operation="LESS_THAN", a=a, b=b)
-
-    @classmethod
-    def lessequal(
-        cls, a: float | LINKABLE | None = 0.0, b: float | LINKABLE | None = 0.0
-    ) -> "Compare":
-        """Create Compare with operation 'Less Than or Equal'."""
-        return cls(operation="LESS_EQUAL", a=a, b=b)
-
-    @classmethod
-    def greaterthan(
-        cls, a: float | LINKABLE | None = 0.0, b: float | LINKABLE | None = 0.0
-    ) -> "Compare":
-        """Create Compare with operation 'Greater Than'."""
-        return cls(operation="GREATER_THAN", a=a, b=b)
-
-    @classmethod
-    def greaterequal(
-        cls, a: float | LINKABLE | None = 0.0, b: float | LINKABLE | None = 0.0
-    ) -> "Compare":
-        """Create Compare with operation 'Greater Than or Equal'."""
-        return cls(operation="GREATER_EQUAL", a=a, b=b)
-
-    @classmethod
-    def equal(
-        cls, a: float | LINKABLE | None = 0.0, b: float | LINKABLE | None = 0.0
-    ) -> "Compare":
-        """Create Compare with operation 'Equal'."""
-        return cls(operation="EQUAL", a=a, b=b)
-
-    @classmethod
-    def notequal(
-        cls, a: float | LINKABLE | None = 0.0, b: float | LINKABLE | None = 0.0
-    ) -> "Compare":
-        """Create Compare with operation 'Not Equal'."""
-        return cls(operation="NOT_EQUAL", a=a, b=b)
-
-    @classmethod
-    def brighter(
-        cls, a: float | LINKABLE | None = 0.0, b: float | LINKABLE | None = 0.0
-    ) -> "Compare":
-        """Create Compare with operation 'Brighter'."""
-        return cls(operation="BRIGHTER", a=a, b=b)
-
-    @classmethod
-    def darker(
-        cls, a: float | LINKABLE | None = 0.0, b: float | LINKABLE | None = 0.0
-    ) -> "Compare":
-        """Create Compare with operation 'Darker'."""
-        return cls(operation="DARKER", a=a, b=b)
-
-    @property
-    def i_a(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: A"""
-        return self._input("A")
-
-    @property
-    def i_b(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: B"""
-        return self._input("B")
-
-    @property
-    def o_result(self) -> bpy.types.NodeSocketBool:
-        """Output socket: Result"""
-        return self._output("Result")
-
-    @property
-    def operation(
-        self,
-    ) -> Literal[
-        "LESS_THAN",
-        "LESS_EQUAL",
-        "GREATER_THAN",
-        "GREATER_EQUAL",
-        "EQUAL",
-        "NOT_EQUAL",
-        "BRIGHTER",
-        "DARKER",
-    ]:
-        return self.node.operation
-
-    @operation.setter
-    def operation(
-        self,
-        value: Literal[
-            "LESS_THAN",
-            "LESS_EQUAL",
-            "GREATER_THAN",
-            "GREATER_EQUAL",
-            "EQUAL",
-            "NOT_EQUAL",
-            "BRIGHTER",
-            "DARKER",
-        ],
-    ):
-        self.node.operation = value
-
-    @property
-    def data_type(
-        self,
-    ) -> Literal[
-        "FLOAT",
-        "INT",
-        "BOOLEAN",
-        "VECTOR",
-        "RGBA",
-        "ROTATION",
-        "MATRIX",
-        "STRING",
-        "MENU",
-        "SHADER",
-        "OBJECT",
-        "IMAGE",
-        "GEOMETRY",
-        "COLLECTION",
-        "TEXTURE",
-        "MATERIAL",
-        "BUNDLE",
-        "CLOSURE",
-    ]:
-        return self.node.data_type
-
-    @data_type.setter
-    def data_type(
-        self,
-        value: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "VECTOR",
-            "RGBA",
-            "ROTATION",
-            "MATRIX",
-            "STRING",
-            "MENU",
-            "SHADER",
-            "OBJECT",
-            "IMAGE",
-            "GEOMETRY",
-            "COLLECTION",
-            "TEXTURE",
-            "MATERIAL",
-            "BUNDLE",
-            "CLOSURE",
-        ],
-    ):
-        self.node.data_type = value
-
-    @property
-    def mode(
-        self,
-    ) -> Literal["ELEMENT", "LENGTH", "AVERAGE", "DOT_PRODUCT", "DIRECTION"]:
-        return self.node.mode
-
-    @mode.setter
-    def mode(
-        self, value: Literal["ELEMENT", "LENGTH", "AVERAGE", "DOT_PRODUCT", "DIRECTION"]
-    ):
-        self.node.mode = value
-
-
-class EulerToRotation(NodeBuilder):
-    """Build a rotation from separate angles around each axis"""
-
-    name = "FunctionNodeEulerToRotation"
-    node: bpy.types.FunctionNodeEulerToRotation
-
-    def __init__(self, euler: LINKABLE | None = [0.0, 0.0, 0.0], **kwargs):
-        super().__init__()
-        key_args = {"Euler": euler}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_euler(self) -> NodeSocket:
-        """Input socket: Euler"""
-        return self._input("Euler")
-
-    @property
-    def o_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Output socket: Rotation"""
-        return self._output("Rotation")
-
-
-class FindInString(NodeBuilder):
-    """Find the number of times a given string occurs in another string and the position of the first match"""
-
-    name = "FunctionNodeFindInString"
-    node: bpy.types.FunctionNodeFindInString
-
-    def __init__(
-        self,
-        string: str | LINKABLE | None = "",
-        search: str | LINKABLE | None = "",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"String": string, "Search": search}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_string(self) -> bpy.types.NodeSocketString:
-        """Input socket: String"""
-        return self._input("String")
-
-    @property
-    def i_search(self) -> bpy.types.NodeSocketString:
-        """Input socket: Search"""
-        return self._input("Search")
-
-    @property
-    def o_first_found(self) -> bpy.types.NodeSocketInt:
-        """Output socket: First Found"""
-        return self._output("First Found")
-
-    @property
-    def o_count(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Count"""
-        return self._output("Count")
-
-
-class FloatToInteger(NodeBuilder):
-    """Convert the given floating-point number to an integer, with a choice of methods"""
-
-    name = "FunctionNodeFloatToInt"
-    node: bpy.types.FunctionNodeFloatToInt
-
-    def __init__(
-        self,
-        float: float | LINKABLE | None = 0.0,
-        rounding_mode: Literal["ROUND", "FLOOR", "CEILING", "TRUNCATE"] = "ROUND",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Float": float}
-        key_args.update(kwargs)
-        self.rounding_mode = rounding_mode
-        self._establish_links(**key_args)
-
-    @property
-    def i_float(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Float"""
-        return self._input("Float")
-
-    @property
-    def o_integer(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Integer"""
-        return self._output("Integer")
-
-    @property
-    def rounding_mode(self) -> Literal["ROUND", "FLOOR", "CEILING", "TRUNCATE"]:
-        return self.node.rounding_mode
-
-    @rounding_mode.setter
-    def rounding_mode(self, value: Literal["ROUND", "FLOOR", "CEILING", "TRUNCATE"]):
-        self.node.rounding_mode = value
-
-
-class FormatString(NodeBuilder):
-    """Insert values into a string using a Python and path template compatible formatting syntax"""
-
-    name = "FunctionNodeFormatString"
-    node: bpy.types.FunctionNodeFormatString
-
-    def __init__(
-        self,
-        format: str | LINKABLE | None = "",
-        extend: LINKABLE | None = None,
-        active_index: int = 0,
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Format": format, "__extend__": extend}
-        key_args.update(kwargs)
-        self.active_index = active_index
-        self._establish_links(**key_args)
-
-    @property
-    def i_format(self) -> bpy.types.NodeSocketString:
-        """Input socket: Format"""
-        return self._input("Format")
-
-    @property
-    def i_input_socket(self) -> NodeSocket:
-        """Input socket:"""
-        return self._input("__extend__")
-
-    @property
-    def o_string(self) -> bpy.types.NodeSocketString:
-        """Output socket: String"""
-        return self._output("String")
-
-    @property
-    def active_index(self) -> int:
-        return self.node.active_index
-
-    @active_index.setter
-    def active_index(self, value: int):
-        self.node.active_index = value
-
-
-class HashValue(NodeBuilder):
-    """Generate a randomized integer using the given input value as a seed"""
-
-    name = "FunctionNodeHashValue"
-    node: bpy.types.FunctionNodeHashValue
-
-    def __init__(
-        self,
-        value: int | LINKABLE | None = 0,
-        seed: int | LINKABLE | None = 0,
-        data_type: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "VECTOR",
-            "RGBA",
-            "ROTATION",
-            "MATRIX",
-            "STRING",
-            "MENU",
-            "SHADER",
-            "OBJECT",
-            "IMAGE",
-            "GEOMETRY",
-            "COLLECTION",
-            "TEXTURE",
-            "MATERIAL",
-            "BUNDLE",
-            "CLOSURE",
-        ] = "INT",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Value": value, "Seed": seed}
-        key_args.update(kwargs)
-        self.data_type = data_type
-        self._establish_links(**key_args)
-
-    @property
-    def i_value(self) -> bpy.types.NodeSocketInt:
-        """Input socket: Value"""
-        return self._input("Value")
-
-    @property
-    def i_seed(self) -> bpy.types.NodeSocketInt:
-        """Input socket: Seed"""
-        return self._input("Seed")
-
-    @property
-    def o_hash(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Hash"""
-        return self._output("Hash")
-
-    @property
-    def data_type(
-        self,
-    ) -> Literal[
-        "FLOAT",
-        "INT",
-        "BOOLEAN",
-        "VECTOR",
-        "RGBA",
-        "ROTATION",
-        "MATRIX",
-        "STRING",
-        "MENU",
-        "SHADER",
-        "OBJECT",
-        "IMAGE",
-        "GEOMETRY",
-        "COLLECTION",
-        "TEXTURE",
-        "MATERIAL",
-        "BUNDLE",
-        "CLOSURE",
-    ]:
-        return self.node.data_type
-
-    @data_type.setter
-    def data_type(
-        self,
-        value: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "VECTOR",
-            "RGBA",
-            "ROTATION",
-            "MATRIX",
-            "STRING",
-            "MENU",
-            "SHADER",
-            "OBJECT",
-            "IMAGE",
-            "GEOMETRY",
-            "COLLECTION",
-            "TEXTURE",
-            "MATERIAL",
-            "BUNDLE",
-            "CLOSURE",
-        ],
-    ):
-        self.node.data_type = value
-
-
-class IntegerMath(NodeBuilder):
-    """Perform various math operations on the given integer inputs"""
-
-    name = "FunctionNodeIntegerMath"
-    node: bpy.types.FunctionNodeIntegerMath
-
-    def __init__(
-        self,
-        value: int | LINKABLE | None = 0,
-        value_001: int | LINKABLE | None = 0,
-        operation: Literal[
-            "ADD",
-            "SUBTRACT",
-            "MULTIPLY",
-            "DIVIDE",
-            "MULTIPLY_ADD",
-            "ABSOLUTE",
-            "NEGATE",
-            "POWER",
-            "MINIMUM",
-            "MAXIMUM",
-            "SIGN",
-            "DIVIDE_ROUND",
-            "DIVIDE_FLOOR",
-            "DIVIDE_CEIL",
-            "FLOORED_MODULO",
-            "MODULO",
-            "GCD",
-            "LCM",
-        ] = "ADD",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Value": value, "Value_001": value_001}
-        key_args.update(kwargs)
-        self.operation = operation
-        self._establish_links(**key_args)
-
-    @classmethod
-    def add(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Add'."""
-        return cls(operation="ADD", value=value, value_001=value_001)
-
-    @classmethod
-    def subtract(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Subtract'."""
-        return cls(operation="SUBTRACT", value=value, value_001=value_001)
-
-    @classmethod
-    def multiply(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Multiply'."""
-        return cls(operation="MULTIPLY", value=value, value_001=value_001)
-
-    @classmethod
-    def divide(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Divide'."""
-        return cls(operation="DIVIDE", value=value, value_001=value_001)
-
-    @classmethod
-    def multiplyadd(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Multiply Add'."""
-        return cls(operation="MULTIPLY_ADD", value=value, value_001=value_001)
-
-    @classmethod
-    def absolute(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Absolute'."""
-        return cls(operation="ABSOLUTE", value=value, value_001=value_001)
-
-    @classmethod
-    def negate(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Negate'."""
-        return cls(operation="NEGATE", value=value, value_001=value_001)
-
-    @classmethod
-    def power(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Power'."""
-        return cls(operation="POWER", value=value, value_001=value_001)
-
-    @classmethod
-    def minimum(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Minimum'."""
-        return cls(operation="MINIMUM", value=value, value_001=value_001)
-
-    @classmethod
-    def maximum(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Maximum'."""
-        return cls(operation="MAXIMUM", value=value, value_001=value_001)
-
-    @classmethod
-    def sign(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Sign'."""
-        return cls(operation="SIGN", value=value, value_001=value_001)
-
-    @classmethod
-    def divideround(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Divide Round'."""
-        return cls(operation="DIVIDE_ROUND", value=value, value_001=value_001)
-
-    @classmethod
-    def dividefloor(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Divide Floor'."""
-        return cls(operation="DIVIDE_FLOOR", value=value, value_001=value_001)
-
-    @classmethod
-    def divideceil(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Divide Ceiling'."""
-        return cls(operation="DIVIDE_CEIL", value=value, value_001=value_001)
-
-    @classmethod
-    def flooredmodulo(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Floored Modulo'."""
-        return cls(operation="FLOORED_MODULO", value=value, value_001=value_001)
-
-    @classmethod
-    def modulo(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Modulo'."""
-        return cls(operation="MODULO", value=value, value_001=value_001)
-
-    @classmethod
-    def gcd(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Greatest Common Divisor'."""
-        return cls(operation="GCD", value=value, value_001=value_001)
-
-    @classmethod
-    def lcm(
-        cls, value: int | LINKABLE | None = 0, value_001: int | LINKABLE | None = 0
-    ) -> "IntegerMath":
-        """Create Integer Math with operation 'Least Common Multiple'."""
-        return cls(operation="LCM", value=value, value_001=value_001)
-
-    @property
-    def i_value(self) -> bpy.types.NodeSocketInt:
-        """Input socket: Value"""
-        return self._input("Value")
-
-    @property
-    def i_value_001(self) -> bpy.types.NodeSocketInt:
-        """Input socket: Value"""
-        return self._input("Value_001")
-
-    @property
-    def o_value(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Value"""
-        return self._output("Value")
-
-    @property
-    def operation(
-        self,
-    ) -> Literal[
-        "ADD",
-        "SUBTRACT",
-        "MULTIPLY",
-        "DIVIDE",
-        "MULTIPLY_ADD",
-        "ABSOLUTE",
-        "NEGATE",
-        "POWER",
-        "MINIMUM",
-        "MAXIMUM",
-        "SIGN",
-        "DIVIDE_ROUND",
-        "DIVIDE_FLOOR",
-        "DIVIDE_CEIL",
-        "FLOORED_MODULO",
-        "MODULO",
-        "GCD",
-        "LCM",
-    ]:
-        return self.node.operation
-
-    @operation.setter
-    def operation(
-        self,
-        value: Literal[
-            "ADD",
-            "SUBTRACT",
-            "MULTIPLY",
-            "DIVIDE",
-            "MULTIPLY_ADD",
-            "ABSOLUTE",
-            "NEGATE",
-            "POWER",
-            "MINIMUM",
-            "MAXIMUM",
-            "SIGN",
-            "DIVIDE_ROUND",
-            "DIVIDE_FLOOR",
-            "DIVIDE_CEIL",
-            "FLOORED_MODULO",
-            "MODULO",
-            "GCD",
-            "LCM",
-        ],
-    ):
-        self.node.operation = value
-
-
-class InvertMatrix(NodeBuilder):
-    """Compute the inverse of the given matrix, if one exists"""
-
-    name = "FunctionNodeInvertMatrix"
-    node: bpy.types.FunctionNodeInvertMatrix
-
-    def __init__(self, matrix: LINKABLE | None = None, **kwargs):
-        super().__init__()
-        key_args = {"Matrix": matrix}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_matrix(self) -> NodeSocket:
-        """Input socket: Matrix"""
-        return self._input("Matrix")
-
-    @property
-    def o_matrix(self) -> NodeSocket:
-        """Output socket: Matrix"""
-        return self._output("Matrix")
-
-    @property
-    def o_invertible(self) -> bpy.types.NodeSocketBool:
-        """Output socket: Invertible"""
-        return self._output("Invertible")
-
-
-class InvertRotation(NodeBuilder):
-    """Compute the inverse of the given rotation"""
-
-    name = "FunctionNodeInvertRotation"
-    node: bpy.types.FunctionNodeInvertRotation
-
-    def __init__(self, rotation: TYPE_INPUT_ROTATION = [0.0, 0.0, 0.0], **kwargs):
-        super().__init__()
-        key_args = {"Rotation": rotation}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Input socket: Rotation"""
-        return self._input("Rotation")
-
-    @property
-    def o_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Output socket: Rotation"""
-        return self._output("Rotation")
-
-
-class MatchString(NodeBuilder):
-    """Check if a given string exists within another string"""
-
-    name = "FunctionNodeMatchString"
-    node: bpy.types.FunctionNodeMatchString
-
-    def __init__(
-        self,
-        string: str | LINKABLE | None = "",
-        operation: LINKABLE | None = "Starts With",
-        key: str | LINKABLE | None = "",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"String": string, "Operation": operation, "Key": key}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_string(self) -> bpy.types.NodeSocketString:
-        """Input socket: String"""
-        return self._input("String")
-
-    @property
-    def i_operation(self) -> NodeSocket:
-        """Input socket: Operation"""
-        return self._input("Operation")
-
-    @property
-    def i_key(self) -> bpy.types.NodeSocketString:
-        """Input socket: Key"""
-        return self._input("Key")
-
-    @property
-    def o_result(self) -> bpy.types.NodeSocketBool:
-        """Output socket: Result"""
-        return self._output("Result")
-
-
-class MatrixDeterminant(NodeBuilder):
-    """Compute the determinant of the given matrix"""
-
-    name = "FunctionNodeMatrixDeterminant"
-    node: bpy.types.FunctionNodeMatrixDeterminant
-
-    def __init__(self, matrix: LINKABLE | None = None, **kwargs):
-        super().__init__()
-        key_args = {"Matrix": matrix}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_matrix(self) -> NodeSocket:
-        """Input socket: Matrix"""
-        return self._input("Matrix")
-
-    @property
-    def o_determinant(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Determinant"""
-        return self._output("Determinant")
-
-
-class MultiplyMatrices(NodeBuilder):
-    """Perform a matrix multiplication on two input matrices"""
-
-    name = "FunctionNodeMatrixMultiply"
-    node: bpy.types.FunctionNodeMatrixMultiply
-
-    def __init__(
-        self,
-        matrix: LINKABLE | None = None,
-        matrix_001: LINKABLE | None = None,
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Matrix": matrix, "Matrix_001": matrix_001}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_matrix(self) -> NodeSocket:
-        """Input socket: Matrix"""
-        return self._input("Matrix")
-
-    @property
-    def i_matrix_001(self) -> NodeSocket:
-        """Input socket: Matrix"""
-        return self._input("Matrix_001")
-
-    @property
-    def o_matrix(self) -> NodeSocket:
-        """Output socket: Matrix"""
-        return self._output("Matrix")
-
-
-class ProjectPoint(NodeBuilder):
-    """Project a point using a matrix, using location, rotation, scale, and perspective divide"""
-
-    name = "FunctionNodeProjectPoint"
-    node: bpy.types.FunctionNodeProjectPoint
-
-    def __init__(
-        self,
-        vector: LINKABLE | None = [0.0, 0.0, 0.0],
-        transform: LINKABLE | None = None,
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Vector": vector, "Transform": transform}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_vector(self) -> NodeSocket:
-        """Input socket: Vector"""
-        return self._input("Vector")
-
-    @property
-    def i_transform(self) -> NodeSocket:
-        """Input socket: Transform"""
-        return self._input("Transform")
-
-    @property
-    def o_vector(self) -> NodeSocket:
-        """Output socket: Vector"""
-        return self._output("Vector")
-
-
-class QuaternionToRotation(NodeBuilder):
-    """Build a rotation from quaternion components"""
-
-    name = "FunctionNodeQuaternionToRotation"
-    node: bpy.types.FunctionNodeQuaternionToRotation
-
-    def __init__(
-        self,
-        w: float | LINKABLE | None = 1.0,
-        x: float | LINKABLE | None = 0.0,
-        y: float | LINKABLE | None = 0.0,
-        z: float | LINKABLE | None = 0.0,
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"W": w, "X": x, "Y": y, "Z": z}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_w(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: W"""
-        return self._input("W")
-
-    @property
-    def i_x(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: X"""
-        return self._input("X")
-
-    @property
-    def i_y(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Y"""
-        return self._input("Y")
-
-    @property
-    def i_z(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Z"""
-        return self._input("Z")
-
-    @property
-    def o_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Output socket: Rotation"""
-        return self._output("Rotation")
-
-
-class ReplaceString(NodeBuilder):
-    """Replace a given string segment with another"""
-
-    name = "FunctionNodeReplaceString"
-    node: bpy.types.FunctionNodeReplaceString
-
-    def __init__(
-        self,
-        string: str | LINKABLE | None = "",
-        find: str | LINKABLE | None = "",
-        replace: str | LINKABLE | None = "",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"String": string, "Find": find, "Replace": replace}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_string(self) -> bpy.types.NodeSocketString:
-        """Input socket: String"""
-        return self._input("String")
-
-    @property
-    def i_find(self) -> bpy.types.NodeSocketString:
-        """Input socket: Find"""
-        return self._input("Find")
-
-    @property
-    def i_replace(self) -> bpy.types.NodeSocketString:
-        """Input socket: Replace"""
-        return self._input("Replace")
-
-    @property
-    def o_string(self) -> bpy.types.NodeSocketString:
-        """Output socket: String"""
-        return self._output("String")
-
-
-class RotateEuler(NodeBuilder):
-    """Apply a secondary Euler rotation to a given Euler rotation"""
-
-    name = "FunctionNodeRotateEuler"
-    node: bpy.types.FunctionNodeRotateEuler
-
-    def __init__(
-        self,
-        rotation: LINKABLE | None = [0.0, 0.0, 0.0],
-        rotate_by: LINKABLE | None = [0.0, 0.0, 0.0],
-        rotation_type: Literal["AXIS_ANGLE", "EULER"] = "EULER",
-        space: Literal["OBJECT", "LOCAL"] = "OBJECT",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Rotation": rotation, "Rotate By": rotate_by}
-        key_args.update(kwargs)
-        self.rotation_type = rotation_type
-        self.space = space
-        self._establish_links(**key_args)
-
-    @property
-    def i_rotation(self) -> NodeSocket:
-        """Input socket: Rotation"""
-        return self._input("Rotation")
-
-    @property
-    def i_rotate_by(self) -> NodeSocket:
-        """Input socket: Rotate By"""
-        return self._input("Rotate By")
-
-    @property
-    def o_rotation(self) -> bpy.types.NodeSocketVector:
-        """Output socket: Rotation"""
-        return self._output("Rotation")
-
-    @property
-    def rotation_type(self) -> Literal["AXIS_ANGLE", "EULER"]:
-        return self.node.rotation_type
-
-    @rotation_type.setter
-    def rotation_type(self, value: Literal["AXIS_ANGLE", "EULER"]):
-        self.node.rotation_type = value
-
-    @property
-    def space(self) -> Literal["OBJECT", "LOCAL"]:
-        return self.node.space
-
-    @space.setter
-    def space(self, value: Literal["OBJECT", "LOCAL"]):
-        self.node.space = value
-
-
-class RotateRotation(NodeBuilder):
-    """Apply a secondary rotation to a given rotation value"""
-
-    name = "FunctionNodeRotateRotation"
-    node: bpy.types.FunctionNodeRotateRotation
-
-    def __init__(
-        self,
-        rotation: TYPE_INPUT_ROTATION = [0.0, 0.0, 0.0],
-        rotate_by: TYPE_INPUT_ROTATION = [0.0, 0.0, 0.0],
-        rotation_space: Literal["GLOBAL", "LOCAL"] = "GLOBAL",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Rotation": rotation, "Rotate By": rotate_by}
-        key_args.update(kwargs)
-        self.rotation_space = rotation_space
-        self._establish_links(**key_args)
-
-    @property
-    def i_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Input socket: Rotation"""
-        return self._input("Rotation")
-
-    @property
-    def i_rotate_by(self) -> bpy.types.NodeSocketRotation:
-        """Input socket: Rotate By"""
-        return self._input("Rotate By")
-
-    @property
-    def o_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Output socket: Rotation"""
-        return self._output("Rotation")
-
-    @property
-    def rotation_space(self) -> Literal["GLOBAL", "LOCAL"]:
-        return self.node.rotation_space
-
-    @rotation_space.setter
-    def rotation_space(self, value: Literal["GLOBAL", "LOCAL"]):
-        self.node.rotation_space = value
-
-
-class RotateVector(NodeBuilder):
-    """Apply a rotation to a given vector"""
-
-    name = "FunctionNodeRotateVector"
-    node: bpy.types.FunctionNodeRotateVector
-
-    def __init__(
-        self,
-        vector: TYPE_INPUT_VECTOR = [0.0, 0.0, 0.0],
-        rotation: TYPE_INPUT_ROTATION = [0.0, 0.0, 0.0],
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Vector": vector, "Rotation": rotation}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_vector(self) -> bpy.types.NodeSocketVector:
-        """Input socket: Vector"""
-        return self._input("Vector")
-
-    @property
-    def i_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Input socket: Rotation"""
-        return self._input("Rotation")
-
-    @property
-    def o_vector(self) -> bpy.types.NodeSocketVector:
-        """Output socket: Vector"""
-        return self._output("Vector")
-
-
-class RotationToAxisAngle(NodeBuilder):
-    """Convert a rotation to axis angle components"""
-
-    name = "FunctionNodeRotationToAxisAngle"
-    node: bpy.types.FunctionNodeRotationToAxisAngle
-
-    def __init__(self, rotation: TYPE_INPUT_ROTATION = [0.0, 0.0, 0.0], **kwargs):
-        super().__init__()
-        key_args = {"Rotation": rotation}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Input socket: Rotation"""
-        return self._input("Rotation")
-
-    @property
-    def o_axis(self) -> bpy.types.NodeSocketVector:
-        """Output socket: Axis"""
-        return self._output("Axis")
-
-    @property
-    def o_angle(self) -> NodeSocket:
-        """Output socket: Angle"""
-        return self._output("Angle")
-
-
-class RotationToEuler(NodeBuilder):
-    """Convert a standard rotation value to an Euler rotation"""
-
-    name = "FunctionNodeRotationToEuler"
-    node: bpy.types.FunctionNodeRotationToEuler
-
-    def __init__(self, rotation: TYPE_INPUT_ROTATION = [0.0, 0.0, 0.0], **kwargs):
-        super().__init__()
-        key_args = {"Rotation": rotation}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Input socket: Rotation"""
-        return self._input("Rotation")
-
-    @property
-    def o_euler(self) -> NodeSocket:
-        """Output socket: Euler"""
-        return self._output("Euler")
-
-
-class RotationToQuaternion(NodeBuilder):
-    """Retrieve the quaternion components representing a rotation"""
-
-    name = "FunctionNodeRotationToQuaternion"
-    node: bpy.types.FunctionNodeRotationToQuaternion
-
-    def __init__(self, rotation: TYPE_INPUT_ROTATION = [0.0, 0.0, 0.0], **kwargs):
-        super().__init__()
-        key_args = {"Rotation": rotation}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Input socket: Rotation"""
-        return self._input("Rotation")
-
-    @property
-    def o_w(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: W"""
-        return self._output("W")
-
-    @property
-    def o_x(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: X"""
-        return self._output("X")
-
-    @property
-    def o_y(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Y"""
-        return self._output("Y")
-
-    @property
-    def o_z(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Z"""
-        return self._output("Z")
-
-
-class SeparateColor(NodeBuilder):
-    """Split a color into separate channels, based on a particular color model"""
-
-    name = "FunctionNodeSeparateColor"
-    node: bpy.types.FunctionNodeSeparateColor
-
-    def __init__(
-        self,
-        color: tuple[float, float, float, float] | LINKABLE | None = [
-            1.0,
-            1.0,
-            1.0,
-            1.0,
-        ],
-        mode: Literal["RGB", "HSV", "HSL"] = "RGB",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Color": color}
-        key_args.update(kwargs)
-        self.mode = mode
-        self._establish_links(**key_args)
-
-    @property
-    def i_color(self) -> bpy.types.NodeSocketColor:
-        """Input socket: Color"""
-        return self._input("Color")
-
-    @property
-    def o_red(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Red"""
-        return self._output("Red")
-
-    @property
-    def o_green(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Green"""
-        return self._output("Green")
-
-    @property
-    def o_blue(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Blue"""
-        return self._output("Blue")
-
-    @property
-    def o_alpha(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Alpha"""
-        return self._output("Alpha")
-
-    @property
-    def mode(self) -> Literal["RGB", "HSV", "HSL"]:
-        return self.node.mode
-
-    @mode.setter
-    def mode(self, value: Literal["RGB", "HSV", "HSL"]):
-        self.node.mode = value
-
-
-class SeparateMatrix(NodeBuilder):
-    """Split a 4x4 matrix into its individual values"""
-
-    name = "FunctionNodeSeparateMatrix"
-    node: bpy.types.FunctionNodeSeparateMatrix
-
-    def __init__(self, matrix: LINKABLE | None = None, **kwargs):
-        super().__init__()
-        key_args = {"Matrix": matrix}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_matrix(self) -> NodeSocket:
-        """Input socket: Matrix"""
-        return self._input("Matrix")
-
-    @property
-    def o_column_1_row_1(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 1 Row 1"""
-        return self._output("Column 1 Row 1")
-
-    @property
-    def o_column_1_row_2(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 1 Row 2"""
-        return self._output("Column 1 Row 2")
-
-    @property
-    def o_column_1_row_3(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 1 Row 3"""
-        return self._output("Column 1 Row 3")
-
-    @property
-    def o_column_1_row_4(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 1 Row 4"""
-        return self._output("Column 1 Row 4")
-
-    @property
-    def o_column_2_row_1(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 2 Row 1"""
-        return self._output("Column 2 Row 1")
-
-    @property
-    def o_column_2_row_2(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 2 Row 2"""
-        return self._output("Column 2 Row 2")
-
-    @property
-    def o_column_2_row_3(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 2 Row 3"""
-        return self._output("Column 2 Row 3")
-
-    @property
-    def o_column_2_row_4(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 2 Row 4"""
-        return self._output("Column 2 Row 4")
-
-    @property
-    def o_column_3_row_1(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 3 Row 1"""
-        return self._output("Column 3 Row 1")
-
-    @property
-    def o_column_3_row_2(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 3 Row 2"""
-        return self._output("Column 3 Row 2")
-
-    @property
-    def o_column_3_row_3(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 3 Row 3"""
-        return self._output("Column 3 Row 3")
-
-    @property
-    def o_column_3_row_4(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 3 Row 4"""
-        return self._output("Column 3 Row 4")
-
-    @property
-    def o_column_4_row_1(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 4 Row 1"""
-        return self._output("Column 4 Row 1")
-
-    @property
-    def o_column_4_row_2(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 4 Row 2"""
-        return self._output("Column 4 Row 2")
-
-    @property
-    def o_column_4_row_3(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 4 Row 3"""
-        return self._output("Column 4 Row 3")
-
-    @property
-    def o_column_4_row_4(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Column 4 Row 4"""
-        return self._output("Column 4 Row 4")
-
-
-class SeparateTransform(NodeBuilder):
-    """Split a transformation matrix into a translation vector, a rotation, and a scale vector"""
-
-    name = "FunctionNodeSeparateTransform"
-    node: bpy.types.FunctionNodeSeparateTransform
-
-    def __init__(self, transform: LINKABLE | None = None, **kwargs):
-        super().__init__()
-        key_args = {"Transform": transform}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_transform(self) -> NodeSocket:
-        """Input socket: Transform"""
-        return self._input("Transform")
-
-    @property
-    def o_translation(self) -> NodeSocket:
-        """Output socket: Translation"""
-        return self._output("Translation")
-
-    @property
-    def o_rotation(self) -> bpy.types.NodeSocketRotation:
-        """Output socket: Rotation"""
-        return self._output("Rotation")
-
-    @property
-    def o_scale(self) -> NodeSocket:
-        """Output socket: Scale"""
-        return self._output("Scale")
-
-
-class SliceString(NodeBuilder):
-    """Extract a string segment from a larger string"""
-
-    name = "FunctionNodeSliceString"
-    node: bpy.types.FunctionNodeSliceString
-
-    def __init__(
-        self,
-        string: str | LINKABLE | None = "",
-        position: int | LINKABLE | None = 0,
-        length: int | LINKABLE | None = 10,
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"String": string, "Position": position, "Length": length}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_string(self) -> bpy.types.NodeSocketString:
-        """Input socket: String"""
-        return self._input("String")
-
-    @property
-    def i_position(self) -> bpy.types.NodeSocketInt:
-        """Input socket: Position"""
-        return self._input("Position")
-
-    @property
-    def i_length(self) -> bpy.types.NodeSocketInt:
-        """Input socket: Length"""
-        return self._input("Length")
-
-    @property
-    def o_string(self) -> bpy.types.NodeSocketString:
-        """Output socket: String"""
-        return self._output("String")
-
-
-class StringLength(NodeBuilder):
-    """Output the number of characters in the given string"""
-
-    name = "FunctionNodeStringLength"
-    node: bpy.types.FunctionNodeStringLength
-
-    def __init__(self, string: str | LINKABLE | None = "", **kwargs):
-        super().__init__()
-        key_args = {"String": string}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_string(self) -> bpy.types.NodeSocketString:
-        """Input socket: String"""
-        return self._input("String")
-
-    @property
-    def o_length(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Length"""
-        return self._output("Length")
-
-
-class StringToValue(NodeBuilder):
-    """Derive a numeric value from a given string representation"""
-
-    name = "FunctionNodeStringToValue"
-    node: bpy.types.FunctionNodeStringToValue
-
-    def __init__(
-        self,
-        string: str | LINKABLE | None = "",
-        data_type: Literal["FLOAT", "INT"] = "FLOAT",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"String": string}
-        key_args.update(kwargs)
-        self.data_type = data_type
-        self._establish_links(**key_args)
-
-    @property
-    def i_string(self) -> bpy.types.NodeSocketString:
-        """Input socket: String"""
-        return self._input("String")
-
-    @property
-    def o_value(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Value"""
-        return self._output("Value")
-
-    @property
-    def o_length(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Length"""
-        return self._output("Length")
-
-    @property
-    def data_type(self) -> Literal["FLOAT", "INT"]:
-        return self.node.data_type
-
-    @data_type.setter
-    def data_type(self, value: Literal["FLOAT", "INT"]):
-        self.node.data_type = value
-
-
-class TransformDirection(NodeBuilder):
-    """Apply a transformation matrix (excluding translation) to the given vector"""
-
-    name = "FunctionNodeTransformDirection"
-    node: bpy.types.FunctionNodeTransformDirection
-
-    def __init__(
-        self,
-        direction: LINKABLE | None = [0.0, 0.0, 0.0],
-        transform: LINKABLE | None = None,
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Direction": direction, "Transform": transform}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_direction(self) -> NodeSocket:
-        """Input socket: Direction"""
-        return self._input("Direction")
-
-    @property
-    def i_transform(self) -> NodeSocket:
-        """Input socket: Transform"""
-        return self._input("Transform")
-
-    @property
-    def o_direction(self) -> NodeSocket:
-        """Output socket: Direction"""
-        return self._output("Direction")
-
-
-class TransformPoint(NodeBuilder):
-    """Apply a transformation matrix to the given vector"""
-
-    name = "FunctionNodeTransformPoint"
-    node: bpy.types.FunctionNodeTransformPoint
-
-    def __init__(
-        self,
-        vector: LINKABLE | None = [0.0, 0.0, 0.0],
-        transform: LINKABLE | None = None,
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Vector": vector, "Transform": transform}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_vector(self) -> NodeSocket:
-        """Input socket: Vector"""
-        return self._input("Vector")
-
-    @property
-    def i_transform(self) -> NodeSocket:
-        """Input socket: Transform"""
-        return self._input("Transform")
-
-    @property
-    def o_vector(self) -> NodeSocket:
-        """Output socket: Vector"""
-        return self._output("Vector")
-
-
-class TransposeMatrix(NodeBuilder):
-    """Flip a matrix over its diagonal, turning columns into rows and vice-versa"""
-
-    name = "FunctionNodeTransposeMatrix"
-    node: bpy.types.FunctionNodeTransposeMatrix
-
-    def __init__(self, matrix: LINKABLE | None = None, **kwargs):
-        super().__init__()
-        key_args = {"Matrix": matrix}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_matrix(self) -> NodeSocket:
-        """Input socket: Matrix"""
-        return self._input("Matrix")
-
-    @property
-    def o_matrix(self) -> NodeSocket:
-        """Output socket: Matrix"""
-        return self._output("Matrix")
-
-
-class ValueToString(NodeBuilder):
-    """Generate a string representation of the given input value"""
-
-    name = "FunctionNodeValueToString"
-    node: bpy.types.FunctionNodeValueToString
-
-    def __init__(
-        self,
-        value: float | LINKABLE | None = 0.0,
-        decimals: int | LINKABLE | None = 0,
-        data_type: Literal["FLOAT", "INT"] = "FLOAT",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Value": value, "Decimals": decimals}
-        key_args.update(kwargs)
-        self.data_type = data_type
-        self._establish_links(**key_args)
-
-    @property
-    def i_value(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Value"""
-        return self._input("Value")
-
-    @property
-    def i_decimals(self) -> bpy.types.NodeSocketInt:
-        """Input socket: Decimals"""
-        return self._input("Decimals")
-
-    @property
-    def o_string(self) -> bpy.types.NodeSocketString:
-        """Output socket: String"""
-        return self._output("String")
-
-    @property
-    def data_type(self) -> Literal["FLOAT", "INT"]:
-        return self.node.data_type
-
-    @data_type.setter
-    def data_type(self, value: Literal["FLOAT", "INT"]):
-        self.node.data_type = value
-
-
-class Clamp(NodeBuilder):
-    """Clamp a value between a minimum and a maximum"""
-
-    name = "ShaderNodeClamp"
-    node: bpy.types.ShaderNodeClamp
-
-    def __init__(
-        self,
-        value: float | LINKABLE | None = 1.0,
-        min: float | LINKABLE | None = 0.0,
-        max: float | LINKABLE | None = 1.0,
-        clamp_type: Literal["MINMAX", "RANGE"] = "MINMAX",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Value": value, "Min": min, "Max": max}
-        key_args.update(kwargs)
-        self.clamp_type = clamp_type
-        self._establish_links(**key_args)
-
-    @property
-    def i_value(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Value"""
-        return self._input("Value")
-
-    @property
-    def i_min(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Min"""
-        return self._input("Min")
-
-    @property
-    def i_max(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Max"""
-        return self._input("Max")
-
-    @property
-    def o_result(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Result"""
-        return self._output("Result")
-
-    @property
-    def clamp_type(self) -> Literal["MINMAX", "RANGE"]:
-        return self.node.clamp_type
-
-    @clamp_type.setter
-    def clamp_type(self, value: Literal["MINMAX", "RANGE"]):
-        self.node.clamp_type = value
-
-
-class Gamma(NodeBuilder):
-    """Apply a gamma correction"""
-
-    name = "ShaderNodeGamma"
-    node: bpy.types.ShaderNodeGamma
-
-    def __init__(
-        self,
-        color: tuple[float, float, float, float] | LINKABLE | None = [
-            1.0,
-            1.0,
-            1.0,
-            1.0,
-        ],
-        gamma: float | LINKABLE | None = 1.0,
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Color": color, "Gamma": gamma}
-        key_args.update(kwargs)
-
-        self._establish_links(**key_args)
-
-    @property
-    def i_color(self) -> bpy.types.NodeSocketColor:
-        """Input socket: Color"""
-        return self._input("Color")
-
-    @property
-    def i_gamma(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Gamma"""
-        return self._input("Gamma")
-
-    @property
-    def o_color(self) -> bpy.types.NodeSocketColor:
-        """Output socket: Color"""
-        return self._output("Color")
-
-
-class MapRange(NodeBuilder):
-    """Remap a value from a range to a target range"""
-
-    name = "ShaderNodeMapRange"
-    node: bpy.types.ShaderNodeMapRange
-
-    def __init__(
-        self,
-        value: float | LINKABLE | None = 1.0,
-        from_min: float | LINKABLE | None = 0.0,
-        from_max: float | LINKABLE | None = 1.0,
-        to_min: float | LINKABLE | None = 0.0,
-        to_max: float | LINKABLE | None = 1.0,
-        clamp: bool = False,
-        interpolation_type: Literal[
-            "LINEAR", "STEPPED", "SMOOTHSTEP", "SMOOTHERSTEP"
-        ] = "LINEAR",
-        data_type: Literal["FLOAT", "FLOAT_VECTOR"] = "FLOAT",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {
-            "Value": value,
-            "From Min": from_min,
-            "From Max": from_max,
-            "To Min": to_min,
-            "To Max": to_max,
-        }
-        key_args.update(kwargs)
-        self.clamp = clamp
-        self.interpolation_type = interpolation_type
-        self.data_type = data_type
-        self._establish_links(**key_args)
-
-    @property
-    def i_value(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Value"""
-        return self._input("Value")
-
-    @property
-    def i_from_min(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: From Min"""
-        return self._input("From Min")
-
-    @property
-    def i_from_max(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: From Max"""
-        return self._input("From Max")
-
-    @property
-    def i_to_min(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: To Min"""
-        return self._input("To Min")
-
-    @property
-    def i_to_max(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: To Max"""
-        return self._input("To Max")
-
-    @property
-    def o_result(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Result"""
-        return self._output("Result")
-
-    @property
-    def clamp(self) -> bool:
-        return self.node.clamp
-
-    @clamp.setter
-    def clamp(self, value: bool):
-        self.node.clamp = value
-
-    @property
-    def interpolation_type(
-        self,
-    ) -> Literal["LINEAR", "STEPPED", "SMOOTHSTEP", "SMOOTHERSTEP"]:
-        return self.node.interpolation_type
-
-    @interpolation_type.setter
-    def interpolation_type(
-        self, value: Literal["LINEAR", "STEPPED", "SMOOTHSTEP", "SMOOTHERSTEP"]
-    ):
-        self.node.interpolation_type = value
-
-    @property
-    def data_type(self) -> Literal["FLOAT", "FLOAT_VECTOR"]:
-        return self.node.data_type
-
-    @data_type.setter
-    def data_type(self, value: Literal["FLOAT", "FLOAT_VECTOR"]):
-        self.node.data_type = value