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

nodebpy/nodes/attribute.py

@@ -3,114 +3,128 @@ from typing import Literal
 import bpy
 
 from ..builder import NodeBuilder, SocketLinker
-from .types import (
-    LINKABLE,
+from ..types import (
     TYPE_INPUT_BOOLEAN,
     TYPE_INPUT_GEOMETRY,
     TYPE_INPUT_INT,
     TYPE_INPUT_MENU,
     TYPE_INPUT_STRING,
+    TYPE_INPUT_ROTATION,
+    TYPE_INPUT_COLOR,
     TYPE_INPUT_VALUE,
-    _AttributeDataTypes,
-    _AttributeDomains,
-    _StoreNamedAttributeTypes,
+    TYPE_INPUT_VECTOR,
 )
 
 
-class DomainSize(NodeBuilder):
-    """Retrieve the number of elements in a geometry for each attribute domain"""
+class BlurAttribute(NodeBuilder):
+    """Mix attribute values of neighboring elements"""
 
-    name = "GeometryNodeAttributeDomainSize"
-    node: bpy.types.GeometryNodeAttributeDomainSize
+    _bl_idname = "GeometryNodeBlurAttribute"
+    node: bpy.types.GeometryNodeBlurAttribute
 
     def __init__(
         self,
-        geometry: TYPE_INPUT_GEOMETRY = None,
+        value: TYPE_INPUT_VALUE = 0.0,
+        iterations: TYPE_INPUT_INT = 1,
+        weight: TYPE_INPUT_VALUE = 1.0,
         *,
-        component: Literal[
-            "MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"
-        ] = "MESH",
+        data_type: Literal["FLOAT", "INT", "FLOAT_VECTOR", "FLOAT_COLOR"] = "FLOAT",
     ):
         super().__init__()
-        key_args = {"Geometry": geometry}
-        self.component = component
+        key_args = {"Value": value, "Iterations": iterations, "Weight": weight}
+        self.data_type = data_type
         self._establish_links(**key_args)
 
-    @property
-    def i_geometry(self) -> SocketLinker:
-        """Input socket: Geometry"""
-        return self._input("Geometry")
+    @classmethod
+    def float(
+        cls,
+        value: TYPE_INPUT_VALUE = 0.0,
+        iterations: TYPE_INPUT_INT = 1,
+        weight: TYPE_INPUT_VALUE = 1.0,
+    ) -> "BlurAttribute":
+        """Create Blur Attribute with operation 'Float'."""
+        return cls(data_type="FLOAT", value=value, iterations=iterations, weight=weight)
+
+    @classmethod
+    def integer(
+        cls,
+        value: TYPE_INPUT_INT = 0,
+        iterations: TYPE_INPUT_INT = 1,
+        weight: TYPE_INPUT_VALUE = 1.0,
+    ) -> "BlurAttribute":
+        """Create Blur Attribute with operation 'Integer'."""
+        return cls(data_type="INT", value=value, iterations=iterations, weight=weight)
+
+    @classmethod
+    def vector(
+        cls,
+        value: TYPE_INPUT_VECTOR = None,
+        iterations: TYPE_INPUT_INT = 1,
+        weight: TYPE_INPUT_VALUE = 1.0,
+    ) -> "BlurAttribute":
+        """Create Blur Attribute with operation 'Vector'."""
+        return cls(
+            data_type="FLOAT_VECTOR", value=value, iterations=iterations, weight=weight
+        )
+
+    @classmethod
+    def color(
+        cls,
+        value: TYPE_INPUT_COLOR = None,
+        iterations: TYPE_INPUT_INT = 1,
+        weight: TYPE_INPUT_VALUE = 1.0,
+    ) -> "BlurAttribute":
+        """Create Blur Attribute with operation 'Color'."""
+        return cls(
+            data_type="FLOAT_COLOR", value=value, iterations=iterations, weight=weight
+        )
 
     @property
-    def o_point_count(self) -> SocketLinker:
-        """Output socket: Point Count"""
-        return self._output("Point Count")
+    def i_value(self) -> SocketLinker:
+        """Input socket: Value"""
+        return self._input("Value")
 
     @property
-    def o_edge_count(self) -> SocketLinker:
-        """Output socket: Edge Count"""
-        return self._output("Edge Count")
+    def i_iterations(self) -> SocketLinker:
+        """Input socket: Iterations"""
+        return self._input("Iterations")
 
     @property
-    def o_face_count(self) -> SocketLinker:
-        """Output socket: Face Count"""
-        return self._output("Face Count")
+    def i_weight(self) -> SocketLinker:
+        """Input socket: Weight"""
+        return self._input("Weight")
 
     @property
-    def o_face_corner_count(self) -> SocketLinker:
-        """Output socket: Face Corner Count"""
-        return self._output("Face Corner Count")
+    def o_value(self) -> SocketLinker:
+        """Output socket: Value"""
+        return self._output("Value")
 
     @property
-    def component(
-        self,
-    ) -> Literal["MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"]:
-        return self.node.component
+    def data_type(self) -> Literal["FLOAT", "INT", "FLOAT_VECTOR", "FLOAT_COLOR"]:
+        return self.node.data_type
 
-    @component.setter
-    def component(
-        self, value: Literal["MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"]
-    ):
-        match value:
-            case "MESH" | "POINTCLOUD" | "CURVE":
-                self._default_output_id = "Point Count"
-            case "INSTANCES":
-                self._default_output_id = "Instance Count"
-            case "GREASEPENCIL":
-                self._default_output_id = "Layer Count"
-        self.node.component = value
+    @data_type.setter
+    def data_type(self, value: Literal["FLOAT", "INT", "FLOAT_VECTOR", "FLOAT_COLOR"]):
+        self.node.data_type = value
 
 
-class AttributeStatistic(NodeBuilder):
-    """Calculate statistics about a data set from a field evaluated on a geometry"""
+class DomainSize(NodeBuilder):
+    """Retrieve the number of elements in a geometry for each attribute domain"""
 
-    name = "GeometryNodeAttributeStatistic"
-    node: bpy.types.GeometryNodeAttributeStatistic
+    _bl_idname = "GeometryNodeAttributeDomainSize"
+    node: bpy.types.GeometryNodeAttributeDomainSize
 
     def __init__(
         self,
         geometry: TYPE_INPUT_GEOMETRY = None,
-        selection: TYPE_INPUT_BOOLEAN = True,
-        attribute: LINKABLE = None,
         *,
-        data_type: Literal[
-            "FLOAT",
-            "FLOAT_VECTOR",
-        ] = "FLOAT",
-        domain: Literal[
-            "POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"
-        ] = "POINT",
-        **kwargs,
+        component: Literal[
+            "MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"
+        ] = "MESH",
     ):
         super().__init__()
-        key_args = {
-            "Geometry": geometry,
-            "Selection": selection,
-            "Attribute": attribute,
-        }
-        key_args.update(kwargs)
-        self.data_type = data_type
-        self.domain = domain
+        key_args = {"Geometry": geometry}
+        self.component = component
         self._establish_links(**key_args)
 
     @property
@@ -119,170 +133,68 @@ class AttributeStatistic(NodeBuilder):
         return self._input("Geometry")
 
     @property
-    def i_selection(self) -> SocketLinker:
-        """Input socket: Selection"""
-        return self._input("Selection")
-
-    @property
-    def i_attribute(self) -> SocketLinker:
-        """Input socket: Attribute"""
-        return self._input("Attribute")
-
-    @property
-    def o_mean(self) -> SocketLinker:
-        """Output socket: Mean"""
-        return self._output("Mean")
-
-    @property
-    def o_median(self) -> SocketLinker:
-        """Output socket: Median"""
-        return self._output("Median")
-
-    @property
-    def o_sum(self) -> SocketLinker:
-        """Output socket: Sum"""
-        return self._output("Sum")
-
-    @property
-    def o_min(self) -> SocketLinker:
-        """Output socket: Min"""
-        return self._output("Min")
-
-    @property
-    def o_max(self) -> SocketLinker:
-        """Output socket: Max"""
-        return self._output("Max")
-
-    @property
-    def o_range(self) -> SocketLinker:
-        """Output socket: Range"""
-        return self._output("Range")
-
-    @property
-    def o_standard_deviation(self) -> SocketLinker:
-        """Output socket: Standard Deviation"""
-        return self._output("Standard Deviation")
-
-    @property
-    def o_variance(self) -> SocketLinker:
-        """Output socket: Variance"""
-        return self._output("Variance")
+    def o_point_count(self) -> SocketLinker:
+        """Output socket: Point Count"""
+        return self._output("Point Count")
 
     @property
-    def data_type(
-        self,
-    ) -> Literal[
-        "FLOAT",
-        "FLOAT_VECTOR",
-    ]:
-        return self.node.data_type  # type: ignore
-
-    @data_type.setter
-    def data_type(
-        self,
-        value: Literal[
-            "FLOAT",
-            "FLOAT_VECTOR",
-        ],
-    ):
-        self.node.data_type = value
+    def o_edge_count(self) -> SocketLinker:
+        """Output socket: Edge Count"""
+        return self._output("Edge Count")
 
     @property
-    def domain(
-        self,
-    ) -> _AttributeDomains:
-        return self.node.domain
-
-    @domain.setter
-    def domain(
-        self,
-        value: _AttributeDomains,
-    ):
-        self.node.domain = value
-
-
-class BlurAttribute(NodeBuilder):
-    """Mix attribute values of neighboring elements"""
-
-    name = "GeometryNodeBlurAttribute"
-    node: bpy.types.GeometryNodeBlurAttribute
-
-    def __init__(
-        self,
-        value: LINKABLE = None,
-        iterations: TYPE_INPUT_INT = 1,
-        weight: TYPE_INPUT_VALUE = 1.0,
-        *,
-        data_type: Literal[
-            "FLOAT",
-            "INT",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-        ] = "FLOAT",
-    ):
-        super().__init__()
-        key_args = {"Value": value, "Iterations": iterations, "Weight": weight}
-        self.data_type = data_type
-        self._establish_links(**key_args)
+    def o_face_count(self) -> SocketLinker:
+        """Output socket: Face Count"""
+        return self._output("Face Count")
 
     @property
-    def i_value(self) -> SocketLinker:
-        """Input socket: Value"""
-        return self._input("Value")
+    def o_face_corner_count(self) -> SocketLinker:
+        """Output socket: Face Corner Count"""
+        return self._output("Face Corner Count")
 
     @property
-    def i_iterations(self) -> SocketLinker:
-        """Input socket: Iterations"""
-        return self._input("Iterations")
+    def o_spline_count(self) -> SocketLinker:
+        """Output socket: Spline Count"""
+        return self._output("Spline Count")
 
     @property
-    def i_weight(self) -> SocketLinker:
-        """Input socket: Weight"""
-        return self._input("Weight")
+    def o_instance_count(self) -> SocketLinker:
+        """Output socket: Instance Count"""
+        return self._output("Instance Count")
 
     @property
-    def o_value(self) -> SocketLinker:
-        """Output socket: Value"""
-        return self._output("Value")
+    def o_layer_count(self) -> SocketLinker:
+        """Output socket: Layer Count"""
+        return self._output("Layer Count")
 
     @property
-    def data_type(
+    def component(
         self,
-    ) -> Literal[
-        "FLOAT",
-        "INT",
-        "FLOAT_VECTOR",
-        "FLOAT_COLOR",
-    ]:
-        return self.node.data_type  # type: ignore
+    ) -> Literal["MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"]:
+        return self.node.component
 
-    @data_type.setter
-    def data_type(
-        self,
-        value: Literal[
-            "FLOAT",
-            "INT",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-        ],
+    @component.setter
+    def component(
+        self, value: Literal["MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"]
     ):
-        self.node.data_type = value
+        self.node.component = value
 
 
 class RemoveNamedAttribute(NodeBuilder):
     """Delete an attribute with a specified name from a geometry. Typically used to optimize performance"""
 
-    name = "GeometryNodeRemoveAttribute"
+    _bl_idname = "GeometryNodeRemoveAttribute"
     node: bpy.types.GeometryNodeRemoveAttribute
 
     def __init__(
         self,
         geometry: TYPE_INPUT_GEOMETRY = None,
-        pattern_mode: Literal["Exact", "Wildcard"] | TYPE_INPUT_MENU = "Exact",
+        pattern_mode: TYPE_INPUT_MENU = "Exact",
         name: TYPE_INPUT_STRING = "",
     ):
         super().__init__()
         key_args = {"Geometry": geometry, "Pattern Mode": pattern_mode, "Name": name}
+
         self._establish_links(**key_args)
 
     @property
@@ -309,7 +221,7 @@ class RemoveNamedAttribute(NodeBuilder):
 class StoreNamedAttribute(NodeBuilder):
     """Store the result of a field on a geometry as an attribute with the specified name"""
 
-    name = "GeometryNodeStoreNamedAttribute"
+    _bl_idname = "GeometryNodeStoreNamedAttribute"
     node: bpy.types.GeometryNodeStoreNamedAttribute
 
     def __init__(
@@ -317,10 +229,23 @@ class StoreNamedAttribute(NodeBuilder):
         geometry: TYPE_INPUT_GEOMETRY = None,
         selection: TYPE_INPUT_BOOLEAN = True,
         name: TYPE_INPUT_STRING = "",
-        value: LINKABLE = None,
+        value: TYPE_INPUT_VALUE = 0.0,
         *,
-        data_type: _StoreNamedAttributeTypes = "FLOAT",
-        domain: _AttributeDomains = "POINT",
+        data_type: Literal[
+            "FLOAT",
+            "INT",
+            "BOOLEAN",
+            "FLOAT_VECTOR",
+            "FLOAT_COLOR",
+            "QUATERNION",
+            "FLOAT4X4",
+            "INT8",
+            "FLOAT2",
+            "BYTE_COLOR",
+        ] = "FLOAT",
+        domain: Literal[
+            "POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"
+        ] = "POINT",
     ):
         super().__init__()
         key_args = {
@@ -333,6 +258,210 @@ class StoreNamedAttribute(NodeBuilder):
         self.domain = domain
         self._establish_links(**key_args)
 
+    @classmethod
+    def float(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_VALUE = 0.0,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Float'."""
+        return cls(
+            data_type="FLOAT",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def integer(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_INT = 0,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Integer'."""
+        return cls(
+            data_type="INT",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def boolean(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_BOOLEAN = False,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Boolean'."""
+        return cls(
+            data_type="BOOLEAN",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def vector(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_VECTOR = None,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Vector'."""
+        return cls(
+            data_type="FLOAT_VECTOR",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def color(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_COLOR = None,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Color'."""
+        return cls(
+            data_type="FLOAT_COLOR",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def quaternion(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_ROTATION = None,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Quaternion'."""
+        return cls(
+            data_type="QUATERNION",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def point(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_COLOR = None,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Point'."""
+        return cls(
+            domain="POINT",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def edge(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_COLOR = None,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Edge'."""
+        return cls(
+            domain="EDGE",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def face(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_COLOR = None,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Face'."""
+        return cls(
+            domain="FACE",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def spline(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_COLOR = None,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Spline'."""
+        return cls(
+            domain="CURVE",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def instance(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_COLOR = None,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Instance'."""
+        return cls(
+            domain="INSTANCE",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
+    @classmethod
+    def layer(
+        cls,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        selection: TYPE_INPUT_BOOLEAN = True,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_COLOR = None,
+    ) -> "StoreNamedAttribute":
+        """Create Store Named Attribute with operation 'Layer'."""
+        return cls(
+            domain="LAYER",
+            geometry=geometry,
+            selection=selection,
+            name=name,
+            value=value,
+        )
+
     @property
     def i_geometry(self) -> SocketLinker:
         """Input socket: Geometry"""
@@ -361,121 +490,47 @@ class StoreNamedAttribute(NodeBuilder):
     @property
     def data_type(
         self,
-    ) -> _StoreNamedAttributeTypes:
-        return self.node.data_type  # type: ignore
+    ) -> Literal[
+        "FLOAT",
+        "INT",
+        "BOOLEAN",
+        "FLOAT_VECTOR",
+        "FLOAT_COLOR",
+        "QUATERNION",
+        "FLOAT4X4",
+        "INT8",
+        "FLOAT2",
+        "BYTE_COLOR",
+    ]:
+        return self.node.data_type
 
     @data_type.setter
     def data_type(
         self,
-        value: _StoreNamedAttributeTypes,
+        value: Literal[
+            "FLOAT",
+            "INT",
+            "BOOLEAN",
+            "FLOAT_VECTOR",
+            "FLOAT_COLOR",
+            "QUATERNION",
+            "FLOAT4X4",
+            "INT8",
+            "FLOAT2",
+            "BYTE_COLOR",
+        ],
     ):
         self.node.data_type = value
 
     @property
     def domain(
         self,
-    ) -> _AttributeDomains:
-        return self.node.domain
-
-    @domain.setter
-    def domain(
-        self,
-        value: _AttributeDomains,
-    ):
-        self.node.domain = value
-
-
-def _domain_capture_attribute(domain: _AttributeDomains):
-    @classmethod
-    def method(
-        cls,
-        *args: LINKABLE,
-        geometry: TYPE_INPUT_GEOMETRY = None,
-        **kwargs,
-    ) -> "CaptureAttribute":
-        """Create an IndexSwitch node with a pre-set domain"""
-        return cls(*args, geometry=geometry, domain=domain, **kwargs)
-
-    return method
-
-
-class CaptureAttribute(NodeBuilder):
-    """Store the result of a field on a geometry and output the data as a node socket. Allows remembering or interpolating data as the geometry changes, such as positions before deformation"""
-
-    name = "GeometryNodeCaptureAttribute"
-    node: bpy.types.GeometryNodeCaptureAttribute
-    point = _domain_capture_attribute("POINT")
-    edge = _domain_capture_attribute("EDGE")
-    face = _domain_capture_attribute("FACE")
-    corner = _domain_capture_attribute("CORNER")
-    curve = _domain_capture_attribute("CURVE")
-    instance = _domain_capture_attribute("INSTANCE")
-    layer = _domain_capture_attribute("LAYER")
-
-    def __init__(
-        self,
-        *args: LINKABLE,
-        geometry: TYPE_INPUT_GEOMETRY = None,
-        domain: _AttributeDomains = "POINT",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Geometry": geometry}
-        self.domain = domain
-        key_args.update(self._add_inputs(*args, **kwargs))  # type: ignore
-        self._establish_links(**key_args)
-
-    def _add_socket(self, name: str, type: _AttributeDataTypes):
-        item = self.node.capture_items.new(socket_type=type, name=name)
-        return self.node.inputs[item.name]
-
-    def capture(self, value: LINKABLE) -> SocketLinker:
-        """Capture the value to store in the attribute
-
-        Return the SocketLinker for the output socket
-        """
-        # the _add_inputs returns a dictionary but we only want the first key
-        # because we are adding a single input
-        input_dict = self._add_inputs(value)
-        return SocketLinker(self.node.outputs[next(iter(input_dict))])
-
-    @property
-    def outputs(self) -> dict[str, SocketLinker]:
-        return {
-            item.name: SocketLinker(self.node.outputs[item.name])
-            for item in self.node.capture_items
-        }
-
-    @property
-    def inputs(self) -> dict[str, SocketLinker]:
-        return {
-            item.name: SocketLinker(self.node.inputs[item.name])
-            for item in self.node.capture_items
-        }
-
-    @property
-    def _items(self) -> bpy.types.NodeGeometryCaptureAttributeItems:
-        return self.node.capture_items
-
-    @property
-    def i_geometry(self) -> SocketLinker:
-        """Input socket: Geometry"""
-        return self._input("Geometry")
-
-    @property
-    def o_geometry(self) -> SocketLinker:
-        """Output socket: Geometry"""
-        return self._output("Geometry")
-
-    @property
-    def domain(
-        self,
-    ) -> _AttributeDomains:
+    ) -> Literal["POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"]:
         return self.node.domain
 
     @domain.setter
     def domain(
         self,
-        value: _AttributeDomains,
+        value: Literal["POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"],
     ):
         self.node.domain = value