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

nodebpy/nodes/attribute.py

@@ -1,457 +1,219 @@
-"""
-Auto-generated Blender Geometry Node classes.
+from typing import Literal
 
-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_BOOLEAN
-
-
-class DomainSize(NodeBuilder):
-    """Retrieve the number of elements in a geometry for each attribute domain"""
-
-    name = "GeometryNodeAttributeDomainSize"
-    node: bpy.types.GeometryNodeAttributeDomainSize
-
-    def __init__(
-        self,
-        geometry: LINKABLE = None,
-        component: Literal[
-            "MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"
-        ] = "MESH",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Geometry": geometry}
-        key_args.update(kwargs)
-        self.component = component
-        self._establish_links(**key_args)
-
-    @property
-    def i_geometry(self) -> NodeSocket:
-        """Input socket: Geometry"""
-        return self._input("Geometry")
-
-    @property
-    def o_point_count(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Point Count"""
-        return self._output("Point Count")
-
-    @property
-    def o_edge_count(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Edge Count"""
-        return self._output("Edge Count")
-
-    @property
-    def o_face_count(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Face Count"""
-        return self._output("Face Count")
-
-    @property
-    def o_face_corner_count(self) -> bpy.types.NodeSocketInt:
-        """Output socket: Face Corner Count"""
-        return self._output("Face Corner Count")
-
-    @property
-    def component(
-        self,
-    ) -> Literal["MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"]:
-        return self.node.component
-
-    @component.setter
-    def component(
-        self, value: Literal["MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"]
-    ):
-        self.node.component = value
-
-
-class AttributeStatistic(NodeBuilder):
-    """Calculate statistics about a data set from a field evaluated on a geometry"""
-
-    name = "GeometryNodeAttributeStatistic"
-    node: bpy.types.GeometryNodeAttributeStatistic
-
-    def __init__(
-        self,
-        geometry: LINKABLE = None,
-        selection: TYPE_INPUT_BOOLEAN = True,
-        attribute: float | LINKABLE | None = 0.0,
-        data_type: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
-        ] = "FLOAT",
-        domain: Literal[
-            "POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"
-        ] = "POINT",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {
-            "Geometry": geometry,
-            "Selection": selection,
-            "Attribute": attribute,
-        }
-        key_args.update(kwargs)
-        self.data_type = data_type
-        self.domain = domain
-        self._establish_links(**key_args)
 
-    @property
-    def i_geometry(self) -> NodeSocket:
-        """Input socket: Geometry"""
-        return self._input("Geometry")
-
-    @property
-    def i_selection(self) -> bpy.types.NodeSocketBool:
-        """Input socket: Selection"""
-        return self._input("Selection")
-
-    @property
-    def i_attribute(self) -> bpy.types.NodeSocketFloat:
-        """Input socket: Attribute"""
-        return self._input("Attribute")
-
-    @property
-    def o_mean(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Mean"""
-        return self._output("Mean")
-
-    @property
-    def o_median(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Median"""
-        return self._output("Median")
-
-    @property
-    def o_sum(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Sum"""
-        return self._output("Sum")
-
-    @property
-    def o_min(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Min"""
-        return self._output("Min")
-
-    @property
-    def o_max(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Max"""
-        return self._output("Max")
-
-    @property
-    def o_range(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Range"""
-        return self._output("Range")
-
-    @property
-    def o_standard_deviation(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Standard Deviation"""
-        return self._output("Standard Deviation")
-
-    @property
-    def o_variance(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Variance"""
-        return self._output("Variance")
-
-    @property
-    def data_type(
-        self,
-    ) -> Literal[
-        "FLOAT",
-        "INT",
-        "BOOLEAN",
-        "FLOAT_VECTOR",
-        "FLOAT_COLOR",
-        "QUATERNION",
-        "FLOAT4X4",
-        "STRING",
-        "INT8",
-        "INT16_2D",
-        "INT32_2D",
-        "FLOAT2",
-        "BYTE_COLOR",
-    ]:
-        return self.node.data_type
-
-    @data_type.setter
-    def data_type(
-        self,
-        value: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
-        ],
-    ):
-        self.node.data_type = value
-
-    @property
-    def domain(
-        self,
-    ) -> Literal["POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"]:
-        return self.node.domain
-
-    @domain.setter
-    def domain(
-        self,
-        value: Literal["POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"],
-    ):
-        self.node.domain = value
+from ..builder import NodeBuilder, SocketLinker
+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,
+    TYPE_INPUT_VECTOR,
+)
 
 
 class BlurAttribute(NodeBuilder):
     """Mix attribute values of neighboring elements"""
 
-    name = "GeometryNodeBlurAttribute"
+    _bl_idname = "GeometryNodeBlurAttribute"
     node: bpy.types.GeometryNodeBlurAttribute
 
     def __init__(
         self,
-        value: float | LINKABLE | None = 0.0,
-        iterations: int | LINKABLE | None = 1,
-        weight: LINKABLE | None = 1.0,
-        data_type: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
-        ] = "FLOAT",
-        **kwargs,
+        value: TYPE_INPUT_VALUE = 0.0,
+        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}
-        key_args.update(kwargs)
         self.data_type = data_type
         self._establish_links(**key_args)
 
-    @property
-    def i_value(self) -> bpy.types.NodeSocketFloat:
+    @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 i_value(self) -> SocketLinker:
         """Input socket: Value"""
         return self._input("Value")
 
     @property
-    def i_iterations(self) -> bpy.types.NodeSocketInt:
+    def i_iterations(self) -> SocketLinker:
         """Input socket: Iterations"""
         return self._input("Iterations")
 
     @property
-    def i_weight(self) -> NodeSocket:
+    def i_weight(self) -> SocketLinker:
         """Input socket: Weight"""
         return self._input("Weight")
 
     @property
-    def o_value(self) -> bpy.types.NodeSocketFloat:
+    def o_value(self) -> SocketLinker:
         """Output socket: Value"""
         return self._output("Value")
 
     @property
-    def data_type(
-        self,
-    ) -> Literal[
-        "FLOAT",
-        "INT",
-        "BOOLEAN",
-        "FLOAT_VECTOR",
-        "FLOAT_COLOR",
-        "QUATERNION",
-        "FLOAT4X4",
-        "STRING",
-        "INT8",
-        "INT16_2D",
-        "INT32_2D",
-        "FLOAT2",
-        "BYTE_COLOR",
-    ]:
+    def data_type(self) -> Literal["FLOAT", "INT", "FLOAT_VECTOR", "FLOAT_COLOR"]:
         return self.node.data_type
 
     @data_type.setter
-    def data_type(
-        self,
-        value: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
-        ],
-    ):
+    def data_type(self, value: Literal["FLOAT", "INT", "FLOAT_VECTOR", "FLOAT_COLOR"]):
         self.node.data_type = value
 
 
-class NamedAttribute(NodeBuilder):
-    """Retrieve the data of a specified attribute"""
+class DomainSize(NodeBuilder):
+    """Retrieve the number of elements in a geometry for each attribute domain"""
 
-    name = "GeometryNodeInputNamedAttribute"
-    node: bpy.types.GeometryNodeInputNamedAttribute
+    _bl_idname = "GeometryNodeAttributeDomainSize"
+    node: bpy.types.GeometryNodeAttributeDomainSize
 
     def __init__(
         self,
-        name: str | LINKABLE | None = "",
-        data_type: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
-        ] = "FLOAT",
-        **kwargs,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        *,
+        component: Literal[
+            "MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"
+        ] = "MESH",
     ):
         super().__init__()
-        key_args = {"Name": name}
-        key_args.update(kwargs)
-        self.data_type = data_type
+        key_args = {"Geometry": geometry}
+        self.component = component
         self._establish_links(**key_args)
 
     @property
-    def i_name(self) -> bpy.types.NodeSocketString:
-        """Input socket: Name"""
-        return self._input("Name")
+    def i_geometry(self) -> SocketLinker:
+        """Input socket: Geometry"""
+        return self._input("Geometry")
 
     @property
-    def o_attribute(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Attribute"""
-        return self._output("Attribute")
+    def o_point_count(self) -> SocketLinker:
+        """Output socket: Point Count"""
+        return self._output("Point Count")
 
     @property
-    def o_exists(self) -> bpy.types.NodeSocketBool:
-        """Output socket: Exists"""
-        return self._output("Exists")
+    def o_edge_count(self) -> SocketLinker:
+        """Output socket: Edge Count"""
+        return self._output("Edge Count")
 
     @property
-    def data_type(
-        self,
-    ) -> Literal[
-        "FLOAT",
-        "INT",
-        "BOOLEAN",
-        "FLOAT_VECTOR",
-        "FLOAT_COLOR",
-        "QUATERNION",
-        "FLOAT4X4",
-        "STRING",
-        "INT8",
-        "INT16_2D",
-        "INT32_2D",
-        "FLOAT2",
-        "BYTE_COLOR",
-    ]:
-        return self.node.data_type
+    def o_face_count(self) -> SocketLinker:
+        """Output socket: Face Count"""
+        return self._output("Face Count")
 
-    @data_type.setter
-    def data_type(
+    @property
+    def o_face_corner_count(self) -> SocketLinker:
+        """Output socket: Face Corner Count"""
+        return self._output("Face Corner Count")
+
+    @property
+    def o_spline_count(self) -> SocketLinker:
+        """Output socket: Spline Count"""
+        return self._output("Spline Count")
+
+    @property
+    def o_instance_count(self) -> SocketLinker:
+        """Output socket: Instance Count"""
+        return self._output("Instance Count")
+
+    @property
+    def o_layer_count(self) -> SocketLinker:
+        """Output socket: Layer Count"""
+        return self._output("Layer Count")
+
+    @property
+    def component(
         self,
-        value: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
-        ],
+    ) -> Literal["MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"]:
+        return self.node.component
+
+    @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: LINKABLE = None,
-        pattern_mode: LINKABLE | None = "Exact",
-        name: str | LINKABLE | None = "",
-        **kwargs,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        pattern_mode: TYPE_INPUT_MENU = "Exact",
+        name: TYPE_INPUT_STRING = "",
     ):
         super().__init__()
         key_args = {"Geometry": geometry, "Pattern Mode": pattern_mode, "Name": name}
-        key_args.update(kwargs)
 
         self._establish_links(**key_args)
 
     @property
-    def i_geometry(self) -> NodeSocket:
+    def i_geometry(self) -> SocketLinker:
         """Input socket: Geometry"""
         return self._input("Geometry")
 
     @property
-    def i_pattern_mode(self) -> NodeSocket:
+    def i_pattern_mode(self) -> SocketLinker:
         """Input socket: Pattern Mode"""
         return self._input("Pattern Mode")
 
     @property
-    def i_name(self) -> bpy.types.NodeSocketString:
+    def i_name(self) -> SocketLinker:
         """Input socket: Name"""
         return self._input("Name")
 
     @property
-    def o_geometry(self) -> NodeSocket:
+    def o_geometry(self) -> SocketLinker:
         """Output socket: Geometry"""
         return self._output("Geometry")
 
@@ -459,15 +221,16 @@ 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__(
         self,
-        geometry: LINKABLE = None,
+        geometry: TYPE_INPUT_GEOMETRY = None,
         selection: TYPE_INPUT_BOOLEAN = True,
-        name: str | LINKABLE | None = "",
-        value: float | LINKABLE | None = 0.0,
+        name: TYPE_INPUT_STRING = "",
+        value: TYPE_INPUT_VALUE = 0.0,
+        *,
         data_type: Literal[
             "FLOAT",
             "INT",
@@ -476,17 +239,13 @@ class StoreNamedAttribute(NodeBuilder):
             "FLOAT_COLOR",
             "QUATERNION",
             "FLOAT4X4",
-            "STRING",
             "INT8",
-            "INT16_2D",
-            "INT32_2D",
             "FLOAT2",
             "BYTE_COLOR",
         ] = "FLOAT",
         domain: Literal[
             "POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"
         ] = "POINT",
-        **kwargs,
     ):
         super().__init__()
         key_args = {
@@ -495,33 +254,236 @@ class StoreNamedAttribute(NodeBuilder):
             "Name": name,
             "Value": value,
         }
-        key_args.update(kwargs)
         self.data_type = data_type
         self.domain = domain
         self._establish_links(**key_args)
 
-    @property
-    def i_geometry(self) -> NodeSocket:
+    @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"""
         return self._input("Geometry")
 
     @property
-    def i_selection(self) -> bpy.types.NodeSocketBool:
+    def i_selection(self) -> SocketLinker:
         """Input socket: Selection"""
         return self._input("Selection")
 
     @property
-    def i_name(self) -> bpy.types.NodeSocketString:
+    def i_name(self) -> SocketLinker:
         """Input socket: Name"""
         return self._input("Name")
 
     @property
-    def i_value(self) -> bpy.types.NodeSocketFloat:
+    def i_value(self) -> SocketLinker:
         """Input socket: Value"""
         return self._input("Value")
 
     @property
-    def o_geometry(self) -> NodeSocket:
+    def o_geometry(self) -> SocketLinker:
         """Output socket: Geometry"""
         return self._output("Geometry")
 
@@ -536,10 +498,7 @@ class StoreNamedAttribute(NodeBuilder):
         "FLOAT_COLOR",
         "QUATERNION",
         "FLOAT4X4",
-        "STRING",
         "INT8",
-        "INT16_2D",
-        "INT32_2D",
         "FLOAT2",
         "BYTE_COLOR",
     ]:
@@ -556,10 +515,7 @@ class StoreNamedAttribute(NodeBuilder):
             "FLOAT_COLOR",
             "QUATERNION",
             "FLOAT4X4",
-            "STRING",
             "INT8",
-            "INT16_2D",
-            "INT32_2D",
             "FLOAT2",
             "BYTE_COLOR",
         ],