nd class

" Static class

Exposes all nodes as static methods:

a = nd.math(1, 2, operation='ADD')

Source code in core/generated/static_nd.py

class ND:
    """" Static class

    Exposes all nodes as static methods:

    ``` python
    a = nd.math(1, 2, operation='ADD')
    ```
    """

    @classmethod
    def align_rotation_to_vector(cls,
                    rotation: Rotation = None,
                    vector: Vector = None,
                    factor: Float = None,
                    axis: Literal['X', 'Y', 'Z'] = 'Z',
                    pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO'):
        """ > Node Align Rotation to Vector

        Parameters
        ----------
        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)

        vector : Vector, optional
            socket 'Vector' (id: Vector)

        factor : Float, optional
            socket 'Factor' (id: Factor)

        axis : Literal['X', 'Y', 'Z']
            parameter `axis`

        pivot_axis : Literal['Auto', 'X', 'Y', 'Z']
            parameter `pivot_axis`


        Returns
        -------
        Rotation
        """
        utils.check_enum_arg('Align Rotation to Vector', 'axis', axis, 'align_rotation_to_vector', ('X', 'Y', 'Z'))
        utils.check_enum_arg('Align Rotation to Vector', 'pivot_axis', pivot_axis, 'align_rotation_to_vector', ('AUTO', 'X', 'Y', 'Z'))
        node = Node('Align Rotation to Vector', {'Rotation': rotation, 'Vector': vector, 'Factor': factor}, axis=axis, pivot_axis=pivot_axis)
        return node._out

    @classmethod
    def axes_to_rotation(cls,
                    primary_axis_1: Vector = None,
                    secondary_axis_1: Vector = None,
                    primary_axis: Literal['X', 'Y', 'Z'] = 'Z',
                    secondary_axis: Literal['X', 'Y', 'Z'] = 'X'):
        """ > Node Axes to Rotation

        Parameters
        ----------
        primary_axis_1 : Vector, optional
            socket 'Primary Axis' (id: Primary Axis)

        secondary_axis_1 : Vector, optional
            socket 'Secondary Axis' (id: Secondary Axis)

        primary_axis : Literal['X', 'Y', 'Z']
            parameter `primary_axis`

        secondary_axis : Literal['X', 'Y', 'Z']
            parameter `secondary_axis`


        Returns
        -------
        Rotation
        """
        utils.check_enum_arg('Axes to Rotation', 'primary_axis', primary_axis, 'axes_to_rotation', ('X', 'Y', 'Z'))
        utils.check_enum_arg('Axes to Rotation', 'secondary_axis', secondary_axis, 'axes_to_rotation', ('X', 'Y', 'Z'))
        node = Node('Axes to Rotation', {'Primary Axis': primary_axis_1, 'Secondary Axis': secondary_axis_1}, primary_axis=primary_axis, secondary_axis=secondary_axis)
        return node._out

    @classmethod
    def axis_angle_to_rotation(cls, axis: Vector = None, angle: Float = None):
        """ > Node Axis Angle to Rotation

        Parameters
        ----------
        axis : Vector, optional
            socket 'Axis' (id: Axis)

        angle : Float, optional
            socket 'Angle' (id: Angle)


        Returns
        -------
        Rotation
        """
        node = Node('Axis Angle to Rotation', {'Axis': axis, 'Angle': angle})
        return node._out

    @classmethod
    def bit_math(cls,
                    a: Integer = None,
                    b: Integer = None,
                    shift: Integer = None,
                    operation: Literal['AND', 'OR', 'XOR', 'NOT', 'SHIFT', 'ROTATE'] = 'AND'):
        """ > Node Bit Math

        Parameters
        ----------
        a : Integer, optional
            socket 'A' (id: A)

        b : Integer, optional
            socket 'B' (id: B)

        shift : Integer, optional
            socket 'Shift' (id: Shift)

        operation : Literal['And', 'Or', 'Exclusive Or', 'Not', 'Shift', 'Rotate']
            parameter `operation`


        Returns
        -------
        Integer
        """
        utils.check_enum_arg('Bit Math', 'operation', operation, 'bit_math', ('AND', 'OR', 'XOR', 'NOT', 'SHIFT', 'ROTATE'))
        node = Node('Bit Math', {'A': a, 'B': b, 'Shift': shift}, operation=operation)
        return node._out

    @classmethod
    def boolean_math(cls,
                    boolean: Boolean = None,
                    boolean_1: Boolean = None,
                    operation: Literal['AND', 'OR', 'NOT', 'NAND', 'NOR', 'XNOR', 'XOR', 'IMPLY', 'NIMPLY'] = 'AND'):
        """ > Node Boolean Math

        Parameters
        ----------
        boolean : Boolean, optional
            socket 'Boolean' (id: Boolean)

        boolean_1 : Boolean, optional
            socket 'Boolean' (id: Boolean_001)

        operation : Literal['And', 'Or', 'Not', 'Not And', 'Nor', 'Equal', 'Not Equal', 'Imply', 'Subtract']
            parameter `operation`


        Returns
        -------
        Boolean
        """
        utils.check_enum_arg('Boolean Math', 'operation', operation, 'boolean_math', ('AND', 'OR', 'NOT', 'NAND', 'NOR', 'XNOR', 'XOR', 'IMPLY', 'NIMPLY'))
        node = Node('Boolean Math', {'Boolean': boolean, 'Boolean_001': boolean_1}, operation=operation)
        return node._out

    @classmethod
    def combine_color(cls,
                    red: Float = None,
                    green: Float = None,
                    blue: Float = None,
                    alpha: Float = None,
                    mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB'):
        """ > Node Combine Color

        Parameters
        ----------
        red : Float, optional
            socket 'Red' (id: Red)

        green : Float, optional
            socket 'Green' (id: Green)

        blue : Float, optional
            socket 'Blue' (id: Blue)

        alpha : Float, optional
            socket 'Alpha' (id: Alpha)

        mode : Literal['RGB', 'HSV', 'HSL']
            parameter `mode`


        Returns
        -------
        Color
        """
        utils.check_enum_arg('Combine Color', 'mode', mode, 'combine_color', ('RGB', 'HSV', 'HSL'))
        node = Node('Combine Color', {'Red': red, 'Green': green, 'Blue': blue, 'Alpha': alpha}, mode=mode)
        return node._out

    @classmethod
    def combine_matrix(cls,
                    column_1_row_1: Float = None,
                    column_1_row_2: Float = None,
                    column_1_row_3: Float = None,
                    column_1_row_4: Float = None,
                    column_2_row_1: Float = None,
                    column_2_row_2: Float = None,
                    column_2_row_3: Float = None,
                    column_2_row_4: Float = None,
                    column_3_row_1: Float = None,
                    column_3_row_2: Float = None,
                    column_3_row_3: Float = None,
                    column_3_row_4: Float = None,
                    column_4_row_1: Float = None,
                    column_4_row_2: Float = None,
                    column_4_row_3: Float = None,
                    column_4_row_4: Float = None):
        """ > Node Combine Matrix

        Parameters
        ----------
        column_1_row_1 : Float, optional
            socket 'Column 1 Row 1' (id: Column 1 Row 1)

        column_1_row_2 : Float, optional
            socket 'Column 1 Row 2' (id: Column 1 Row 2)

        column_1_row_3 : Float, optional
            socket 'Column 1 Row 3' (id: Column 1 Row 3)

        column_1_row_4 : Float, optional
            socket 'Column 1 Row 4' (id: Column 1 Row 4)

        column_2_row_1 : Float, optional
            socket 'Column 2 Row 1' (id: Column 2 Row 1)

        column_2_row_2 : Float, optional
            socket 'Column 2 Row 2' (id: Column 2 Row 2)

        column_2_row_3 : Float, optional
            socket 'Column 2 Row 3' (id: Column 2 Row 3)

        column_2_row_4 : Float, optional
            socket 'Column 2 Row 4' (id: Column 2 Row 4)

        column_3_row_1 : Float, optional
            socket 'Column 3 Row 1' (id: Column 3 Row 1)

        column_3_row_2 : Float, optional
            socket 'Column 3 Row 2' (id: Column 3 Row 2)

        column_3_row_3 : Float, optional
            socket 'Column 3 Row 3' (id: Column 3 Row 3)

        column_3_row_4 : Float, optional
            socket 'Column 3 Row 4' (id: Column 3 Row 4)

        column_4_row_1 : Float, optional
            socket 'Column 4 Row 1' (id: Column 4 Row 1)

        column_4_row_2 : Float, optional
            socket 'Column 4 Row 2' (id: Column 4 Row 2)

        column_4_row_3 : Float, optional
            socket 'Column 4 Row 3' (id: Column 4 Row 3)

        column_4_row_4 : Float, optional
            socket 'Column 4 Row 4' (id: Column 4 Row 4)


        Returns
        -------
        Matrix
        """
        node = Node('Combine Matrix', {'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})
        return node._out

    @classmethod
    def combine_transform(cls,
                    translation: Vector = None,
                    rotation: Rotation = None,
                    scale: Vector = None):
        """ > Node Combine Transform

        Parameters
        ----------
        translation : Vector, optional
            socket 'Translation' (id: Translation)

        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)

        scale : Vector, optional
            socket 'Scale' (id: Scale)


        Returns
        -------
        Matrix
        """
        node = Node('Combine Transform', {'Translation': translation, 'Rotation': rotation, 'Scale': scale})
        return node._out

    @classmethod
    def compare(cls,
                    a: Float = None,
                    b: Float = None,
                    a_1: Integer = None,
                    b_1: Integer = None,
                    a_2: Vector = None,
                    b_2: Vector = None,
                    a_3: Color = None,
                    b_3: Color = None,
                    a_4: String = None,
                    b_4: String = None,
                    c: Float = None,
                    angle: Float = None,
                    epsilon: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'VECTOR', 'RGBA', 'STRING'] = 'FLOAT',
                    mode: Literal['ELEMENT', 'LENGTH', 'AVERAGE', 'DOT_PRODUCT', 'DIRECTION'] = 'ELEMENT',
                    operation: Literal['LESS_THAN', 'LESS_EQUAL', 'GREATER_THAN', 'GREATER_EQUAL', 'EQUAL', 'NOT_EQUAL'] = 'GREATER_THAN'):
        """ > Node Compare

        Parameters
        ----------
        a : Float, optional
            socket 'A' (id: A)

        b : Float, optional
            socket 'B' (id: B)

        a_1 : Integer, optional
            socket 'A' (id: A_INT)

        b_1 : Integer, optional
            socket 'B' (id: B_INT)

        a_2 : Vector, optional
            socket 'A' (id: A_VEC3)

        b_2 : Vector, optional
            socket 'B' (id: B_VEC3)

        a_3 : Color, optional
            socket 'A' (id: A_COL)

        b_3 : Color, optional
            socket 'B' (id: B_COL)

        a_4 : String, optional
            socket 'A' (id: A_STR)

        b_4 : String, optional
            socket 'B' (id: B_STR)

        c : Float, optional
            socket 'C' (id: C)

        angle : Float, optional
            socket 'Angle' (id: Angle)

        epsilon : Float, optional
            socket 'Epsilon' (id: Epsilon)

        data_type : Literal['Float', 'Integer', 'Vector', 'Color', 'String']
            parameter `data_type`

        mode : Literal['Element-Wise', 'Length', 'Average', 'Dot Product', 'Direction']
            parameter `mode`

        operation : Literal['Less Than', 'Less Than or Equal', 'Greater Than', 'Greater Than or Equal', 'Equal', 'Not Equal']
            parameter `operation`


        Returns
        -------
        Boolean
        """
        utils.check_enum_arg('Compare', 'mode', mode, 'compare', ('ELEMENT', 'LENGTH', 'AVERAGE', 'DOT_PRODUCT', 'DIRECTION'))
        utils.check_enum_arg('Compare', 'operation', operation, 'compare', ('LESS_THAN', 'LESS_EQUAL', 'GREATER_THAN', 'GREATER_EQUAL', 'EQUAL', 'NOT_EQUAL'))
        node = Node('Compare', {'A': a, 'B': b, 'A_INT': a_1, 'B_INT': b_1, 'A_VEC3': a_2, 'B_VEC3': b_2, 'A_COL': a_3, 'B_COL': b_3, 'A_STR': a_4, 'B_STR': b_4, 'C': c, 'Angle': angle, 'Epsilon': epsilon}, data_type=data_type, mode=mode, operation=operation)
        return node._out

    @classmethod
    def euler_to_rotation(cls, euler: Vector = None):
        """ > Node Euler to Rotation

        Parameters
        ----------
        euler : Vector, optional
            socket 'Euler' (id: Euler)


        Returns
        -------
        Rotation
        """
        node = Node('Euler to Rotation', {'Euler': euler})
        return node._out

    @classmethod
    def find_in_string(cls, string: String = None, search: String = None):
        """ > Node Find in String

        Parameters
        ----------
        string : String, optional
            socket 'String' (id: String)

        search : String, optional
            socket 'Search' (id: Search)


        Returns
        -------
        Integer
            peer sockets: count_ (Integer)

        """
        node = Node('Find in String', {'String': string, 'Search': search})
        return node._out

    @classmethod
    def float_to_integer(cls,
                    float: Float = None,
                    rounding_mode: Literal['ROUND', 'FLOOR', 'CEILING', 'TRUNCATE'] = 'ROUND'):
        """ > Node Float to Integer

        Parameters
        ----------
        float : Float, optional
            socket 'Float' (id: Float)

        rounding_mode : Literal['Round', 'Floor', 'Ceiling', 'Truncate']
            parameter `rounding_mode`


        Returns
        -------
        Integer
        """
        utils.check_enum_arg('Float to Integer', 'rounding_mode', rounding_mode, 'float_to_integer', ('ROUND', 'FLOOR', 'CEILING', 'TRUNCATE'))
        node = Node('Float to Integer', {'Float': float}, rounding_mode=rounding_mode)
        return node._out

    @classmethod
    def format_string(cls, named_sockets: dict = {}, format: String = None, **sockets):
        """ > Node Format String

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        format : String, optional
            socket 'Format' (id: Format)

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        String
        """
        node = Node('Format String', {'Format': format, **named_sockets}, **sockets)
        return node._out

    @classmethod
    def hash_value(cls,
                    value: Integer = None,
                    seed: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING'] = 'INT'):
        """ > Node Hash Value

        Parameters
        ----------
        value : Integer, optional
            socket 'Value' (id: Value)

        seed : Integer, optional
            socket 'Seed' (id: Seed)

        data_type : Literal['Float', 'Integer', 'Vector', 'Color', 'Rotation', 'Matrix', 'String']
            parameter `data_type`


        Returns
        -------
        Integer
        """
        node = Node('Hash Value', {'Value': value, 'Seed': seed}, data_type=data_type)
        return node._out

    @classmethod
    def boolean(cls, boolean = False):
        """ > Node Boolean

        Parameters
        ----------
        boolean : bool
            parameter `boolean`


        Returns
        -------
        Boolean
        """
        node = Node('Boolean', boolean=boolean)
        return node._out

    @utils.classproperty
    def color(self):
        """ > Node Color

        Returns
        -------
        Color
        """
        node = Node('Color', )
        return node._out

    @classmethod
    def integer(cls, integer = 0):
        """ > Node Integer

        Parameters
        ----------
        integer : int
            parameter `integer`


        Returns
        -------
        Integer
        """
        node = Node('Integer', integer=integer)
        return node._out

    @utils.classproperty
    def rotation(self):
        """ > Node Rotation

        Returns
        -------
        Rotation
        """
        node = Node('Rotation', )
        return node._out

    @classmethod
    def special_characters(cls):
        """ > Node Special Characters

        Returns
        -------
        String
            peer sockets: tab_ (String)

        """
        node = Node('Special Characters', )
        return node

    @classmethod
    def string(cls, string = ''):
        """ > Node String

        Parameters
        ----------
        string : str
            parameter `string`


        Returns
        -------
        String
        """
        node = Node('String', string=string)
        return node._out

    @utils.classproperty
    def vector(self):
        """ > Node Vector

        Returns
        -------
        Vector
        """
        node = Node('Vector', )
        return node._out

    @classmethod
    def integer_math(cls,
                    value: Integer = None,
                    value_1: Integer = None,
                    value_2: Integer = None,
                    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'):
        """ > Node Integer Math

        Parameters
        ----------
        value : Integer, optional
            socket 'Value' (id: Value)

        value_1 : Integer, optional
            socket 'Value' (id: Value_001)

        value_2 : Integer, optional
            socket 'Value' (id: Value_002)

        operation : Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Absolute', 'Negate', 'Power', 'Minimum', 'Maximum', 'Sign', 'Divide Round', 'Divide Floor', 'Divide Ceiling', 'Floored Modulo', 'Modulo', 'Greatest Common Divisor', 'Least Common Multiple']
            parameter `operation`


        Returns
        -------
        Integer
        """
        utils.check_enum_arg('Integer Math', 'operation', operation, 'integer_math', ('ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'ABSOLUTE', 'NEGATE', 'POWER', 'MINIMUM', 'MAXIMUM', 'SIGN', 'DIVIDE_ROUND', 'DIVIDE_FLOOR', 'DIVIDE_CEIL', 'FLOORED_MODULO', 'MODULO', 'GCD', 'LCM'))
        node = Node('Integer Math', {'Value': value, 'Value_001': value_1, 'Value_002': value_2}, operation=operation)
        return node._out

    @classmethod
    def invert_matrix(cls, matrix: Matrix = None):
        """ > Node Invert Matrix

        Parameters
        ----------
        matrix : Matrix, optional
            socket 'Matrix' (id: Matrix)


        Returns
        -------
        Matrix
            peer sockets: invertible_ (Boolean)

        """
        node = Node('Invert Matrix', {'Matrix': matrix})
        return node._out

    @classmethod
    def invert_rotation(cls, rotation: Rotation = None):
        """ > Node Invert Rotation

        Parameters
        ----------
        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)


        Returns
        -------
        Rotation
        """
        node = Node('Invert Rotation', {'Rotation': rotation})
        return node._out

    @classmethod
    def match_string(cls,
                    string: String = None,
                    operation: Literal['Starts With', 'Ends With', 'Contains'] = None,
                    key: String = None):
        """ > Node Match String

        Parameters
        ----------
        string : String, optional
            socket 'String' (id: String)

        operation : menu='Starts With', optional
            ('Starts With', 'Ends With', 'Contains')

        key : String, optional
            socket 'Key' (id: Key)


        Returns
        -------
        Boolean
        """
        node = Node('Match String', {'String': string, 'Operation': operation, 'Key': key})
        return node._out

    @classmethod
    def matrix_determinant(cls, matrix: Matrix = None):
        """ > Node Matrix Determinant

        Parameters
        ----------
        matrix : Matrix, optional
            socket 'Matrix' (id: Matrix)


        Returns
        -------
        Float
        """
        node = Node('Matrix Determinant', {'Matrix': matrix})
        return node._out

    @classmethod
    def multiply_matrices(cls, matrix: Matrix = None, matrix_1: Matrix = None):
        """ > Node Multiply Matrices

        Parameters
        ----------
        matrix : Matrix, optional
            socket 'Matrix' (id: Matrix)

        matrix_1 : Matrix, optional
            socket 'Matrix' (id: Matrix_001)


        Returns
        -------
        Matrix
        """
        node = Node('Multiply Matrices', {'Matrix': matrix, 'Matrix_001': matrix_1})
        return node._out

    @classmethod
    def matrix_svd(cls, matrix: Matrix = None):
        """ > Node Matrix SVD

        Parameters
        ----------
        matrix : Matrix, optional
            socket 'Matrix' (id: Matrix)


        Returns
        -------
        Matrix
            peer sockets: s_ (Vector), v_ (Matrix)

        """
        node = Node('Matrix SVD', {'Matrix': matrix})
        return node._out

    @classmethod
    def project_point(cls, vector: Vector = None, transform: Matrix = None):
        """ > Node Project Point

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        transform : Matrix, optional
            socket 'Transform' (id: Transform)


        Returns
        -------
        Vector
        """
        node = Node('Project Point', {'Vector': vector, 'Transform': transform})
        return node._out

    @classmethod
    def quaternion_to_rotation(cls, w: Float = None, x: Float = None, y: Float = None, z: Float = None):
        """ > Node Quaternion to Rotation

        Parameters
        ----------
        w : Float, optional
            socket 'W' (id: W)

        x : Float, optional
            socket 'X' (id: X)

        y : Float, optional
            socket 'Y' (id: Y)

        z : Float, optional
            socket 'Z' (id: Z)


        Returns
        -------
        Rotation
        """
        node = Node('Quaternion to Rotation', {'W': w, 'X': x, 'Y': y, 'Z': z})
        return node._out

    @classmethod
    def random_value(cls,
                    min: Vector = None,
                    max: Vector = None,
                    min_1: Float = None,
                    max_1: Float = None,
                    min_2: Integer = None,
                    max_2: Integer = None,
                    probability: Float = None,
                    id: Integer = None,
                    seed: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR'] = 'FLOAT'):
        """ > Node Random Value

        Parameters
        ----------
        min : Vector, optional
            socket 'Min' (id: Min)

        max : Vector, optional
            socket 'Max' (id: Max)

        min_1 : Float, optional
            socket 'Min' (id: Min_001)

        max_1 : Float, optional
            socket 'Max' (id: Max_001)

        min_2 : Integer, optional
            socket 'Min' (id: Min_002)

        max_2 : Integer, optional
            socket 'Max' (id: Max_002)

        probability : Float, optional
            socket 'Probability' (id: Probability)

        id : Integer, optional
            socket 'ID' (id: ID)

        seed : Integer, optional
            socket 'Seed' (id: Seed)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Random Value', {'Min': min, 'Max': max, 'Min_001': min_1, 'Max_001': max_1, 'Min_002': min_2, 'Max_002': max_2, 'Probability': probability, 'ID': id, 'Seed': seed}, data_type=data_type)
        return node._out

    @classmethod
    def replace_string(cls, string: String = None, find: String = None, replace: String = None):
        """ > Node Replace String

        Parameters
        ----------
        string : String, optional
            socket 'String' (id: String)

        find : String, optional
            socket 'Find' (id: Find)

        replace : String, optional
            socket 'Replace' (id: Replace)


        Returns
        -------
        String
        """
        node = Node('Replace String', {'String': string, 'Find': find, 'Replace': replace})
        return node._out

    @classmethod
    def rotate_rotation(cls,
                    rotation: Rotation = None,
                    rotate_by: Rotation = None,
                    rotation_space: Literal['GLOBAL', 'LOCAL'] = 'GLOBAL'):
        """ > Node Rotate Rotation

        Parameters
        ----------
        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)

        rotate_by : Rotation, optional
            socket 'Rotate By' (id: Rotate By)

        rotation_space : Literal['Global', 'Local']
            parameter `rotation_space`


        Returns
        -------
        Rotation
        """
        utils.check_enum_arg('Rotate Rotation', 'rotation_space', rotation_space, 'rotate_rotation', ('GLOBAL', 'LOCAL'))
        node = Node('Rotate Rotation', {'Rotation': rotation, 'Rotate By': rotate_by}, rotation_space=rotation_space)
        return node._out

    @classmethod
    def rotate_vector(cls, vector: Vector = None, rotation: Rotation = None):
        """ > Node Rotate Vector

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)


        Returns
        -------
        Vector
        """
        node = Node('Rotate Vector', {'Vector': vector, 'Rotation': rotation})
        return node._out

    @classmethod
    def rotation_to_axis_angle(cls, rotation: Rotation = None):
        """ > Node Rotation to Axis Angle

        Parameters
        ----------
        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)


        Returns
        -------
        Vector
            peer sockets: angle_ (Float)

        """
        node = Node('Rotation to Axis Angle', {'Rotation': rotation})
        return node._out

    @classmethod
    def rotation_to_euler(cls, rotation: Rotation = None):
        """ > Node Rotation to Euler

        Parameters
        ----------
        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)


        Returns
        -------
        Vector
        """
        node = Node('Rotation to Euler', {'Rotation': rotation})
        return node._out

    @classmethod
    def rotation_to_quaternion(cls, rotation: Rotation = None):
        """ > Node Rotation to Quaternion

        Parameters
        ----------
        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)


        Returns
        -------
        Float
            peer sockets: x_ (Float), y_ (Float), z_ (Float)

        """
        node = Node('Rotation to Quaternion', {'Rotation': rotation})
        return node._out

    @classmethod
    def separate_color(cls, color: Color = None, mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB'):
        """ > Node Separate Color

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        mode : Literal['RGB', 'HSV', 'HSL']
            parameter `mode`


        Returns
        -------
        Float
            peer sockets: green_ (Float), blue_ (Float), alpha_ (Float)

        """
        utils.check_enum_arg('Separate Color', 'mode', mode, 'separate_color', ('RGB', 'HSV', 'HSL'))
        node = Node('Separate Color', {'Color': color}, mode=mode)
        return node

    @classmethod
    def separate_matrix(cls, matrix: Matrix = None):
        """ > Node Separate Matrix

        Parameters
        ----------
        matrix : Matrix, optional
            socket 'Matrix' (id: Matrix)


        Returns
        -------
        Float
            peer sockets: column_1_row_2_ (Float), column_1_row_3_ (Float), column_1_row_4_ (Float), column_2_row_1_ (Float), column_2_row_2_ (Float), column_2_row_3_ (Float), column_2_row_4_ (Float), column_3_row_1_ (Float), column_3_row_2_ (Float), column_3_row_3_ (Float), column_3_row_4_ (Float), column_4_row_1_ (Float), column_4_row_2_ (Float), column_4_row_3_ (Float), column_4_row_4_ (Float)

        """
        node = Node('Separate Matrix', {'Matrix': matrix})
        return node

    @classmethod
    def separate_transform(cls, transform: Matrix = None):
        """ > Node Separate Transform

        Parameters
        ----------
        transform : Matrix, optional
            socket 'Transform' (id: Transform)


        Returns
        -------
        Vector
            peer sockets: rotation_ (Rotation), scale_ (Vector)

        """
        node = Node('Separate Transform', {'Transform': transform})
        return node

    @classmethod
    def slice_string(cls, string: String = None, position: Integer = None, length: Integer = None):
        """ > Node Slice String

        Parameters
        ----------
        string : String, optional
            socket 'String' (id: String)

        position : Integer, optional
            socket 'Position' (id: Position)

        length : Integer, optional
            socket 'Length' (id: Length)


        Returns
        -------
        String
        """
        node = Node('Slice String', {'String': string, 'Position': position, 'Length': length})
        return node._out

    @classmethod
    def string_length(cls, string: String = None):
        """ > Node String Length

        Parameters
        ----------
        string : String, optional
            socket 'String' (id: String)


        Returns
        -------
        Integer
        """
        node = Node('String Length', {'String': string})
        return node._out

    @classmethod
    def string_to_value(cls, string: String = None, data_type: Literal['FLOAT', 'INT'] = 'FLOAT'):
        """ > Node String to Value

        Parameters
        ----------
        string : String, optional
            socket 'String' (id: String)

        data_type : Literal['Float', 'Integer']
            parameter `data_type`


        Returns
        -------
        Float
            peer sockets: length_ (Integer)

        """
        node = Node('String to Value', {'String': string}, data_type=data_type)
        return node._out

    @classmethod
    def transform_direction(cls, direction: Vector = None, transform: Matrix = None):
        """ > Node Transform Direction

        Parameters
        ----------
        direction : Vector, optional
            socket 'Direction' (id: Direction)

        transform : Matrix, optional
            socket 'Transform' (id: Transform)


        Returns
        -------
        Vector
        """
        node = Node('Transform Direction', {'Direction': direction, 'Transform': transform})
        return node._out

    @classmethod
    def transform_point(cls, vector: Vector = None, transform: Matrix = None):
        """ > Node Transform Point

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        transform : Matrix, optional
            socket 'Transform' (id: Transform)


        Returns
        -------
        Vector
        """
        node = Node('Transform Point', {'Vector': vector, 'Transform': transform})
        return node._out

    @classmethod
    def transpose_matrix(cls, matrix: Matrix = None):
        """ > Node Transpose Matrix

        Parameters
        ----------
        matrix : Matrix, optional
            socket 'Matrix' (id: Matrix)


        Returns
        -------
        Matrix
        """
        node = Node('Transpose Matrix', {'Matrix': matrix})
        return node._out

    @classmethod
    def value_to_string(cls,
                    value: Float = None,
                    decimals: Integer = None,
                    data_type: Literal['FLOAT', 'INT'] = 'FLOAT'):
        """ > Node Value to String

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        decimals : Integer, optional
            socket 'Decimals' (id: Decimals)

        data_type : Literal['Float', 'Integer']
            parameter `data_type`


        Returns
        -------
        String
        """
        node = Node('Value to String', {'Value': value, 'Decimals': decimals}, data_type=data_type)
        return node._out

    @classmethod
    def accumulate_field(cls,
                    value: Float = None,
                    group_id: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'FLOAT_VECTOR', 'TRANSFORM'] = 'FLOAT',
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
        """ > Node Accumulate Field

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        group_id : Integer, optional
            socket 'Group ID' (id: Group Index)

        data_type : Literal['Float', 'Integer', 'Vector', 'Transform']
            parameter `data_type`

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Float
            peer sockets: trailing_ (Float), total_ (Float)

        """
        utils.check_enum_arg('Accumulate Field', 'domain', domain, 'accumulate_field', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Accumulate Field', {'Value': value, 'Group Index': group_id}, data_type=data_type, domain=domain)
        return node._out

    @classmethod
    def domain_size(cls,
                    geometry: Geometry = None,
                    component: Literal['MESH', 'POINTCLOUD', 'CURVE', 'INSTANCES', 'GREASEPENCIL'] = 'MESH'):
        """ > Node Domain Size

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        component : Literal['Mesh', 'Point Cloud', 'Curve', 'Instances', 'Grease Pencil']
            parameter `component`


        Returns
        -------
        Integer
            peer sockets: edge_count_ (Integer), face_count_ (Integer), face_corner_count_ (Integer)

        """
        utils.check_enum_arg('Domain Size', 'component', component, 'domain_size', ('MESH', 'POINTCLOUD', 'CURVE', 'INSTANCES', 'GREASEPENCIL'))
        node = Node('Domain Size', {'Geometry': geometry}, component=component)
        return node._out

    @classmethod
    def attribute_statistic(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    attribute: Float = None,
                    data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
        """ > Node Attribute Statistic

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        attribute : Float, optional
            socket 'Attribute' (id: Attribute)

        data_type : Literal['Float', 'Vector']
            parameter `data_type`

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Float
            peer sockets: median_ (Float), sum_ (Float), min_ (Float), max_ (Float), range_ (Float), standard_deviation_ (Float), variance_ (Float)

        """
        utils.check_enum_arg('Attribute Statistic', 'domain', domain, 'attribute_statistic', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Attribute Statistic', {'Geometry': geometry, 'Selection': selection, 'Attribute': attribute}, data_type=data_type, domain=domain)
        return node._out

    @classmethod
    def bake(cls, named_sockets: dict = {}, **sockets):
        """ > Node Bake

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        None
        """
        node = Node('Bake', named_sockets, **sockets)
        return node._out

    @classmethod
    def blur_attribute(cls,
                    value: Float = None,
                    iterations: Integer = None,
                    weight: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'FLOAT_VECTOR', 'FLOAT_COLOR'] = 'FLOAT'):
        """ > Node Blur Attribute

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        data_type : Literal['Float', 'Integer', 'Vector', 'Color']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Blur Attribute', {'Value': value, 'Iterations': iterations, 'Weight': weight}, data_type=data_type)
        return node._out

    @classmethod
    def bone_info(cls,
                    armature: Object = None,
                    bone_name: String = None,
                    transform_space: Literal['ORIGINAL', 'RELATIVE'] = 'ORIGINAL'):
        """ > Node Bone Info

        Parameters
        ----------
        armature : Object, optional
            socket 'Armature' (id: Armature)

        bone_name : String, optional
            socket 'Bone Name' (id: Bone Name)

        transform_space : Literal['Original', 'Relative']
            parameter `transform_space`


        Returns
        -------
        Matrix
            peer sockets: local_pose_ (Matrix), transform_pose_ (Matrix), rest_pose_ (Matrix), rest_length_ (Float)

        """
        utils.check_enum_arg('Bone Info', 'transform_space', transform_space, 'bone_info', ('ORIGINAL', 'RELATIVE'))
        node = Node('Bone Info', {'Armature': armature, 'Bone Name': bone_name}, transform_space=transform_space)
        return node._out

    @classmethod
    def bounding_box(cls, geometry: Geometry = None, use_radius: Boolean = None):
        """ > Node Bounding Box

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        use_radius : Boolean, optional
            socket 'Use Radius' (id: Use Radius)


        Returns
        -------
        Mesh
            peer sockets: min_ (Vector), max_ (Vector)

        """
        node = Node('Bounding Box', {'Geometry': geometry, 'Use Radius': use_radius})
        return node._out

    @classmethod
    def camera_info(cls, camera: Object = None):
        """ > Node Camera Info

        Parameters
        ----------
        camera : Object, optional
            socket 'Camera' (id: Camera)


        Returns
        -------
        Matrix
            peer sockets: focal_length_ (Float), sensor_ (Vector), shift_ (Vector), clip_start_ (Float), clip_end_ (Float), focus_distance_ (Float), is_orthographic_ (Boolean), orthographic_scale_ (Float)

        """
        node = Node('Camera Info', {'Camera': camera})
        return node._out

    @classmethod
    def capture_attribute(cls,
                    named_sockets: dict = {},
                    geometry: Geometry = None,
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT',
                    **sockets):
        """ > Node Capture Attribute

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        Geometry
        """
        utils.check_enum_arg('Capture Attribute', 'domain', domain, 'capture_attribute', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Capture Attribute', {'Geometry': geometry, **named_sockets}, domain=domain, **sockets)
        return node._out

    @classmethod
    def collection_info(cls,
                    collection: Collection = None,
                    separate_children: Boolean = None,
                    reset_children: Boolean = None,
                    transform_space: Literal['ORIGINAL', 'RELATIVE'] = 'ORIGINAL'):
        """ > Node Collection Info

        Parameters
        ----------
        collection : Collection, optional
            socket 'Collection' (id: Collection)

        separate_children : Boolean, optional
            socket 'Separate Children' (id: Separate Children)

        reset_children : Boolean, optional
            socket 'Reset Children' (id: Reset Children)

        transform_space : Literal['Original', 'Relative']
            parameter `transform_space`


        Returns
        -------
        Instances
        """
        utils.check_enum_arg('Collection Info', 'transform_space', transform_space, 'collection_info', ('ORIGINAL', 'RELATIVE'))
        node = Node('Collection Info', {'Collection': collection, 'Separate Children': separate_children, 'Reset Children': reset_children}, transform_space=transform_space)
        return node._out

    @classmethod
    def convex_hull(cls, geometry: Geometry = None):
        """ > Node Convex Hull

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)


        Returns
        -------
        Mesh
        """
        node = Node('Convex Hull', {'Geometry': geometry})
        return node._out

    @classmethod
    def corners_of_edge(cls,
                    edge_index: Integer = None,
                    weights: Float = None,
                    sort_index: Integer = None):
        """ > Node Corners of Edge

        Parameters
        ----------
        edge_index : Integer, optional
            socket 'Edge Index' (id: Edge Index)

        weights : Float, optional
            socket 'Weights' (id: Weights)

        sort_index : Integer, optional
            socket 'Sort Index' (id: Sort Index)


        Returns
        -------
        Integer
            peer sockets: total_ (Integer)

        """
        node = Node('Corners of Edge', {'Edge Index': edge_index, 'Weights': weights, 'Sort Index': sort_index})
        return node._out

    @classmethod
    def corners_of_face(cls,
                    face_index: Integer = None,
                    weights: Float = None,
                    sort_index: Integer = None):
        """ > Node Corners of Face

        Parameters
        ----------
        face_index : Integer, optional
            socket 'Face Index' (id: Face Index)

        weights : Float, optional
            socket 'Weights' (id: Weights)

        sort_index : Integer, optional
            socket 'Sort Index' (id: Sort Index)


        Returns
        -------
        Integer
            peer sockets: total_ (Integer)

        """
        node = Node('Corners of Face', {'Face Index': face_index, 'Weights': weights, 'Sort Index': sort_index})
        return node._out

    @classmethod
    def corners_of_vertex(cls,
                    vertex_index: Integer = None,
                    weights: Float = None,
                    sort_index: Integer = None):
        """ > Node Corners of Vertex

        Parameters
        ----------
        vertex_index : Integer, optional
            socket 'Vertex Index' (id: Vertex Index)

        weights : Float, optional
            socket 'Weights' (id: Weights)

        sort_index : Integer, optional
            socket 'Sort Index' (id: Sort Index)


        Returns
        -------
        Integer
            peer sockets: total_ (Integer)

        """
        node = Node('Corners of Vertex', {'Vertex Index': vertex_index, 'Weights': weights, 'Sort Index': sort_index})
        return node._out

    @classmethod
    def cube_grid_topology(cls,
                    bounds_min: Vector = None,
                    bounds_max: Vector = None,
                    resolution_x: Integer = None,
                    resolution_y: Integer = None,
                    resolution_z: Integer = None,
                    min_x: Integer = None,
                    min_y: Integer = None,
                    min_z: Integer = None):
        """ > Node Cube Grid Topology

        Parameters
        ----------
        bounds_min : Vector, optional
            socket 'Bounds Min' (id: Bounds Min)

        bounds_max : Vector, optional
            socket 'Bounds Max' (id: Bounds Max)

        resolution_x : Integer, optional
            socket 'Resolution X' (id: Resolution X)

        resolution_y : Integer, optional
            socket 'Resolution Y' (id: Resolution Y)

        resolution_z : Integer, optional
            socket 'Resolution Z' (id: Resolution Z)

        min_x : Integer, optional
            socket 'Min X' (id: Min X)

        min_y : Integer, optional
            socket 'Min Y' (id: Min Y)

        min_z : Integer, optional
            socket 'Min Z' (id: Min Z)


        Returns
        -------
        Boolean
        """
        node = Node('Cube Grid Topology', {'Bounds Min': bounds_min, 'Bounds Max': bounds_max, 'Resolution X': resolution_x, 'Resolution Y': resolution_y, 'Resolution Z': resolution_z, 'Min X': min_x, 'Min Y': min_y, 'Min Z': min_z})
        return node._out

    @classmethod
    def arc(cls,
                    resolution: Integer = None,
                    start: Vector = None,
                    middle: Vector = None,
                    end: Vector = None,
                    radius: Float = None,
                    start_angle: Float = None,
                    sweep_angle: Float = None,
                    offset_angle: Float = None,
                    connect_center: Boolean = None,
                    invert_arc: Boolean = None,
                    mode: Literal['POINTS', 'RADIUS'] = 'RADIUS'):
        """ > Node Arc

        Parameters
        ----------
        resolution : Integer, optional
            socket 'Resolution' (id: Resolution)

        start : Vector, optional
            socket 'Start' (id: Start)

        middle : Vector, optional
            socket 'Middle' (id: Middle)

        end : Vector, optional
            socket 'End' (id: End)

        radius : Float, optional
            socket 'Radius' (id: Radius)

        start_angle : Float, optional
            socket 'Start Angle' (id: Start Angle)

        sweep_angle : Float, optional
            socket 'Sweep Angle' (id: Sweep Angle)

        offset_angle : Float, optional
            socket 'Offset Angle' (id: Offset Angle)

        connect_center : Boolean, optional
            socket 'Connect Center' (id: Connect Center)

        invert_arc : Boolean, optional
            socket 'Invert Arc' (id: Invert Arc)

        mode : Literal['Points', 'Radius']
            parameter `mode`


        Returns
        -------
        Curve
        """
        utils.check_enum_arg('Arc', 'mode', mode, 'arc', ('POINTS', 'RADIUS'))
        node = Node('Arc', {'Resolution': resolution, 'Start': start, 'Middle': middle, 'End': end, 'Radius': radius, 'Start Angle': start_angle, 'Sweep Angle': sweep_angle, 'Offset Angle': offset_angle, 'Connect Center': connect_center, 'Invert Arc': invert_arc}, mode=mode)
        return node._out

    @classmethod
    def endpoint_selection(cls, start_size: Integer = None, end_size: Integer = None):
        """ > Node Endpoint Selection

        Parameters
        ----------
        start_size : Integer, optional
            socket 'Start Size' (id: Start Size)

        end_size : Integer, optional
            socket 'End Size' (id: End Size)


        Returns
        -------
        Boolean
        """
        node = Node('Endpoint Selection', {'Start Size': start_size, 'End Size': end_size})
        return node._out

    @classmethod
    def handle_type_selection(cls,
                    handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO',
                    mode = {'LEFT', 'RIGHT'}):
        """ > Node Handle Type Selection

        Parameters
        ----------
        handle_type : Literal['Free', 'Auto', 'Vector', 'Align']
            parameter `handle_type`

        mode : set
            parameter `mode`


        Returns
        -------
        Boolean
        """
        utils.check_enum_arg('Handle Type Selection', 'handle_type', handle_type, 'handle_type_selection', ('FREE', 'AUTO', 'VECTOR', 'ALIGN'))
        node = Node('Handle Type Selection', handle_type=handle_type, mode=mode)
        return node._out

    @classmethod
    def curve_length(cls, curve: Curve = None):
        """ > Node Curve Length

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)


        Returns
        -------
        Float
        """
        node = Node('Curve Length', {'Curve': curve})
        return node._out

    @classmethod
    def curve_of_point(cls, point_index: Integer = None):
        """ > Node Curve of Point

        Parameters
        ----------
        point_index : Integer, optional
            socket 'Point Index' (id: Point Index)


        Returns
        -------
        Integer
            peer sockets: index_in_curve_ (Integer)

        """
        node = Node('Curve of Point', {'Point Index': point_index})
        return node._out

    @classmethod
    def bezier_segment(cls,
                    resolution: Integer = None,
                    start: Vector = None,
                    start_handle: Vector = None,
                    end_handle: Vector = None,
                    end: Vector = None,
                    mode: Literal['POSITION', 'OFFSET'] = 'POSITION'):
        """ > Node Bézier Segment

        Parameters
        ----------
        resolution : Integer, optional
            socket 'Resolution' (id: Resolution)

        start : Vector, optional
            socket 'Start' (id: Start)

        start_handle : Vector, optional
            socket 'Start Handle' (id: Start Handle)

        end_handle : Vector, optional
            socket 'End Handle' (id: End Handle)

        end : Vector, optional
            socket 'End' (id: End)

        mode : Literal['Position', 'Offset']
            parameter `mode`


        Returns
        -------
        Curve
        """
        utils.check_enum_arg('Bézier Segment', 'mode', mode, 'bezier_segment', ('POSITION', 'OFFSET'))
        node = Node('Bézier Segment', {'Resolution': resolution, 'Start': start, 'Start Handle': start_handle, 'End Handle': end_handle, 'End': end}, mode=mode)
        return node._out

    @classmethod
    def curve_circle(cls,
                    resolution: Integer = None,
                    point_1: Vector = None,
                    point_2: Vector = None,
                    point_3: Vector = None,
                    radius: Float = None,
                    mode: Literal['POINTS', 'RADIUS'] = 'RADIUS'):
        """ > Node Curve Circle

        Parameters
        ----------
        resolution : Integer, optional
            socket 'Resolution' (id: Resolution)

        point_1 : Vector, optional
            socket 'Point 1' (id: Point 1)

        point_2 : Vector, optional
            socket 'Point 2' (id: Point 2)

        point_3 : Vector, optional
            socket 'Point 3' (id: Point 3)

        radius : Float, optional
            socket 'Radius' (id: Radius)

        mode : Literal['Points', 'Radius']
            parameter `mode`


        Returns
        -------
        Curve
        """
        utils.check_enum_arg('Curve Circle', 'mode', mode, 'curve_circle', ('POINTS', 'RADIUS'))
        node = Node('Curve Circle', {'Resolution': resolution, 'Point 1': point_1, 'Point 2': point_2, 'Point 3': point_3, 'Radius': radius}, mode=mode)
        return node._out

    @classmethod
    def curve_line(cls,
                    start: Vector = None,
                    end: Vector = None,
                    direction: Vector = None,
                    length: Float = None,
                    mode: Literal['POINTS', 'DIRECTION'] = 'POINTS'):
        """ > Node Curve Line

        Parameters
        ----------
        start : Vector, optional
            socket 'Start' (id: Start)

        end : Vector, optional
            socket 'End' (id: End)

        direction : Vector, optional
            socket 'Direction' (id: Direction)

        length : Float, optional
            socket 'Length' (id: Length)

        mode : Literal['Points', 'Direction']
            parameter `mode`


        Returns
        -------
        Curve
        """
        utils.check_enum_arg('Curve Line', 'mode', mode, 'curve_line', ('POINTS', 'DIRECTION'))
        node = Node('Curve Line', {'Start': start, 'End': end, 'Direction': direction, 'Length': length}, mode=mode)
        return node._out

    @classmethod
    def quadrilateral(cls,
                    width: Float = None,
                    height: Float = None,
                    bottom_width: Float = None,
                    top_width: Float = None,
                    offset: Float = None,
                    bottom_height: Float = None,
                    top_height: Float = None,
                    point_1: Vector = None,
                    point_2: Vector = None,
                    point_3: Vector = None,
                    point_4: Vector = None,
                    mode: Literal['RECTANGLE', 'PARALLELOGRAM', 'TRAPEZOID', 'KITE', 'POINTS'] = 'RECTANGLE'):
        """ > Node Quadrilateral

        Parameters
        ----------
        width : Float, optional
            socket 'Width' (id: Width)

        height : Float, optional
            socket 'Height' (id: Height)

        bottom_width : Float, optional
            socket 'Bottom Width' (id: Bottom Width)

        top_width : Float, optional
            socket 'Top Width' (id: Top Width)

        offset : Float, optional
            socket 'Offset' (id: Offset)

        bottom_height : Float, optional
            socket 'Bottom Height' (id: Bottom Height)

        top_height : Float, optional
            socket 'Top Height' (id: Top Height)

        point_1 : Vector, optional
            socket 'Point 1' (id: Point 1)

        point_2 : Vector, optional
            socket 'Point 2' (id: Point 2)

        point_3 : Vector, optional
            socket 'Point 3' (id: Point 3)

        point_4 : Vector, optional
            socket 'Point 4' (id: Point 4)

        mode : Literal['Rectangle', 'Parallelogram', 'Trapezoid', 'Kite', 'Points']
            parameter `mode`


        Returns
        -------
        Curve
        """
        utils.check_enum_arg('Quadrilateral', 'mode', mode, 'quadrilateral', ('RECTANGLE', 'PARALLELOGRAM', 'TRAPEZOID', 'KITE', 'POINTS'))
        node = Node('Quadrilateral', {'Width': width, 'Height': height, 'Bottom Width': bottom_width, 'Top Width': top_width, 'Offset': offset, 'Bottom Height': bottom_height, 'Top Height': top_height, 'Point 1': point_1, 'Point 2': point_2, 'Point 3': point_3, 'Point 4': point_4}, mode=mode)
        return node._out

    @classmethod
    def quadratic_bezier(cls,
                    resolution: Integer = None,
                    start: Vector = None,
                    middle: Vector = None,
                    end: Vector = None):
        """ > Node Quadratic Bézier

        Parameters
        ----------
        resolution : Integer, optional
            socket 'Resolution' (id: Resolution)

        start : Vector, optional
            socket 'Start' (id: Start)

        middle : Vector, optional
            socket 'Middle' (id: Middle)

        end : Vector, optional
            socket 'End' (id: End)


        Returns
        -------
        Curve
        """
        node = Node('Quadratic Bézier', {'Resolution': resolution, 'Start': start, 'Middle': middle, 'End': end})
        return node._out

    @classmethod
    def set_handle_type(cls,
                    curve: Curve = None,
                    selection: Boolean = None,
                    handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO',
                    mode = {'LEFT', 'RIGHT'}):
        """ > Node Set Handle Type

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        handle_type : Literal['Free', 'Auto', 'Vector', 'Align']
            parameter `handle_type`

        mode : set
            parameter `mode`


        Returns
        -------
        Curve
        """
        utils.check_enum_arg('Set Handle Type', 'handle_type', handle_type, 'set_handle_type', ('FREE', 'AUTO', 'VECTOR', 'ALIGN'))
        node = Node('Set Handle Type', {'Curve': curve, 'Selection': selection}, handle_type=handle_type, mode=mode)
        return node._out

    @classmethod
    def spiral(cls,
                    resolution: Integer = None,
                    rotations: Float = None,
                    start_radius: Float = None,
                    end_radius: Float = None,
                    height: Float = None,
                    reverse: Boolean = None):
        """ > Node Spiral

        Parameters
        ----------
        resolution : Integer, optional
            socket 'Resolution' (id: Resolution)

        rotations : Float, optional
            socket 'Rotations' (id: Rotations)

        start_radius : Float, optional
            socket 'Start Radius' (id: Start Radius)

        end_radius : Float, optional
            socket 'End Radius' (id: End Radius)

        height : Float, optional
            socket 'Height' (id: Height)

        reverse : Boolean, optional
            socket 'Reverse' (id: Reverse)


        Returns
        -------
        Curve
        """
        node = Node('Spiral', {'Resolution': resolution, 'Rotations': rotations, 'Start Radius': start_radius, 'End Radius': end_radius, 'Height': height, 'Reverse': reverse})
        return node._out

    @classmethod
    def set_spline_type(cls,
                    curve: Curve = None,
                    selection: Boolean = None,
                    spline_type: Literal['CATMULL_ROM', 'POLY', 'BEZIER', 'NURBS'] = 'POLY'):
        """ > Node Set Spline Type

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        spline_type : Literal['Catmull Rom', 'Poly', 'Bézier', 'NURBS']
            parameter `spline_type`


        Returns
        -------
        Curve
        """
        utils.check_enum_arg('Set Spline Type', 'spline_type', spline_type, 'set_spline_type', ('CATMULL_ROM', 'POLY', 'BEZIER', 'NURBS'))
        node = Node('Set Spline Type', {'Curve': curve, 'Selection': selection}, spline_type=spline_type)
        return node._out

    @classmethod
    def star(cls,
                    points: Integer = None,
                    inner_radius: Float = None,
                    outer_radius: Float = None,
                    twist: Float = None):
        """ > Node Star

        Parameters
        ----------
        points : Integer, optional
            socket 'Points' (id: Points)

        inner_radius : Float, optional
            socket 'Inner Radius' (id: Inner Radius)

        outer_radius : Float, optional
            socket 'Outer Radius' (id: Outer Radius)

        twist : Float, optional
            socket 'Twist' (id: Twist)


        Returns
        -------
        Curve
            peer sockets: outer_points_ (Boolean)

        """
        node = Node('Star', {'Points': points, 'Inner Radius': inner_radius, 'Outer Radius': outer_radius, 'Twist': twist})
        return node._out

    @classmethod
    def curve_to_mesh(cls,
                    curve: Curve = None,
                    profile_curve: Curve = None,
                    scale: Float = None,
                    fill_caps: Boolean = None):
        """ > Node Curve to Mesh

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        profile_curve : Curve, optional
            socket 'Profile Curve' (id: Profile Curve)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        fill_caps : Boolean, optional
            socket 'Fill Caps' (id: Fill Caps)


        Returns
        -------
        Mesh
        """
        node = Node('Curve to Mesh', {'Curve': curve, 'Profile Curve': profile_curve, 'Scale': scale, 'Fill Caps': fill_caps})
        return node._out

    @classmethod
    def curve_to_points(cls,
                    curve: Curve = None,
                    count: Integer = None,
                    length: Float = None,
                    mode: Literal['EVALUATED', 'COUNT', 'LENGTH'] = 'COUNT'):
        """ > Node Curve to Points

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        count : Integer, optional
            socket 'Count' (id: Count)

        length : Float, optional
            socket 'Length' (id: Length)

        mode : Literal['Evaluated', 'Count', 'Length']
            parameter `mode`


        Returns
        -------
        Cloud
            peer sockets: tangent_ (Vector), normal_ (Vector), rotation_ (Rotation)

        """
        utils.check_enum_arg('Curve to Points', 'mode', mode, 'curve_to_points', ('EVALUATED', 'COUNT', 'LENGTH'))
        node = Node('Curve to Points', {'Curve': curve, 'Count': count, 'Length': length}, mode=mode)
        return node._out

    @classmethod
    def curves_to_grease_pencil(cls,
                    curves: Curve = None,
                    selection: Boolean = None,
                    instances_as_layers: Boolean = None):
        """ > Node Curves to Grease Pencil

        Parameters
        ----------
        curves : Curve, optional
            socket 'Curves' (id: Curves)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        instances_as_layers : Boolean, optional
            socket 'Instances as Layers' (id: Instances as Layers)


        Returns
        -------
        GreasePencil
        """
        node = Node('Curves to Grease Pencil', {'Curves': curves, 'Selection': selection, 'Instances as Layers': instances_as_layers})
        return node._out

    @classmethod
    def deform_curves_on_surface(cls, curves: Curve = None):
        """ > Node Deform Curves on Surface

        Parameters
        ----------
        curves : Curve, optional
            socket 'Curves' (id: Curves)


        Returns
        -------
        Curve
        """
        node = Node('Deform Curves on Surface', {'Curves': curves})
        return node._out

    @classmethod
    def delete_geometry(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT',
                    mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL'):
        """ > Node Delete Geometry

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        domain : Literal['Point', 'Edge', 'Face', 'Spline', 'Instance', 'Layer']
            parameter `domain`

        mode : Literal['All', 'Only Edges & Faces', 'Only Faces']
            parameter `mode`


        Returns
        -------
        Geometry
        """
        utils.check_enum_arg('Delete Geometry', 'domain', domain, 'delete_geometry', ('POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'))
        utils.check_enum_arg('Delete Geometry', 'mode', mode, 'delete_geometry', ('ALL', 'EDGE_FACE', 'ONLY_FACE'))
        node = Node('Delete Geometry', {'Geometry': geometry, 'Selection': selection}, domain=domain, mode=mode)
        return node._out

    @classmethod
    def distribute_points_in_grid(cls,
                    grid: Float = None,
                    density: Float = None,
                    seed: Integer = None,
                    spacing: Vector = None,
                    threshold: Float = None,
                    mode: Literal['DENSITY_RANDOM', 'DENSITY_GRID'] = 'DENSITY_RANDOM'):
        """ > Node Distribute Points in Grid

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        density : Float, optional
            socket 'Density' (id: Density)

        seed : Integer, optional
            socket 'Seed' (id: Seed)

        spacing : Vector, optional
            socket 'Spacing' (id: Spacing)

        threshold : Float, optional
            socket 'Threshold' (id: Threshold)

        mode : Literal['Random', 'Grid']
            parameter `mode`


        Returns
        -------
        Cloud
        """
        utils.check_enum_arg('Distribute Points in Grid', 'mode', mode, 'distribute_points_in_grid', ('DENSITY_RANDOM', 'DENSITY_GRID'))
        node = Node('Distribute Points in Grid', {'Grid': grid, 'Density': density, 'Seed': seed, 'Spacing': spacing, 'Threshold': threshold}, mode=mode)
        return node._out

    @classmethod
    def distribute_points_in_volume(cls,
                    volume: Volume = None,
                    mode: Literal['Random', 'Grid'] = None,
                    density: Float = None,
                    seed: Integer = None,
                    spacing: Vector = None,
                    threshold: Float = None):
        """ > Node Distribute Points in Volume

        Parameters
        ----------
        volume : Volume, optional
            socket 'Volume' (id: Volume)

        mode : menu='Random', optional
            ('Random', 'Grid')

        density : Float, optional
            socket 'Density' (id: Density)

        seed : Integer, optional
            socket 'Seed' (id: Seed)

        spacing : Vector, optional
            socket 'Spacing' (id: Spacing)

        threshold : Float, optional
            socket 'Threshold' (id: Threshold)


        Returns
        -------
        Cloud
        """
        node = Node('Distribute Points in Volume', {'Volume': volume, 'Mode': mode, 'Density': density, 'Seed': seed, 'Spacing': spacing, 'Threshold': threshold})
        return node._out

    @classmethod
    def distribute_points_on_faces(cls,
                    mesh: Mesh = None,
                    selection: Boolean = None,
                    distance_min: Float = None,
                    density_max: Float = None,
                    density: Float = None,
                    density_factor: Float = None,
                    seed: Integer = None,
                    distribute_method: Literal['RANDOM', 'POISSON'] = 'RANDOM'):
        """ > Node Distribute Points on Faces

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        distance_min : Float, optional
            socket 'Distance Min' (id: Distance Min)

        density_max : Float, optional
            socket 'Density Max' (id: Density Max)

        density : Float, optional
            socket 'Density' (id: Density)

        density_factor : Float, optional
            socket 'Density Factor' (id: Density Factor)

        seed : Integer, optional
            socket 'Seed' (id: Seed)

        distribute_method : Literal['Random', 'Poisson Disk']
            parameter `distribute_method`


        Returns
        -------
        Cloud
            peer sockets: normal_ (Vector), rotation_ (Rotation)

        """
        utils.check_enum_arg('Distribute Points on Faces', 'distribute_method', distribute_method, 'distribute_points_on_faces', ('RANDOM', 'POISSON'))
        node = Node('Distribute Points on Faces', {'Mesh': mesh, 'Selection': selection, 'Distance Min': distance_min, 'Density Max': density_max, 'Density': density, 'Density Factor': density_factor, 'Seed': seed}, distribute_method=distribute_method)
        return node._out

    @classmethod
    def dual_mesh(cls, mesh: Mesh = None, keep_boundaries: Boolean = None):
        """ > Node Dual Mesh

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        keep_boundaries : Boolean, optional
            socket 'Keep Boundaries' (id: Keep Boundaries)


        Returns
        -------
        Mesh
        """
        node = Node('Dual Mesh', {'Mesh': mesh, 'Keep Boundaries': keep_boundaries})
        return node._out

    @classmethod
    def duplicate_elements(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    amount: Integer = None,
                    domain: Literal['POINT', 'EDGE', 'FACE', 'SPLINE', 'LAYER', 'INSTANCE'] = 'POINT'):
        """ > Node Duplicate Elements

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        amount : Integer, optional
            socket 'Amount' (id: Amount)

        domain : Literal['Point', 'Edge', 'Face', 'Spline', 'Layer', 'Instance']
            parameter `domain`


        Returns
        -------
        Geometry
            peer sockets: duplicate_index_ (Integer)

        """
        utils.check_enum_arg('Duplicate Elements', 'domain', domain, 'duplicate_elements', ('POINT', 'EDGE', 'FACE', 'SPLINE', 'LAYER', 'INSTANCE'))
        node = Node('Duplicate Elements', {'Geometry': geometry, 'Selection': selection, 'Amount': amount}, domain=domain)
        return node._out

    @classmethod
    def edge_paths_to_curves(cls,
                    mesh: Mesh = None,
                    start_vertices: Boolean = None,
                    next_vertex_index: Integer = None):
        """ > Node Edge Paths to Curves

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        start_vertices : Boolean, optional
            socket 'Start Vertices' (id: Start Vertices)

        next_vertex_index : Integer, optional
            socket 'Next Vertex Index' (id: Next Vertex Index)


        Returns
        -------
        Curve
        """
        node = Node('Edge Paths to Curves', {'Mesh': mesh, 'Start Vertices': start_vertices, 'Next Vertex Index': next_vertex_index})
        return node._out

    @classmethod
    def edge_paths_to_selection(cls, start_vertices: Boolean = None, next_vertex_index: Integer = None):
        """ > Node Edge Paths to Selection

        Parameters
        ----------
        start_vertices : Boolean, optional
            socket 'Start Vertices' (id: Start Vertices)

        next_vertex_index : Integer, optional
            socket 'Next Vertex Index' (id: Next Vertex Index)


        Returns
        -------
        Boolean
        """
        node = Node('Edge Paths to Selection', {'Start Vertices': start_vertices, 'Next Vertex Index': next_vertex_index})
        return node._out

    @classmethod
    def edges_of_corner(cls, corner_index: Integer = None):
        """ > Node Edges of Corner

        Parameters
        ----------
        corner_index : Integer, optional
            socket 'Corner Index' (id: Corner Index)


        Returns
        -------
        Integer
            peer sockets: previous_edge_index_ (Integer)

        """
        node = Node('Edges of Corner', {'Corner Index': corner_index})
        return node._out

    @classmethod
    def edges_of_vertex(cls,
                    vertex_index: Integer = None,
                    weights: Float = None,
                    sort_index: Integer = None):
        """ > Node Edges of Vertex

        Parameters
        ----------
        vertex_index : Integer, optional
            socket 'Vertex Index' (id: Vertex Index)

        weights : Float, optional
            socket 'Weights' (id: Weights)

        sort_index : Integer, optional
            socket 'Sort Index' (id: Sort Index)


        Returns
        -------
        Integer
            peer sockets: total_ (Integer)

        """
        node = Node('Edges of Vertex', {'Vertex Index': vertex_index, 'Weights': weights, 'Sort Index': sort_index})
        return node._out

    @classmethod
    def edges_to_face_groups(cls, boundary_edges: Boolean = None):
        """ > Node Edges to Face Groups

        Parameters
        ----------
        boundary_edges : Boolean, optional
            socket 'Boundary Edges' (id: Boundary Edges)


        Returns
        -------
        Integer
        """
        node = Node('Edges to Face Groups', {'Boundary Edges': boundary_edges})
        return node._out

    @classmethod
    def extrude_mesh(cls,
                    mesh: Mesh = None,
                    selection: Boolean = None,
                    offset: Vector = None,
                    offset_scale: Float = None,
                    individual: Boolean = None,
                    mode: Literal['VERTICES', 'EDGES', 'FACES'] = 'FACES'):
        """ > Node Extrude Mesh

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        offset : Vector, optional
            socket 'Offset' (id: Offset)

        offset_scale : Float, optional
            socket 'Offset Scale' (id: Offset Scale)

        individual : Boolean, optional
            socket 'Individual' (id: Individual)

        mode : Literal['Vertices', 'Edges', 'Faces']
            parameter `mode`


        Returns
        -------
        Mesh
            peer sockets: top_ (Boolean), side_ (Boolean)

        """
        utils.check_enum_arg('Extrude Mesh', 'mode', mode, 'extrude_mesh', ('VERTICES', 'EDGES', 'FACES'))
        node = Node('Extrude Mesh', {'Mesh': mesh, 'Selection': selection, 'Offset': offset, 'Offset Scale': offset_scale, 'Individual': individual}, mode=mode)
        return node._out

    @classmethod
    def face_of_corner(cls, corner_index: Integer = None):
        """ > Node Face of Corner

        Parameters
        ----------
        corner_index : Integer, optional
            socket 'Corner Index' (id: Corner Index)


        Returns
        -------
        Integer
            peer sockets: index_in_face_ (Integer)

        """
        node = Node('Face of Corner', {'Corner Index': corner_index})
        return node._out

    @classmethod
    def evaluate_at_index(cls,
                    value: Float = None,
                    index: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
        """ > Node Evaluate at Index

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        index : Integer, optional
            socket 'Index' (id: Index)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
            parameter `data_type`

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Evaluate at Index', 'domain', domain, 'evaluate_at_index', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Evaluate at Index', {'Value': value, 'Index': index}, data_type=data_type, domain=domain)
        return node._out

    @classmethod
    def field_average(cls,
                    value: Float = None,
                    group_id: Integer = None,
                    data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
        """ > Node Field Average

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        group_id : Integer, optional
            socket 'Group ID' (id: Group Index)

        data_type : Literal['Float', 'Vector']
            parameter `data_type`

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Float
            peer sockets: median_ (Float)

        """
        utils.check_enum_arg('Field Average', 'domain', domain, 'field_average', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Field Average', {'Value': value, 'Group Index': group_id}, data_type=data_type, domain=domain)
        return node._out

    @classmethod
    def field_min_max(cls,
                    value: Float = None,
                    group_id: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'FLOAT_VECTOR'] = 'FLOAT',
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
        """ > Node Field Min & Max

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        group_id : Integer, optional
            socket 'Group ID' (id: Group Index)

        data_type : Literal['Float', 'Integer', 'Vector']
            parameter `data_type`

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Float
            peer sockets: max_ (Float)

        """
        utils.check_enum_arg('Field Min & Max', 'domain', domain, 'field_min_max', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Field Min & Max', {'Value': value, 'Group Index': group_id}, data_type=data_type, domain=domain)
        return node._out

    @classmethod
    def evaluate_on_domain(cls,
                    value: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
        """ > Node Evaluate on Domain

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
            parameter `data_type`

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Evaluate on Domain', 'domain', domain, 'evaluate_on_domain', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Evaluate on Domain', {'Value': value}, data_type=data_type, domain=domain)
        return node._out

    @classmethod
    def field_to_grid(cls,
                    named_sockets: dict = {},
                    topology: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT',
                    **sockets):
        """ > Node Field to Grid

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        topology : Float, optional
            socket 'Topology' (id: Topology)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        None
        """
        node = Node('Field to Grid', {'Topology': topology, **named_sockets}, data_type=data_type, **sockets)
        return node._out

    @classmethod
    def field_to_list(cls, named_sockets: dict = {}, count: Integer = None, **sockets):
        """ > Node Field to List

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        count : Integer, optional
            socket 'Count' (id: Count)

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        None
        """
        node = Node('Field to List', {'Count': count, **named_sockets}, **sockets)
        return node._out

    @classmethod
    def field_variance(cls,
                    value: Float = None,
                    group_id: Integer = None,
                    data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
        """ > Node Field Variance

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        group_id : Integer, optional
            socket 'Group ID' (id: Group Index)

        data_type : Literal['Float', 'Vector']
            parameter `data_type`

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Float
            peer sockets: variance_ (Float)

        """
        utils.check_enum_arg('Field Variance', 'domain', domain, 'field_variance', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Field Variance', {'Value': value, 'Group Index': group_id}, data_type=data_type, domain=domain)
        return node._out

    @classmethod
    def fill_curve(cls,
                    curve: Curve = None,
                    group_id: Integer = None,
                    mode: Literal['Triangles', 'N-gons'] = None,
                    fill_rule: Literal['Even-Odd', 'Non-Zero'] = None):
        """ > Node Fill Curve

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        group_id : Integer, optional
            socket 'Group ID' (id: Group ID)

        mode : menu='Triangles', optional
            ('Triangles', 'N-gons')

        fill_rule : menu='Even-Odd', optional
            ('Even-Odd', 'Non-Zero')


        Returns
        -------
        Mesh
        """
        node = Node('Fill Curve', {'Curve': curve, 'Group ID': group_id, 'Mode': mode, 'Fill Rule': fill_rule})
        return node._out

    @classmethod
    def fillet_curve(cls,
                    curve: Curve = None,
                    radius: Float = None,
                    limit_radius: Boolean = None,
                    mode: Literal['Bézier', 'Poly'] = None,
                    count: Integer = None):
        """ > Node Fillet Curve

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        radius : Float, optional
            socket 'Radius' (id: Radius)

        limit_radius : Boolean, optional
            socket 'Limit Radius' (id: Limit Radius)

        mode : menu='Bézier', optional
            ('Bézier', 'Poly')

        count : Integer, optional
            socket 'Count' (id: Count)


        Returns
        -------
        Curve
        """
        node = Node('Fillet Curve', {'Curve': curve, 'Radius': radius, 'Limit Radius': limit_radius, 'Mode': mode, 'Count': count})
        return node._out

    @classmethod
    def flip_faces(cls, mesh: Mesh = None, selection: Boolean = None):
        """ > Node Flip Faces

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)


        Returns
        -------
        Mesh
        """
        node = Node('Flip Faces', {'Mesh': mesh, 'Selection': selection})
        return node._out

    @classmethod
    def for_each_geometry_element_input(cls, geometry: Geometry = None, selection: Boolean = None):
        """ > Node For Each Geometry Element Input

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)


        Returns
        -------
        Integer
        """
        node = Node('For Each Geometry Element Input', {'Geometry': geometry, 'Selection': selection})
        return node._out

    @classmethod
    def for_each_geometry_element_output(cls,
                    geometry: Geometry = None,
                    active_generation_index = 0,
                    active_input_index = 0,
                    active_main_index = 0,
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT',
                    inspection_index = 0):
        """ > Node For Each Geometry Element Output

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Generation_0)

        active_generation_index : int
            parameter `active_generation_index`

        active_input_index : int
            parameter `active_input_index`

        active_main_index : int
            parameter `active_main_index`

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`

        inspection_index : int
            parameter `inspection_index`


        Returns
        -------
        Geometry
        """
        utils.check_enum_arg('For Each Geometry Element Output', 'domain', domain, 'for_each_geometry_element_output', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('For Each Geometry Element Output', {'Generation_0': geometry}, active_generation_index=active_generation_index, active_input_index=active_input_index, active_main_index=active_main_index, domain=domain, inspection_index=inspection_index)
        return node._out

    @classmethod
    def geometry_to_instance(cls, *geometry: Geometry):
        """ > Node Geometry to Instance

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)


        Returns
        -------
        Instances
        """
        node = Node('Geometry to Instance', {'Geometry': list(geometry)})
        return node._out

    @classmethod
    def get_geometry_bundle(cls, geometry: Geometry = None, remove: Boolean = None):
        """ > Node Get Geometry Bundle

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        remove : Boolean, optional
            socket 'Remove' (id: Remove)


        Returns
        -------
        Geometry
            peer sockets: bundle_ (Bundle)

        """
        node = Node('Get Geometry Bundle', {'Geometry': geometry, 'Remove': remove})
        return node._out

    @classmethod
    def get_named_grid(cls,
                    volume: Volume = None,
                    name: String = None,
                    remove: Boolean = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Get Named Grid

        Parameters
        ----------
        volume : Volume, optional
            socket 'Volume' (id: Volume)

        name : String, optional
            socket 'Name' (id: Name)

        remove : Boolean, optional
            socket 'Remove' (id: Remove)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Volume
            peer sockets: grid_ (Float)

        """
        node = Node('Get Named Grid', {'Volume': volume, 'Name': name, 'Remove': remove}, data_type=data_type)
        return node._out

    @classmethod
    def dial_gizmo(cls,
                    *value: Float,
                    position: Vector = None,
                    up: Vector = None,
                    screen_space: Boolean = None,
                    radius: Float = None,
                    color_id: Literal['PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'] = 'PRIMARY'):
        """ > Node Dial Gizmo

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        position : Vector, optional
            socket 'Position' (id: Position)

        up : Vector, optional
            socket 'Up' (id: Up)

        screen_space : Boolean, optional
            socket 'Screen Space' (id: Screen Space)

        radius : Float, optional
            socket 'Radius' (id: Radius)

        color_id : Literal['Primary', 'Secondary', 'X', 'Y', 'Z']
            parameter `color_id`


        Returns
        -------
        Geometry
        """
        utils.check_enum_arg('Dial Gizmo', 'color_id', color_id, 'dial_gizmo', ('PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'))
        node = Node('Dial Gizmo', {'Value': list(value), 'Position': position, 'Up': up, 'Screen Space': screen_space, 'Radius': radius}, color_id=color_id)
        return node._out

    @classmethod
    def linear_gizmo(cls,
                    *value: Float,
                    position: Vector = None,
                    direction: Vector = None,
                    color_id: Literal['PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'] = 'PRIMARY',
                    draw_style: Literal['ARROW', 'CROSS', 'BOX'] = 'ARROW'):
        """ > Node Linear Gizmo

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        position : Vector, optional
            socket 'Position' (id: Position)

        direction : Vector, optional
            socket 'Direction' (id: Direction)

        color_id : Literal['Primary', 'Secondary', 'X', 'Y', 'Z']
            parameter `color_id`

        draw_style : Literal['Arrow', 'Cross', 'Box']
            parameter `draw_style`


        Returns
        -------
        Geometry
        """
        utils.check_enum_arg('Linear Gizmo', 'color_id', color_id, 'linear_gizmo', ('PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'))
        utils.check_enum_arg('Linear Gizmo', 'draw_style', draw_style, 'linear_gizmo', ('ARROW', 'CROSS', 'BOX'))
        node = Node('Linear Gizmo', {'Value': list(value), 'Position': position, 'Direction': direction}, color_id=color_id, draw_style=draw_style)
        return node._out

    @classmethod
    def transform_gizmo(cls,
                    *value: Matrix,
                    position: Vector = None,
                    rotation: Rotation = None,
                    use_rotation_x = True,
                    use_rotation_y = True,
                    use_rotation_z = True,
                    use_scale_x = True,
                    use_scale_y = True,
                    use_scale_z = True,
                    use_translation_x = True,
                    use_translation_y = True,
                    use_translation_z = True):
        """ > Node Transform Gizmo

        Parameters
        ----------
        value : Matrix, optional
            socket 'Value' (id: Value)

        position : Vector, optional
            socket 'Position' (id: Position)

        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)

        use_rotation_x : bool
            parameter `use_rotation_x`

        use_rotation_y : bool
            parameter `use_rotation_y`

        use_rotation_z : bool
            parameter `use_rotation_z`

        use_scale_x : bool
            parameter `use_scale_x`

        use_scale_y : bool
            parameter `use_scale_y`

        use_scale_z : bool
            parameter `use_scale_z`

        use_translation_x : bool
            parameter `use_translation_x`

        use_translation_y : bool
            parameter `use_translation_y`

        use_translation_z : bool
            parameter `use_translation_z`


        Returns
        -------
        Geometry
        """
        node = Node('Transform Gizmo', {'Value': list(value), 'Position': position, 'Rotation': rotation}, use_rotation_x=use_rotation_x, use_rotation_y=use_rotation_y, use_rotation_z=use_rotation_z, use_scale_x=use_scale_x, use_scale_y=use_scale_y, use_scale_z=use_scale_z, use_translation_x=use_translation_x, use_translation_y=use_translation_y, use_translation_z=use_translation_z)
        return node._out

    @classmethod
    def grease_pencil_to_curves(cls,
                    grease_pencil: GreasePencil = None,
                    selection: Boolean = None,
                    layers_as_instances: Boolean = None):
        """ > Node Grease Pencil to Curves

        Parameters
        ----------
        grease_pencil : GreasePencil, optional
            socket 'Grease Pencil' (id: Grease Pencil)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        layers_as_instances : Boolean, optional
            socket 'Layers as Instances' (id: Layers as Instances)


        Returns
        -------
        Curve
        """
        node = Node('Grease Pencil to Curves', {'Grease Pencil': grease_pencil, 'Selection': selection, 'Layers as Instances': layers_as_instances})
        return node._out

    @classmethod
    def advect_grid(cls,
                    grid: Float = None,
                    velocity: Vector = None,
                    time_step: Float = None,
                    integration_scheme: Literal['Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC'] = None,
                    limiter: Literal['None', 'Clamp', 'Revert'] = None,
                    data_type: Literal['FLOAT', 'INT', 'VECTOR'] = 'FLOAT'):
        """ > Node Advect Grid

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        velocity : Vector, optional
            socket 'Velocity' (id: Velocity)

        time_step : Float, optional
            socket 'Time Step' (id: Time Step)

        integration_scheme : menu='Runge-Kutta 3', optional
            ('Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC')

        limiter : menu='Clamp', optional
            ('None', 'Clamp', 'Revert')

        data_type : Literal['Float', 'Integer', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Advect Grid', {'Grid': grid, 'Velocity': velocity, 'Time Step': time_step, 'Integration Scheme': integration_scheme, 'Limiter': limiter}, data_type=data_type)
        return node._out

    @classmethod
    def clip_grid(cls,
                    grid: Float = None,
                    min_x: Integer = None,
                    min_y: Integer = None,
                    min_z: Integer = None,
                    max_x: Integer = None,
                    max_y: Integer = None,
                    max_z: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Clip Grid

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        min_x : Integer, optional
            socket 'Min X' (id: Min X)

        min_y : Integer, optional
            socket 'Min Y' (id: Min Y)

        min_z : Integer, optional
            socket 'Min Z' (id: Min Z)

        max_x : Integer, optional
            socket 'Max X' (id: Max X)

        max_y : Integer, optional
            socket 'Max Y' (id: Max Y)

        max_z : Integer, optional
            socket 'Max Z' (id: Max Z)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Clip Grid', {'Grid': grid, 'Min X': min_x, 'Min Y': min_y, 'Min Z': min_z, 'Max X': max_x, 'Max Y': max_y, 'Max Z': max_z}, data_type=data_type)
        return node._out

    @classmethod
    def grid_curl(cls, grid: Vector = None):
        """ > Node Grid Curl

        Parameters
        ----------
        grid : Vector, optional
            socket 'Grid' (id: Grid)


        Returns
        -------
        Vector
        """
        node = Node('Grid Curl', {'Grid': grid})
        return node._out

    @classmethod
    def grid_dilate_erode(cls,
                    grid: Float = None,
                    connectivity: Literal['Face', 'Edge', 'Vertex'] = None,
                    tiles: Literal['Ignore', 'Expand', 'Preserve'] = None,
                    steps: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Grid Dilate & Erode

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        connectivity : menu='Face', optional
            ('Face', 'Edge', 'Vertex')

        tiles : menu='Preserve', optional
            ('Ignore', 'Expand', 'Preserve')

        steps : Integer, optional
            socket 'Steps' (id: Steps)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Grid Dilate & Erode', {'Grid': grid, 'Connectivity': connectivity, 'Tiles': tiles, 'Steps': steps}, data_type=data_type)
        return node._out

    @classmethod
    def grid_divergence(cls, grid: Vector = None):
        """ > Node Grid Divergence

        Parameters
        ----------
        grid : Vector, optional
            socket 'Grid' (id: Grid)


        Returns
        -------
        Float
        """
        node = Node('Grid Divergence', {'Grid': grid})
        return node._out

    @classmethod
    def grid_gradient(cls, grid: Float = None):
        """ > Node Grid Gradient

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)


        Returns
        -------
        Vector
        """
        node = Node('Grid Gradient', {'Grid': grid})
        return node._out

    @classmethod
    def grid_info(cls,
                    grid: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Grid Info

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Matrix
            peer sockets: background_value_ (Float)

        """
        node = Node('Grid Info', {'Grid': grid}, data_type=data_type)
        return node._out

    @classmethod
    def grid_laplacian(cls, grid: Float = None):
        """ > Node Grid Laplacian

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)


        Returns
        -------
        Float
        """
        node = Node('Grid Laplacian', {'Grid': grid})
        return node._out

    @classmethod
    def grid_mean(cls,
                    grid: Float = None,
                    width: Integer = None,
                    iterations: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'VECTOR'] = 'FLOAT'):
        """ > Node Grid Mean

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        width : Integer, optional
            socket 'Width' (id: Width)

        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)

        data_type : Literal['Float', 'Integer', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Grid Mean', {'Grid': grid, 'Width': width, 'Iterations': iterations}, data_type=data_type)
        return node._out

    @classmethod
    def grid_median(cls,
                    grid: Float = None,
                    width: Integer = None,
                    iterations: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'VECTOR'] = 'FLOAT'):
        """ > Node Grid Median

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        width : Integer, optional
            socket 'Width' (id: Width)

        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)

        data_type : Literal['Float', 'Integer', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Grid Median', {'Grid': grid, 'Width': width, 'Iterations': iterations}, data_type=data_type)
        return node._out

    @classmethod
    def prune_grid(cls,
                    grid: Float = None,
                    mode: Literal['Inactive', 'Threshold', 'SDF'] = None,
                    threshold: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Prune Grid

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        mode : menu='Threshold', optional
            ('Inactive', 'Threshold', 'SDF')

        threshold : Float, optional
            socket 'Threshold' (id: Threshold)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Prune Grid', {'Grid': grid, 'Mode': mode, 'Threshold': threshold}, data_type=data_type)
        return node._out

    @classmethod
    def grid_to_mesh(cls, grid: Float = None, threshold: Float = None, adaptivity: Float = None):
        """ > Node Grid to Mesh

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        threshold : Float, optional
            socket 'Threshold' (id: Threshold)

        adaptivity : Float, optional
            socket 'Adaptivity' (id: Adaptivity)


        Returns
        -------
        Mesh
        """
        node = Node('Grid to Mesh', {'Grid': grid, 'Threshold': threshold, 'Adaptivity': adaptivity})
        return node._out

    @classmethod
    def grid_to_points(cls,
                    grid: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Grid to Points

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Cloud
            peer sockets: value_ (Float), x_ (Integer), y_ (Integer), z_ (Integer), is_tile_ (Boolean), extent_ (Integer)

        """
        node = Node('Grid to Points', {'Grid': grid}, data_type=data_type)
        return node._out

    @classmethod
    def voxelize_grid(cls,
                    grid: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Voxelize Grid

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Voxelize Grid', {'Grid': grid}, data_type=data_type)
        return node._out

    @classmethod
    def group(cls, node_tree = None):
        """ > Node Group

        Parameters
        ----------
        node_tree : NoneType
            parameter `node_tree`


        Returns
        -------
        None
        """
        node = Node('Group', node_tree=node_tree)
        return node._out

    @classmethod
    def image_info(cls, image: Image = None, frame: Integer = None):
        """ > Node Image Info

        Parameters
        ----------
        image : Image, optional
            socket 'Image' (id: Image)

        frame : Integer, optional
            socket 'Frame' (id: Frame)


        Returns
        -------
        Integer
            peer sockets: height_ (Integer), has_alpha_ (Boolean), frame_count_ (Integer), fps_ (Float)

        """
        node = Node('Image Info', {'Image': image, 'Frame': frame})
        return node._out

    @classmethod
    def image_texture(cls,
                    image: Image = None,
                    vector: Vector = None,
                    frame: Integer = None,
                    extension: Literal['REPEAT', 'EXTEND', 'CLIP', 'MIRROR'] = 'REPEAT',
                    interpolation: Literal['Linear', 'Closest', 'Cubic'] = 'Linear'):
        """ > Node Image Texture

        Parameters
        ----------
        image : Image, optional
            socket 'Image' (id: Image)

        vector : Vector, optional
            socket 'Vector' (id: Vector)

        frame : Integer, optional
            socket 'Frame' (id: Frame)

        extension : Literal['Repeat', 'Extend', 'Clip', 'Mirror']
            parameter `extension`

        interpolation : Literal['Linear', 'Closest', 'Cubic']
            parameter `interpolation`


        Returns
        -------
        Color
            peer sockets: alpha_ (Float)

        """
        utils.check_enum_arg('Image Texture', 'extension', extension, 'image_texture', ('REPEAT', 'EXTEND', 'CLIP', 'MIRROR'))
        utils.check_enum_arg('Image Texture', 'interpolation', interpolation, 'image_texture', ('Linear', 'Closest', 'Cubic'))
        node = Node('Image Texture', {'Image': image, 'Vector': vector, 'Frame': frame}, extension=extension, interpolation=interpolation)
        return node._out

    @classmethod
    def import_csv(cls, path: String = None, delimiter: String = None):
        """ > Node Import CSV

        Parameters
        ----------
        path : String, optional
            socket 'Path' (id: Path)

        delimiter : String, optional
            socket 'Delimiter' (id: Delimiter)


        Returns
        -------
        Cloud
        """
        node = Node('Import CSV', {'Path': path, 'Delimiter': delimiter})
        return node._out

    @classmethod
    def import_obj(cls, path: String = None):
        """ > Node Import OBJ

        Parameters
        ----------
        path : String, optional
            socket 'Path' (id: Path)


        Returns
        -------
        Instances
        """
        node = Node('Import OBJ', {'Path': path})
        return node._out

    @classmethod
    def import_ply(cls, path: String = None):
        """ > Node Import PLY

        Parameters
        ----------
        path : String, optional
            socket 'Path' (id: Path)


        Returns
        -------
        Mesh
        """
        node = Node('Import PLY', {'Path': path})
        return node._out

    @classmethod
    def import_stl(cls, path: String = None):
        """ > Node Import STL

        Parameters
        ----------
        path : String, optional
            socket 'Path' (id: Path)


        Returns
        -------
        Mesh
        """
        node = Node('Import STL', {'Path': path})
        return node._out

    @classmethod
    def import_text(cls, path: String = None):
        """ > Node Import Text

        Parameters
        ----------
        path : String, optional
            socket 'Path' (id: Path)


        Returns
        -------
        String
        """
        node = Node('Import Text', {'Path': path})
        return node._out

    @classmethod
    def import_vdb(cls, path: String = None):
        """ > Node Import VDB

        Parameters
        ----------
        path : String, optional
            socket 'Path' (id: Path)


        Returns
        -------
        Volume
        """
        node = Node('Import VDB', {'Path': path})
        return node._out

    @classmethod
    def index_of_nearest(cls, position: Vector = None, group_id: Integer = None):
        """ > Node Index of Nearest

        Parameters
        ----------
        position : Vector, optional
            socket 'Position' (id: Position)

        group_id : Integer, optional
            socket 'Group ID' (id: Group ID)


        Returns
        -------
        Integer
            peer sockets: has_neighbor_ (Boolean)

        """
        node = Node('Index of Nearest', {'Position': position, 'Group ID': group_id})
        return node._out

    @classmethod
    def index_switch(cls,
                    named_sockets: dict = {},
                    index: Integer = None,
                    _0: Float = None,
                    _1: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
                    **sockets):
        """ > Node Index Switch

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        index : Integer, optional
            socket 'Index' (id: Index)

        _0 : Float, optional
            socket '0' (id: Item_0)

        _1 : Float, optional
            socket '1' (id: Item_1)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
            parameter `data_type`

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        Float
        """
        node = Node('Index Switch', {'Index': index, 'Item_0': _0, 'Item_1': _1, **named_sockets}, data_type=data_type, **sockets)
        return node._out

    @utils.classproperty
    def active_camera(self):
        """ > Node Active Camera

        Returns
        -------
        Object
        """
        node = Node('Active Camera', )
        return node._out

    @classmethod
    def collection(cls, collection = None):
        """ > Node Collection

        Parameters
        ----------
        collection : NoneType
            parameter `collection`


        Returns
        -------
        Collection
        """
        node = Node('Collection', collection=collection)
        return node._out

    @classmethod
    def curve_handle_positions(cls, relative: Boolean = None):
        """ > Node Curve Handle Positions

        Parameters
        ----------
        relative : Boolean, optional
            socket 'Relative' (id: Relative)


        Returns
        -------
        Vector
            peer sockets: right_ (Vector)

        """
        node = Node('Curve Handle Positions', {'Relative': relative})
        return node._out

    @utils.classproperty
    def curve_tilt(self):
        """ > Node Curve Tilt

        Returns
        -------
        Float
        """
        node = Node('Curve Tilt', )
        return node._out

    @utils.classproperty
    def is_edge_smooth(self):
        """ > Node Is Edge Smooth

        Returns
        -------
        Boolean
        """
        node = Node('Is Edge Smooth', )
        return node._out

    @utils.classproperty
    def id(self):
        """ > Node ID

        Returns
        -------
        Integer
        """
        node = Node('ID', )
        return node._out

    @classmethod
    def image(cls, image = None):
        """ > Node Image

        Parameters
        ----------
        image : NoneType
            parameter `image`


        Returns
        -------
        Image
        """
        node = Node('Image', image=image)
        return node._out

    @utils.classproperty
    def index(self):
        """ > Node Index

        Returns
        -------
        Integer
        """
        node = Node('Index', )
        return node._out

    @classmethod
    def instance_bounds(cls, use_radius: Boolean = None):
        """ > Node Instance Bounds

        Parameters
        ----------
        use_radius : Boolean, optional
            socket 'Use Radius' (id: Use Radius)


        Returns
        -------
        Vector
            peer sockets: max_ (Vector)

        """
        node = Node('Instance Bounds', {'Use Radius': use_radius})
        return node._out

    @utils.classproperty
    def instance_rotation(self):
        """ > Node Instance Rotation

        Returns
        -------
        Rotation
        """
        node = Node('Instance Rotation', )
        return node._out

    @utils.classproperty
    def instance_scale(self):
        """ > Node Instance Scale

        Returns
        -------
        Vector
        """
        node = Node('Instance Scale', )
        return node._out

    @classmethod
    def material(cls, material = None):
        """ > Node Material

        Parameters
        ----------
        material : NoneType
            parameter `material`


        Returns
        -------
        Material
        """
        node = Node('Material', material=material)
        return node._out

    @utils.classproperty
    def material_index(self):
        """ > Node Material Index

        Returns
        -------
        Integer
        """
        node = Node('Material Index', )
        return node._out

    @classmethod
    def edge_angle(cls):
        """ > Node Edge Angle

        Returns
        -------
        Float
            peer sockets: signed_angle_ (Float)

        """
        node = Node('Edge Angle', )
        return node

    @utils.classproperty
    def edge_neighbors(self):
        """ > Node Edge Neighbors

        Returns
        -------
        Integer
        """
        node = Node('Edge Neighbors', )
        return node._out

    @classmethod
    def edge_vertices(cls):
        """ > Node Edge Vertices

        Returns
        -------
        Integer
            peer sockets: vertex_index_2_ (Integer), position_1_ (Vector), position_2_ (Vector)

        """
        node = Node('Edge Vertices', )
        return node

    @utils.classproperty
    def face_area(self):
        """ > Node Face Area

        Returns
        -------
        Float
        """
        node = Node('Face Area', )
        return node._out

    @classmethod
    def is_face_planar(cls, threshold: Float = None):
        """ > Node Is Face Planar

        Parameters
        ----------
        threshold : Float, optional
            socket 'Threshold' (id: Threshold)


        Returns
        -------
        Boolean
        """
        node = Node('Is Face Planar', {'Threshold': threshold})
        return node._out

    @classmethod
    def face_neighbors(cls):
        """ > Node Face Neighbors

        Returns
        -------
        Integer
            peer sockets: face_count_ (Integer)

        """
        node = Node('Face Neighbors', )
        return node

    @classmethod
    def mesh_island(cls):
        """ > Node Mesh Island

        Returns
        -------
        Integer
            peer sockets: island_count_ (Integer)

        """
        node = Node('Mesh Island', )
        return node

    @classmethod
    def vertex_neighbors(cls):
        """ > Node Vertex Neighbors

        Returns
        -------
        Integer
            peer sockets: face_count_ (Integer)

        """
        node = Node('Vertex Neighbors', )
        return node

    @classmethod
    def named_attribute(cls,
                    name: String = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT'):
        """ > Node Named Attribute

        Parameters
        ----------
        name : String, optional
            socket 'Name' (id: Name)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
            parameter `data_type`


        Returns
        -------
        Float
            peer sockets: exists_ (Boolean)

        """
        node = Node('Named Attribute', {'Name': name}, data_type=data_type)
        return node._out

    @classmethod
    def named_layer_selection(cls, name: String = None):
        """ > Node Named Layer Selection

        Parameters
        ----------
        name : String, optional
            socket 'Name' (id: Name)


        Returns
        -------
        Boolean
        """
        node = Node('Named Layer Selection', {'Name': name})
        return node._out

    @utils.classproperty
    def normal(self):
        """ > Node Normal

        Returns
        -------
        Vector
            peer sockets: true_normal_ (Vector)

        """
        node = Node('Normal', )
        return node._out

    @classmethod
    def object(cls, object = None):
        """ > Node Object

        Parameters
        ----------
        object : NoneType
            parameter `object`


        Returns
        -------
        Object
        """
        node = Node('Object', object=object)
        return node._out

    @utils.classproperty
    def position(self):
        """ > Node Position

        Returns
        -------
        Vector
        """
        node = Node('Position', )
        return node._out

    @utils.classproperty
    def radius(self):
        """ > Node Radius

        Returns
        -------
        Float
        """
        node = Node('Radius', )
        return node._out

    @classmethod
    def scene_time(cls):
        """ > Node Scene Time

        Returns
        -------
        Float
            peer sockets: frame_ (Float)

        """
        node = Node('Scene Time', )
        return node

    @utils.classproperty
    def is_face_smooth(self):
        """ > Node Is Face Smooth

        Returns
        -------
        Boolean
        """
        node = Node('Is Face Smooth', )
        return node._out

    @classmethod
    def shortest_edge_paths(cls, end_vertex: Boolean = None, edge_cost: Float = None):
        """ > Node Shortest Edge Paths

        Parameters
        ----------
        end_vertex : Boolean, optional
            socket 'End Vertex' (id: End Vertex)

        edge_cost : Float, optional
            socket 'Edge Cost' (id: Edge Cost)


        Returns
        -------
        Integer
            peer sockets: total_cost_ (Float)

        """
        node = Node('Shortest Edge Paths', {'End Vertex': end_vertex, 'Edge Cost': edge_cost})
        return node._out

    @utils.classproperty
    def is_spline_cyclic(self):
        """ > Node Is Spline Cyclic

        Returns
        -------
        Boolean
        """
        node = Node('Is Spline Cyclic', )
        return node._out

    @utils.classproperty
    def spline_resolution(self):
        """ > Node Spline Resolution

        Returns
        -------
        Integer
        """
        node = Node('Spline Resolution', )
        return node._out

    @utils.classproperty
    def curve_tangent(self):
        """ > Node Curve Tangent

        Returns
        -------
        Vector
        """
        node = Node('Curve Tangent', )
        return node._out

    @classmethod
    def voxel_index(cls):
        """ > Node Voxel Index

        Returns
        -------
        Integer
            peer sockets: y_ (Integer), z_ (Integer), is_tile_ (Boolean), extent_x_ (Integer), extent_y_ (Integer), extent_z_ (Integer)

        """
        node = Node('Voxel Index', )
        return node

    @classmethod
    def instance_on_points(cls,
                    points: Cloud = None,
                    selection: Boolean = None,
                    instance: Instances = None,
                    pick_instance: Boolean = None,
                    instance_index: Integer = None,
                    rotation: Rotation = None,
                    scale: Vector = None):
        """ > Node Instance on Points

        Parameters
        ----------
        points : Cloud, optional
            socket 'Points' (id: Points)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        instance : Instances, optional
            socket 'Instance' (id: Instance)

        pick_instance : Boolean, optional
            socket 'Pick Instance' (id: Pick Instance)

        instance_index : Integer, optional
            socket 'Instance Index' (id: Instance Index)

        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)

        scale : Vector, optional
            socket 'Scale' (id: Scale)


        Returns
        -------
        Instances
        """
        node = Node('Instance on Points', {'Points': points, 'Selection': selection, 'Instance': instance, 'Pick Instance': pick_instance, 'Instance Index': instance_index, 'Rotation': rotation, 'Scale': scale})
        return node._out

    @utils.classproperty
    def instance_transform(self):
        """ > Node Instance Transform

        Returns
        -------
        Matrix
        """
        node = Node('Instance Transform', )
        return node._out

    @classmethod
    def instances_to_points(cls,
                    instances: Instances = None,
                    selection: Boolean = None,
                    position: Vector = None,
                    radius: Float = None):
        """ > Node Instances to Points

        Parameters
        ----------
        instances : Instances, optional
            socket 'Instances' (id: Instances)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        position : Vector, optional
            socket 'Position' (id: Position)

        radius : Float, optional
            socket 'Radius' (id: Radius)


        Returns
        -------
        Cloud
        """
        node = Node('Instances to Points', {'Instances': instances, 'Selection': selection, 'Position': position, 'Radius': radius})
        return node._out

    @classmethod
    def interpolate_curves(cls,
                    guide_curves: Curve = None,
                    guide_up: Vector = None,
                    guide_group_id: Integer = None,
                    points: Cloud = None,
                    point_up: Vector = None,
                    point_group_id: Integer = None,
                    max_neighbors: Integer = None):
        """ > Node Interpolate Curves

        Parameters
        ----------
        guide_curves : Curve, optional
            socket 'Guide Curves' (id: Guide Curves)

        guide_up : Vector, optional
            socket 'Guide Up' (id: Guide Up)

        guide_group_id : Integer, optional
            socket 'Guide Group ID' (id: Guide Group ID)

        points : Cloud, optional
            socket 'Points' (id: Points)

        point_up : Vector, optional
            socket 'Point Up' (id: Point Up)

        point_group_id : Integer, optional
            socket 'Point Group ID' (id: Point Group ID)

        max_neighbors : Integer, optional
            socket 'Max Neighbors' (id: Max Neighbors)


        Returns
        -------
        Curve
            peer sockets: closest_index_ (Integer), closest_weight_ (Float)

        """
        node = Node('Interpolate Curves', {'Guide Curves': guide_curves, 'Guide Up': guide_up, 'Guide Group ID': guide_group_id, 'Points': points, 'Point Up': point_up, 'Point Group ID': point_group_id, 'Max Neighbors': max_neighbors})
        return node._out

    @utils.classproperty
    def is_viewport(self):
        """ > Node Is Viewport

        Returns
        -------
        Boolean
        """
        node = Node('Is Viewport', )
        return node._out

    @classmethod
    def join_geometry(cls, *geometry: Geometry):
        """ > Node Join Geometry

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)


        Returns
        -------
        Geometry
        """
        node = Node('Join Geometry', {'Geometry': list(geometry)})
        return node._out

    @classmethod
    def get_list_item(cls,
                    list: Float = None,
                    index: Integer = None,
                    socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
                    structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO'):
        """ > Node Get List Item

        Parameters
        ----------
        list : Float, optional
            socket 'List' (id: List)

        index : Integer, optional
            socket 'Index' (id: Index)

        socket_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
            parameter `socket_type`

        structure_type : Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']
            parameter `structure_type`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Get List Item', 'socket_type', socket_type, 'get_list_item', ('FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'))
        utils.check_enum_arg('Get List Item', 'structure_type', structure_type, 'get_list_item', ('AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'))
        node = Node('Get List Item', {'List': list, 'Index': index}, socket_type=socket_type, structure_type=structure_type)
        return node._out

    @classmethod
    def list_length(cls,
                    list: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT'):
        """ > Node List Length

        Parameters
        ----------
        list : Float, optional
            socket 'List' (id: List)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
            parameter `data_type`


        Returns
        -------
        Integer
        """
        node = Node('List Length', {'List': list}, data_type=data_type)
        return node._out

    @classmethod
    def material_selection(cls, material: Material = None):
        """ > Node Material Selection

        Parameters
        ----------
        material : Material, optional
            socket 'Material' (id: Material)


        Returns
        -------
        Boolean
        """
        node = Node('Material Selection', {'Material': material})
        return node._out

    @classmethod
    def menu_switch(cls,
                    named_sockets: dict = {},
                    menu = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'GEOMETRY',
                    **sockets):
        """ > Node Menu Switch

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        menu : Menu, optional
            Menu selection

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
            parameter `data_type`

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        Geometry
            peer sockets: a_ (Boolean), b_ (Boolean)

        """
        node = Node('Menu Switch', {'Menu': menu, **named_sockets}, data_type=data_type, **sockets)
        return node._out

    @classmethod
    def merge_by_distance(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    mode: Literal['All', 'Connected'] = None,
                    distance: Float = None):
        """ > Node Merge by Distance

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        mode : menu='All', optional
            ('All', 'Connected')

        distance : Float, optional
            socket 'Distance' (id: Distance)


        Returns
        -------
        Geometry
        """
        node = Node('Merge by Distance', {'Geometry': geometry, 'Selection': selection, 'Mode': mode, 'Distance': distance})
        return node._out

    @classmethod
    def merge_layers(cls,
                    grease_pencil: GreasePencil = None,
                    selection: Boolean = None,
                    group_id: Integer = None,
                    mode: Literal['MERGE_BY_NAME', 'MERGE_BY_ID'] = 'MERGE_BY_NAME'):
        """ > Node Merge Layers

        Parameters
        ----------
        grease_pencil : GreasePencil, optional
            socket 'Grease Pencil' (id: Grease Pencil)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        group_id : Integer, optional
            socket 'Group ID' (id: Group ID)

        mode : Literal['By Name', 'By Group ID']
            parameter `mode`


        Returns
        -------
        GreasePencil
        """
        utils.check_enum_arg('Merge Layers', 'mode', mode, 'merge_layers', ('MERGE_BY_NAME', 'MERGE_BY_ID'))
        node = Node('Merge Layers', {'Grease Pencil': grease_pencil, 'Selection': selection, 'Group ID': group_id}, mode=mode)
        return node._out

    @classmethod
    def mesh_boolean(cls,
                    *mesh_2: Mesh,
                    mesh_1: Mesh = None,
                    self_intersection: Boolean = None,
                    hole_tolerant: Boolean = None,
                    operation: Literal['INTERSECT', 'UNION', 'DIFFERENCE'] = 'DIFFERENCE',
                    solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT'):
        """ > Node Mesh Boolean

        Parameters
        ----------
        mesh_1 : Mesh, optional
            socket 'Mesh 1' (id: Mesh 1)

        mesh_2 : Mesh, optional
            socket 'Mesh 2' (id: Mesh 2)

        self_intersection : Boolean, optional
            socket 'Self Intersection' (id: Self Intersection)

        hole_tolerant : Boolean, optional
            socket 'Hole Tolerant' (id: Hole Tolerant)

        operation : Literal['Intersect', 'Union', 'Difference']
            parameter `operation`

        solver : Literal['Exact', 'Float', 'Manifold']
            parameter `solver`


        Returns
        -------
        Mesh
        """
        utils.check_enum_arg('Mesh Boolean', 'operation', operation, 'mesh_boolean', ('INTERSECT', 'UNION', 'DIFFERENCE'))
        utils.check_enum_arg('Mesh Boolean', 'solver', solver, 'mesh_boolean', ('EXACT', 'FLOAT', 'MANIFOLD'))
        node = Node('Mesh Boolean', {'Mesh 1': mesh_1, 'Mesh 2': list(mesh_2), 'Self Intersection': self_intersection, 'Hole Tolerant': hole_tolerant}, operation=operation, solver=solver)
        return node._out

    @classmethod
    def mesh_circle(cls,
                    vertices: Integer = None,
                    radius: Float = None,
                    fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NONE'):
        """ > Node Mesh Circle

        Parameters
        ----------
        vertices : Integer, optional
            socket 'Vertices' (id: Vertices)

        radius : Float, optional
            socket 'Radius' (id: Radius)

        fill_type : Literal['None', 'N-Gon', 'Triangles']
            parameter `fill_type`


        Returns
        -------
        Mesh
        """
        utils.check_enum_arg('Mesh Circle', 'fill_type', fill_type, 'mesh_circle', ('NONE', 'NGON', 'TRIANGLE_FAN'))
        node = Node('Mesh Circle', {'Vertices': vertices, 'Radius': radius}, fill_type=fill_type)
        return node._out

    @classmethod
    def cone(cls,
                    vertices: Integer = None,
                    side_segments: Integer = None,
                    fill_segments: Integer = None,
                    radius_top: Float = None,
                    radius_bottom: Float = None,
                    depth: Float = None,
                    fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NGON'):
        """ > Node Cone

        Parameters
        ----------
        vertices : Integer, optional
            socket 'Vertices' (id: Vertices)

        side_segments : Integer, optional
            socket 'Side Segments' (id: Side Segments)

        fill_segments : Integer, optional
            socket 'Fill Segments' (id: Fill Segments)

        radius_top : Float, optional
            socket 'Radius Top' (id: Radius Top)

        radius_bottom : Float, optional
            socket 'Radius Bottom' (id: Radius Bottom)

        depth : Float, optional
            socket 'Depth' (id: Depth)

        fill_type : Literal['None', 'N-Gon', 'Triangles']
            parameter `fill_type`


        Returns
        -------
        Mesh
            peer sockets: top_ (Boolean), bottom_ (Boolean), side_ (Boolean), uv_map_ (Vector)

        """
        utils.check_enum_arg('Cone', 'fill_type', fill_type, 'cone', ('NONE', 'NGON', 'TRIANGLE_FAN'))
        node = Node('Cone', {'Vertices': vertices, 'Side Segments': side_segments, 'Fill Segments': fill_segments, 'Radius Top': radius_top, 'Radius Bottom': radius_bottom, 'Depth': depth}, fill_type=fill_type)
        return node._out

    @classmethod
    def cube(cls,
                    size: Vector = None,
                    vertices_x: Integer = None,
                    vertices_y: Integer = None,
                    vertices_z: Integer = None):
        """ > Node Cube

        Parameters
        ----------
        size : Vector, optional
            socket 'Size' (id: Size)

        vertices_x : Integer, optional
            socket 'Vertices X' (id: Vertices X)

        vertices_y : Integer, optional
            socket 'Vertices Y' (id: Vertices Y)

        vertices_z : Integer, optional
            socket 'Vertices Z' (id: Vertices Z)


        Returns
        -------
        Mesh
            peer sockets: uv_map_ (Vector)

        """
        node = Node('Cube', {'Size': size, 'Vertices X': vertices_x, 'Vertices Y': vertices_y, 'Vertices Z': vertices_z})
        return node._out

    @classmethod
    def cylinder(cls,
                    vertices: Integer = None,
                    side_segments: Integer = None,
                    fill_segments: Integer = None,
                    radius: Float = None,
                    depth: Float = None,
                    fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NGON'):
        """ > Node Cylinder

        Parameters
        ----------
        vertices : Integer, optional
            socket 'Vertices' (id: Vertices)

        side_segments : Integer, optional
            socket 'Side Segments' (id: Side Segments)

        fill_segments : Integer, optional
            socket 'Fill Segments' (id: Fill Segments)

        radius : Float, optional
            socket 'Radius' (id: Radius)

        depth : Float, optional
            socket 'Depth' (id: Depth)

        fill_type : Literal['None', 'N-Gon', 'Triangles']
            parameter `fill_type`


        Returns
        -------
        Mesh
            peer sockets: top_ (Boolean), side_ (Boolean), bottom_ (Boolean), uv_map_ (Vector)

        """
        utils.check_enum_arg('Cylinder', 'fill_type', fill_type, 'cylinder', ('NONE', 'NGON', 'TRIANGLE_FAN'))
        node = Node('Cylinder', {'Vertices': vertices, 'Side Segments': side_segments, 'Fill Segments': fill_segments, 'Radius': radius, 'Depth': depth}, fill_type=fill_type)
        return node._out

    @classmethod
    def face_group_boundaries(cls, face_group_id: Integer = None):
        """ > Node Face Group Boundaries

        Parameters
        ----------
        face_group_id : Integer, optional
            socket 'Face Group ID' (id: Face Set)


        Returns
        -------
        Boolean
        """
        node = Node('Face Group Boundaries', {'Face Set': face_group_id})
        return node._out

    @classmethod
    def grid(cls,
                    size_x: Float = None,
                    size_y: Float = None,
                    vertices_x: Integer = None,
                    vertices_y: Integer = None):
        """ > Node Grid

        Parameters
        ----------
        size_x : Float, optional
            socket 'Size X' (id: Size X)

        size_y : Float, optional
            socket 'Size Y' (id: Size Y)

        vertices_x : Integer, optional
            socket 'Vertices X' (id: Vertices X)

        vertices_y : Integer, optional
            socket 'Vertices Y' (id: Vertices Y)


        Returns
        -------
        Mesh
            peer sockets: uv_map_ (Vector)

        """
        node = Node('Grid', {'Size X': size_x, 'Size Y': size_y, 'Vertices X': vertices_x, 'Vertices Y': vertices_y})
        return node._out

    @classmethod
    def ico_sphere(cls, radius: Float = None, subdivisions: Integer = None):
        """ > Node Ico Sphere

        Parameters
        ----------
        radius : Float, optional
            socket 'Radius' (id: Radius)

        subdivisions : Integer, optional
            socket 'Subdivisions' (id: Subdivisions)


        Returns
        -------
        Mesh
            peer sockets: uv_map_ (Vector)

        """
        node = Node('Ico Sphere', {'Radius': radius, 'Subdivisions': subdivisions})
        return node._out

    @classmethod
    def mesh_line(cls,
                    count: Integer = None,
                    resolution: Float = None,
                    start_location: Vector = None,
                    offset: Vector = None,
                    count_mode: Literal['TOTAL', 'RESOLUTION'] = 'TOTAL',
                    mode: Literal['OFFSET', 'END_POINTS'] = 'OFFSET'):
        """ > Node Mesh Line

        Parameters
        ----------
        count : Integer, optional
            socket 'Count' (id: Count)

        resolution : Float, optional
            socket 'Resolution' (id: Resolution)

        start_location : Vector, optional
            socket 'Start Location' (id: Start Location)

        offset : Vector, optional
            socket 'Offset' (id: Offset)

        count_mode : Literal['Count', 'Resolution']
            parameter `count_mode`

        mode : Literal['Offset', 'End Points']
            parameter `mode`


        Returns
        -------
        Mesh
        """
        utils.check_enum_arg('Mesh Line', 'count_mode', count_mode, 'mesh_line', ('TOTAL', 'RESOLUTION'))
        utils.check_enum_arg('Mesh Line', 'mode', mode, 'mesh_line', ('OFFSET', 'END_POINTS'))
        node = Node('Mesh Line', {'Count': count, 'Resolution': resolution, 'Start Location': start_location, 'Offset': offset}, count_mode=count_mode, mode=mode)
        return node._out

    @classmethod
    def mesh_to_curve(cls,
                    mesh: Mesh = None,
                    selection: Boolean = None,
                    mode: Literal['EDGES', 'FACES'] = 'EDGES'):
        """ > Node Mesh to Curve

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        mode : Literal['Edges', 'Faces']
            parameter `mode`


        Returns
        -------
        Curve
        """
        utils.check_enum_arg('Mesh to Curve', 'mode', mode, 'mesh_to_curve', ('EDGES', 'FACES'))
        node = Node('Mesh to Curve', {'Mesh': mesh, 'Selection': selection}, mode=mode)
        return node._out

    @classmethod
    def mesh_to_density_grid(cls,
                    mesh: Mesh = None,
                    density: Float = None,
                    voxel_size: Float = None,
                    gradient_width: Float = None):
        """ > Node Mesh to Density Grid

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        density : Float, optional
            socket 'Density' (id: Density)

        voxel_size : Float, optional
            socket 'Voxel Size' (id: Voxel Size)

        gradient_width : Float, optional
            socket 'Gradient Width' (id: Gradient Width)


        Returns
        -------
        Float
        """
        node = Node('Mesh to Density Grid', {'Mesh': mesh, 'Density': density, 'Voxel Size': voxel_size, 'Gradient Width': gradient_width})
        return node._out

    @classmethod
    def mesh_to_points(cls,
                    mesh: Mesh = None,
                    selection: Boolean = None,
                    position: Vector = None,
                    radius: Float = None,
                    mode: Literal['VERTICES', 'EDGES', 'FACES', 'CORNERS'] = 'VERTICES'):
        """ > Node Mesh to Points

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        position : Vector, optional
            socket 'Position' (id: Position)

        radius : Float, optional
            socket 'Radius' (id: Radius)

        mode : Literal['Vertices', 'Edges', 'Faces', 'Corners']
            parameter `mode`


        Returns
        -------
        Cloud
        """
        utils.check_enum_arg('Mesh to Points', 'mode', mode, 'mesh_to_points', ('VERTICES', 'EDGES', 'FACES', 'CORNERS'))
        node = Node('Mesh to Points', {'Mesh': mesh, 'Selection': selection, 'Position': position, 'Radius': radius}, mode=mode)
        return node._out

    @classmethod
    def mesh_to_sdf_grid(cls, mesh: Mesh = None, voxel_size: Float = None, band_width: Integer = None):
        """ > Node Mesh to SDF Grid

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        voxel_size : Float, optional
            socket 'Voxel Size' (id: Voxel Size)

        band_width : Integer, optional
            socket 'Band Width' (id: Band Width)


        Returns
        -------
        Float
        """
        node = Node('Mesh to SDF Grid', {'Mesh': mesh, 'Voxel Size': voxel_size, 'Band Width': band_width})
        return node._out

    @classmethod
    def mesh_to_volume(cls,
                    mesh: Mesh = None,
                    density: Float = None,
                    resolution_mode: Literal['Amount', 'Size'] = None,
                    voxel_size: Float = None,
                    voxel_amount: Float = None,
                    interior_band_width: Float = None):
        """ > Node Mesh to Volume

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        density : Float, optional
            socket 'Density' (id: Density)

        resolution_mode : menu='Amount', optional
            ('Amount', 'Size')

        voxel_size : Float, optional
            socket 'Voxel Size' (id: Voxel Size)

        voxel_amount : Float, optional
            socket 'Voxel Amount' (id: Voxel Amount)

        interior_band_width : Float, optional
            socket 'Interior Band Width' (id: Interior Band Width)


        Returns
        -------
        Volume
        """
        node = Node('Mesh to Volume', {'Mesh': mesh, 'Density': density, 'Resolution Mode': resolution_mode, 'Voxel Size': voxel_size, 'Voxel Amount': voxel_amount, 'Interior Band Width': interior_band_width})
        return node._out

    @classmethod
    def uv_sphere(cls, segments: Integer = None, rings: Integer = None, radius: Float = None):
        """ > Node UV Sphere

        Parameters
        ----------
        segments : Integer, optional
            socket 'Segments' (id: Segments)

        rings : Integer, optional
            socket 'Rings' (id: Rings)

        radius : Float, optional
            socket 'Radius' (id: Radius)


        Returns
        -------
        Mesh
            peer sockets: uv_map_ (Vector)

        """
        node = Node('UV Sphere', {'Segments': segments, 'Rings': rings, 'Radius': radius})
        return node._out

    @classmethod
    def object_info(cls,
                    object: Object = None,
                    as_instance: Boolean = None,
                    transform_space: Literal['ORIGINAL', 'RELATIVE'] = 'ORIGINAL'):
        """ > Node Object Info

        Parameters
        ----------
        object : Object, optional
            socket 'Object' (id: Object)

        as_instance : Boolean, optional
            socket 'As Instance' (id: As Instance)

        transform_space : Literal['Original', 'Relative']
            parameter `transform_space`


        Returns
        -------
        Matrix
            peer sockets: location_ (Vector), rotation_ (Rotation), scale_ (Vector), geometry_ (Geometry)

        """
        utils.check_enum_arg('Object Info', 'transform_space', transform_space, 'object_info', ('ORIGINAL', 'RELATIVE'))
        node = Node('Object Info', {'Object': object, 'As Instance': as_instance}, transform_space=transform_space)
        return node._out

    @classmethod
    def offset_corner_in_face(cls, corner_index: Integer = None, offset: Integer = None):
        """ > Node Offset Corner in Face

        Parameters
        ----------
        corner_index : Integer, optional
            socket 'Corner Index' (id: Corner Index)

        offset : Integer, optional
            socket 'Offset' (id: Offset)


        Returns
        -------
        Integer
        """
        node = Node('Offset Corner in Face', {'Corner Index': corner_index, 'Offset': offset})
        return node._out

    @classmethod
    def offset_point_in_curve(cls, point_index: Integer = None, offset: Integer = None):
        """ > Node Offset Point in Curve

        Parameters
        ----------
        point_index : Integer, optional
            socket 'Point Index' (id: Point Index)

        offset : Integer, optional
            socket 'Offset' (id: Offset)


        Returns
        -------
        Boolean
            peer sockets: point_index_ (Integer)

        """
        node = Node('Offset Point in Curve', {'Point Index': point_index, 'Offset': offset})
        return node._out

    @classmethod
    def points(cls, count: Integer = None, position: Vector = None, radius: Float = None):
        """ > Node Points

        Parameters
        ----------
        count : Integer, optional
            socket 'Count' (id: Count)

        position : Vector, optional
            socket 'Position' (id: Position)

        radius : Float, optional
            socket 'Radius' (id: Radius)


        Returns
        -------
        Cloud
        """
        node = Node('Points', {'Count': count, 'Position': position, 'Radius': radius})
        return node._out

    @classmethod
    def points_of_curve(cls,
                    curve_index: Integer = None,
                    weights: Float = None,
                    sort_index: Integer = None):
        """ > Node Points of Curve

        Parameters
        ----------
        curve_index : Integer, optional
            socket 'Curve Index' (id: Curve Index)

        weights : Float, optional
            socket 'Weights' (id: Weights)

        sort_index : Integer, optional
            socket 'Sort Index' (id: Sort Index)


        Returns
        -------
        Integer
            peer sockets: total_ (Integer)

        """
        node = Node('Points of Curve', {'Curve Index': curve_index, 'Weights': weights, 'Sort Index': sort_index})
        return node._out

    @classmethod
    def points_to_curves(cls,
                    points: Cloud = None,
                    curve_group_id: Integer = None,
                    weight: Float = None):
        """ > Node Points to Curves

        Parameters
        ----------
        points : Cloud, optional
            socket 'Points' (id: Points)

        curve_group_id : Integer, optional
            socket 'Curve Group ID' (id: Curve Group ID)

        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        Curve
        """
        node = Node('Points to Curves', {'Points': points, 'Curve Group ID': curve_group_id, 'Weight': weight})
        return node._out

    @classmethod
    def points_to_sdf_grid(cls, points: Cloud = None, radius: Float = None, voxel_size: Float = None):
        """ > Node Points to SDF Grid

        Parameters
        ----------
        points : Cloud, optional
            socket 'Points' (id: Points)

        radius : Float, optional
            socket 'Radius' (id: Radius)

        voxel_size : Float, optional
            socket 'Voxel Size' (id: Voxel Size)


        Returns
        -------
        Float
        """
        node = Node('Points to SDF Grid', {'Points': points, 'Radius': radius, 'Voxel Size': voxel_size})
        return node._out

    @classmethod
    def points_to_vertices(cls, points: Cloud = None, selection: Boolean = None):
        """ > Node Points to Vertices

        Parameters
        ----------
        points : Cloud, optional
            socket 'Points' (id: Points)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)


        Returns
        -------
        Mesh
        """
        node = Node('Points to Vertices', {'Points': points, 'Selection': selection})
        return node._out

    @classmethod
    def points_to_volume(cls,
                    points: Cloud = None,
                    density: Float = None,
                    resolution_mode: Literal['Amount', 'Size'] = None,
                    voxel_size: Float = None,
                    voxel_amount: Float = None,
                    radius: Float = None):
        """ > Node Points to Volume

        Parameters
        ----------
        points : Cloud, optional
            socket 'Points' (id: Points)

        density : Float, optional
            socket 'Density' (id: Density)

        resolution_mode : menu='Amount', optional
            ('Amount', 'Size')

        voxel_size : Float, optional
            socket 'Voxel Size' (id: Voxel Size)

        voxel_amount : Float, optional
            socket 'Voxel Amount' (id: Voxel Amount)

        radius : Float, optional
            socket 'Radius' (id: Radius)


        Returns
        -------
        Volume
        """
        node = Node('Points to Volume', {'Points': points, 'Density': density, 'Resolution Mode': resolution_mode, 'Voxel Size': voxel_size, 'Voxel Amount': voxel_amount, 'Radius': radius})
        return node._out

    @classmethod
    def geometry_proximity(cls,
                    geometry: Geometry = None,
                    group_id: Integer = None,
                    sample_position: Vector = None,
                    sample_group_id: Integer = None,
                    target_element: Literal['POINTS', 'EDGES', 'FACES'] = 'FACES'):
        """ > Node Geometry Proximity

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Target)

        group_id : Integer, optional
            socket 'Group ID' (id: Group ID)

        sample_position : Vector, optional
            socket 'Sample Position' (id: Source Position)

        sample_group_id : Integer, optional
            socket 'Sample Group ID' (id: Sample Group ID)

        target_element : Literal['Points', 'Edges', 'Faces']
            parameter `target_element`


        Returns
        -------
        Vector
            peer sockets: distance_ (Float), is_valid_ (Boolean)

        """
        utils.check_enum_arg('Geometry Proximity', 'target_element', target_element, 'geometry_proximity', ('POINTS', 'EDGES', 'FACES'))
        node = Node('Geometry Proximity', {'Target': geometry, 'Group ID': group_id, 'Source Position': sample_position, 'Sample Group ID': sample_group_id}, target_element=target_element)
        return node._out

    @classmethod
    def raycast(cls,
                    target_geometry: Geometry = None,
                    attribute: Float = None,
                    interpolation: Literal['Interpolated', 'Nearest'] = None,
                    source_position: Vector = None,
                    ray_direction: Vector = None,
                    ray_length: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT'):
        """ > Node Raycast

        Parameters
        ----------
        target_geometry : Geometry, optional
            socket 'Target Geometry' (id: Target Geometry)

        attribute : Float, optional
            socket 'Attribute' (id: Attribute)

        interpolation : menu='Interpolated', optional
            ('Interpolated', 'Nearest')

        source_position : Vector, optional
            socket 'Source Position' (id: Source Position)

        ray_direction : Vector, optional
            socket 'Ray Direction' (id: Ray Direction)

        ray_length : Float, optional
            socket 'Ray Length' (id: Ray Length)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
            parameter `data_type`


        Returns
        -------
        Boolean
            peer sockets: hit_position_ (Vector), hit_normal_ (Vector), hit_distance_ (Float), attribute_ (Float)

        """
        node = Node('Raycast', {'Target Geometry': target_geometry, 'Attribute': attribute, 'Interpolation': interpolation, 'Source Position': source_position, 'Ray Direction': ray_direction, 'Ray Length': ray_length}, data_type=data_type)
        return node._out

    @classmethod
    def realize_instances(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    realize_all: Boolean = None,
                    depth: Integer = None,
                    realize_to_point_domain = False):
        """ > Node Realize Instances

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        realize_all : Boolean, optional
            socket 'Realize All' (id: Realize All)

        depth : Integer, optional
            socket 'Depth' (id: Depth)

        realize_to_point_domain : bool
            parameter `realize_to_point_domain`


        Returns
        -------
        Geometry
        """
        node = Node('Realize Instances', {'Geometry': geometry, 'Selection': selection, 'Realize All': realize_all, 'Depth': depth}, realize_to_point_domain=realize_to_point_domain)
        return node._out

    @classmethod
    def remove_named_attribute(cls,
                    geometry: Geometry = None,
                    pattern_mode: Literal['Exact', 'Wildcard'] = None,
                    name: String = None):
        """ > Node Remove Named Attribute

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        pattern_mode : menu='Exact', optional
            ('Exact', 'Wildcard')

        name : String, optional
            socket 'Name' (id: Name)


        Returns
        -------
        Geometry
        """
        node = Node('Remove Named Attribute', {'Geometry': geometry, 'Pattern Mode': pattern_mode, 'Name': name})
        return node._out

    @classmethod
    def repeat_input(cls, iterations: Integer = None):
        """ > Node Repeat Input

        Parameters
        ----------
        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)


        Returns
        -------
        Integer
        """
        node = Node('Repeat Input', {'Iterations': iterations})
        return node._out

    @classmethod
    def repeat_output(cls, geometry: Geometry = None, inspection_index = 0):
        """ > Node Repeat Output

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Item_0)

        inspection_index : int
            parameter `inspection_index`


        Returns
        -------
        Geometry
        """
        node = Node('Repeat Output', {'Item_0': geometry}, inspection_index=inspection_index)
        return node._out

    @classmethod
    def replace_material(cls, geometry: Geometry = None, old: Material = None, new: Material = None):
        """ > Node Replace Material

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        old : Material, optional
            socket 'Old' (id: Old)

        new : Material, optional
            socket 'New' (id: New)


        Returns
        -------
        Geometry
        """
        node = Node('Replace Material', {'Geometry': geometry, 'Old': old, 'New': new})
        return node._out

    @classmethod
    def resample_curve(cls,
                    curve: Curve = None,
                    selection: Boolean = None,
                    mode: Literal['Evaluated', 'Count', 'Length'] = None,
                    count: Integer = None,
                    length: Float = None,
                    keep_last_segment = True):
        """ > Node Resample Curve

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        mode : menu='Count', optional
            ('Evaluated', 'Count', 'Length')

        count : Integer, optional
            socket 'Count' (id: Count)

        length : Float, optional
            socket 'Length' (id: Length)

        keep_last_segment : bool
            parameter `keep_last_segment`


        Returns
        -------
        Curve
        """
        node = Node('Resample Curve', {'Curve': curve, 'Selection': selection, 'Mode': mode, 'Count': count, 'Length': length}, keep_last_segment=keep_last_segment)
        return node._out

    @classmethod
    def reverse_curve(cls, curve: Curve = None, selection: Boolean = None):
        """ > Node Reverse Curve

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)


        Returns
        -------
        Curve
        """
        node = Node('Reverse Curve', {'Curve': curve, 'Selection': selection})
        return node._out

    @classmethod
    def rotate_instances(cls,
                    instances: Instances = None,
                    selection: Boolean = None,
                    rotation: Rotation = None,
                    pivot_point: Vector = None,
                    local_space: Boolean = None):
        """ > Node Rotate Instances

        Parameters
        ----------
        instances : Instances, optional
            socket 'Instances' (id: Instances)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)

        pivot_point : Vector, optional
            socket 'Pivot Point' (id: Pivot Point)

        local_space : Boolean, optional
            socket 'Local Space' (id: Local Space)


        Returns
        -------
        Instances
        """
        node = Node('Rotate Instances', {'Instances': instances, 'Selection': selection, 'Rotation': rotation, 'Pivot Point': pivot_point, 'Local Space': local_space})
        return node._out

    @classmethod
    def sdf_grid_boolean(cls,
                    *grid_2: Float,
                    grid_1: Float = None,
                    operation: Literal['INTERSECT', 'UNION', 'DIFFERENCE'] = 'DIFFERENCE'):
        """ > Node SDF Grid Boolean

        Parameters
        ----------
        grid_1 : Float, optional
            socket 'Grid 1' (id: Grid 1)

        grid_2 : Float, optional
            socket 'Grid 2' (id: Grid 2)

        operation : Literal['Intersect', 'Union', 'Difference']
            parameter `operation`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('SDF Grid Boolean', 'operation', operation, 'sdf_grid_boolean', ('INTERSECT', 'UNION', 'DIFFERENCE'))
        node = Node('SDF Grid Boolean', {'Grid 1': grid_1, 'Grid 2': list(grid_2)}, operation=operation)
        return node._out

    @classmethod
    def sdf_grid_fillet(cls, grid: Float = None, iterations: Integer = None):
        """ > Node SDF Grid Fillet

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)


        Returns
        -------
        Float
        """
        node = Node('SDF Grid Fillet', {'Grid': grid, 'Iterations': iterations})
        return node._out

    @classmethod
    def sdf_grid_laplacian(cls, grid: Float = None, iterations: Integer = None):
        """ > Node SDF Grid Laplacian

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)


        Returns
        -------
        Float
        """
        node = Node('SDF Grid Laplacian', {'Grid': grid, 'Iterations': iterations})
        return node._out

    @classmethod
    def sdf_grid_mean(cls, grid: Float = None, width: Integer = None, iterations: Integer = None):
        """ > Node SDF Grid Mean

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        width : Integer, optional
            socket 'Width' (id: Width)

        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)


        Returns
        -------
        Float
        """
        node = Node('SDF Grid Mean', {'Grid': grid, 'Width': width, 'Iterations': iterations})
        return node._out

    @classmethod
    def sdf_grid_mean_curvature(cls, grid: Float = None, iterations: Integer = None):
        """ > Node SDF Grid Mean Curvature

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)


        Returns
        -------
        Float
        """
        node = Node('SDF Grid Mean Curvature', {'Grid': grid, 'Iterations': iterations})
        return node._out

    @classmethod
    def sdf_grid_median(cls, grid: Float = None, width: Integer = None, iterations: Integer = None):
        """ > Node SDF Grid Median

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        width : Integer, optional
            socket 'Width' (id: Width)

        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)


        Returns
        -------
        Float
        """
        node = Node('SDF Grid Median', {'Grid': grid, 'Width': width, 'Iterations': iterations})
        return node._out

    @classmethod
    def sdf_grid_offset(cls, grid: Float = None, distance: Float = None):
        """ > Node SDF Grid Offset

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        distance : Float, optional
            socket 'Distance' (id: Distance)


        Returns
        -------
        Float
        """
        node = Node('SDF Grid Offset', {'Grid': grid, 'Distance': distance})
        return node._out

    @classmethod
    def sample_curve(cls,
                    curves: Curve = None,
                    value: Float = None,
                    length: Float = None,
                    curve_index: Integer = None,
                    factor: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
                    mode: Literal['FACTOR', 'LENGTH'] = 'FACTOR',
                    use_all_curves = False):
        """ > Node Sample Curve

        Parameters
        ----------
        curves : Curve, optional
            socket 'Curves' (id: Curves)

        value : Float, optional
            socket 'Value' (id: Value)

        length : Float, optional
            socket 'Length' (id: Length)

        curve_index : Integer, optional
            socket 'Curve Index' (id: Curve Index)

        factor : Float, optional
            socket 'Factor' (id: Factor)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
            parameter `data_type`

        mode : Literal['Factor', 'Length']
            parameter `mode`

        use_all_curves : bool
            parameter `use_all_curves`


        Returns
        -------
        Float
            peer sockets: position_ (Vector), tangent_ (Vector), normal_ (Vector)

        """
        utils.check_enum_arg('Sample Curve', 'mode', mode, 'sample_curve', ('FACTOR', 'LENGTH'))
        node = Node('Sample Curve', {'Curves': curves, 'Value': value, 'Length': length, 'Curve Index': curve_index, 'Factor': factor}, data_type=data_type, mode=mode, use_all_curves=use_all_curves)
        return node._out

    @classmethod
    def sample_grid(cls,
                    grid: Float = None,
                    position: Vector = None,
                    interpolation: Literal['Nearest Neighbor', 'Trilinear', 'Triquadratic'] = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Sample Grid

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        position : Vector, optional
            socket 'Position' (id: Position)

        interpolation : menu='Trilinear', optional
            ('Nearest Neighbor', 'Trilinear', 'Triquadratic')

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Sample Grid', {'Grid': grid, 'Position': position, 'Interpolation': interpolation}, data_type=data_type)
        return node._out

    @classmethod
    def sample_grid_index(cls,
                    grid: Float = None,
                    x: Integer = None,
                    y: Integer = None,
                    z: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Sample Grid Index

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        x : Integer, optional
            socket 'X' (id: X)

        y : Integer, optional
            socket 'Y' (id: Y)

        z : Integer, optional
            socket 'Z' (id: Z)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Sample Grid Index', {'Grid': grid, 'X': x, 'Y': y, 'Z': z}, data_type=data_type)
        return node._out

    @classmethod
    def sample_index(cls,
                    geometry: Geometry = None,
                    value: Float = None,
                    index: Integer = None,
                    clamp = False,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
        """ > Node Sample Index

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        value : Float, optional
            socket 'Value' (id: Value)

        index : Integer, optional
            socket 'Index' (id: Index)

        clamp : bool
            parameter `clamp`

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
            parameter `data_type`

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Sample Index', 'domain', domain, 'sample_index', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Sample Index', {'Geometry': geometry, 'Value': value, 'Index': index}, clamp=clamp, data_type=data_type, domain=domain)
        return node._out

    @classmethod
    def sample_nearest(cls,
                    geometry: Geometry = None,
                    sample_position: Vector = None,
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER'] = 'POINT'):
        """ > Node Sample Nearest

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        sample_position : Vector, optional
            socket 'Sample Position' (id: Sample Position)

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner']
            parameter `domain`


        Returns
        -------
        Integer
        """
        utils.check_enum_arg('Sample Nearest', 'domain', domain, 'sample_nearest', ('POINT', 'EDGE', 'FACE', 'CORNER'))
        node = Node('Sample Nearest', {'Geometry': geometry, 'Sample Position': sample_position}, domain=domain)
        return node._out

    @classmethod
    def sample_nearest_surface(cls,
                    mesh: Mesh = None,
                    value: Float = None,
                    group_id: Integer = None,
                    sample_position: Vector = None,
                    sample_group_id: Integer = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT'):
        """ > Node Sample Nearest Surface

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        value : Float, optional
            socket 'Value' (id: Value)

        group_id : Integer, optional
            socket 'Group ID' (id: Group ID)

        sample_position : Vector, optional
            socket 'Sample Position' (id: Sample Position)

        sample_group_id : Integer, optional
            socket 'Sample Group ID' (id: Sample Group ID)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
            parameter `data_type`


        Returns
        -------
        Float
            peer sockets: is_valid_ (Boolean)

        """
        node = Node('Sample Nearest Surface', {'Mesh': mesh, 'Value': value, 'Group ID': group_id, 'Sample Position': sample_position, 'Sample Group ID': sample_group_id}, data_type=data_type)
        return node._out

    @classmethod
    def sample_uv_surface(cls,
                    mesh: Mesh = None,
                    value: Float = None,
                    uv_map: Vector = None,
                    sample_uv: Vector = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT'):
        """ > Node Sample UV Surface

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        value : Float, optional
            socket 'Value' (id: Value)

        uv_map : Vector, optional
            socket 'UV Map' (id: Source UV Map)

        sample_uv : Vector, optional
            socket 'Sample UV' (id: Sample UV)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
            parameter `data_type`


        Returns
        -------
        Float
            peer sockets: is_valid_ (Boolean)

        """
        node = Node('Sample UV Surface', {'Mesh': mesh, 'Value': value, 'Source UV Map': uv_map, 'Sample UV': sample_uv}, data_type=data_type)
        return node._out

    @classmethod
    def scale_elements(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    scale: Float = None,
                    center: Vector = None,
                    scale_mode: Literal['Uniform', 'Single Axis'] = None,
                    axis: Vector = None,
                    domain: Literal['FACE', 'EDGE'] = 'FACE'):
        """ > Node Scale Elements

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        center : Vector, optional
            socket 'Center' (id: Center)

        scale_mode : menu='Uniform', optional
            ('Uniform', 'Single Axis')

        axis : Vector, optional
            socket 'Axis' (id: Axis)

        domain : Literal['Face', 'Edge']
            parameter `domain`


        Returns
        -------
        Geometry
        """
        utils.check_enum_arg('Scale Elements', 'domain', domain, 'scale_elements', ('FACE', 'EDGE'))
        node = Node('Scale Elements', {'Geometry': geometry, 'Selection': selection, 'Scale': scale, 'Center': center, 'Scale Mode': scale_mode, 'Axis': axis}, domain=domain)
        return node._out

    @classmethod
    def scale_instances(cls,
                    instances: Instances = None,
                    selection: Boolean = None,
                    scale: Vector = None,
                    center: Vector = None,
                    local_space: Boolean = None):
        """ > Node Scale Instances

        Parameters
        ----------
        instances : Instances, optional
            socket 'Instances' (id: Instances)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        scale : Vector, optional
            socket 'Scale' (id: Scale)

        center : Vector, optional
            socket 'Center' (id: Center)

        local_space : Boolean, optional
            socket 'Local Space' (id: Local Space)


        Returns
        -------
        Instances
        """
        node = Node('Scale Instances', {'Instances': instances, 'Selection': selection, 'Scale': scale, 'Center': center, 'Local Space': local_space})
        return node._out

    @utils.classproperty
    def self_object(self):
        """ > Node Self Object

        Returns
        -------
        Object
        """
        node = Node('Self Object', )
        return node._out

    @classmethod
    def separate_components(cls, geometry: Geometry = None):
        """ > Node Separate Components

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)


        Returns
        -------
        Mesh
            peer sockets: curve_ (Curve), grease_pencil_ (GreasePencil), point_cloud_ (Cloud), volume_ (Volume), instances_ (Instances)

        """
        node = Node('Separate Components', {'Geometry': geometry})
        return node

    @classmethod
    def separate_geometry(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
        """ > Node Separate Geometry

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        domain : Literal['Point', 'Edge', 'Face', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Geometry
            peer sockets: inverted_ (Geometry)

        """
        utils.check_enum_arg('Separate Geometry', 'domain', domain, 'separate_geometry', ('POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Separate Geometry', {'Geometry': geometry, 'Selection': selection}, domain=domain)
        return node

    @classmethod
    def set_handle_positions(cls,
                    curve: Curve = None,
                    selection: Boolean = None,
                    position: Vector = None,
                    offset: Vector = None,
                    mode: Literal['LEFT', 'RIGHT'] = 'LEFT'):
        """ > Node Set Handle Positions

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        position : Vector, optional
            socket 'Position' (id: Position)

        offset : Vector, optional
            socket 'Offset' (id: Offset)

        mode : Literal['Left', 'Right']
            parameter `mode`


        Returns
        -------
        Curve
        """
        utils.check_enum_arg('Set Handle Positions', 'mode', mode, 'set_handle_positions', ('LEFT', 'RIGHT'))
        node = Node('Set Handle Positions', {'Curve': curve, 'Selection': selection, 'Position': position, 'Offset': offset}, mode=mode)
        return node._out

    @classmethod
    def set_curve_normal(cls,
                    curve: Curve = None,
                    selection: Boolean = None,
                    mode: Literal['Minimum Twist', 'Z Up', 'Free'] = None,
                    normal: Vector = None):
        """ > Node Set Curve Normal

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        mode : menu='Minimum Twist', optional
            ('Minimum Twist', 'Z Up', 'Free')

        normal : Vector, optional
            socket 'Normal' (id: Normal)


        Returns
        -------
        Curve
        """
        node = Node('Set Curve Normal', {'Curve': curve, 'Selection': selection, 'Mode': mode, 'Normal': normal})
        return node._out

    @classmethod
    def set_curve_radius(cls, curve: Curve = None, selection: Boolean = None, radius: Float = None):
        """ > Node Set Curve Radius

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        radius : Float, optional
            socket 'Radius' (id: Radius)


        Returns
        -------
        Curve
        """
        node = Node('Set Curve Radius', {'Curve': curve, 'Selection': selection, 'Radius': radius})
        return node._out

    @classmethod
    def set_curve_tilt(cls, curve: Curve = None, selection: Boolean = None, tilt: Float = None):
        """ > Node Set Curve Tilt

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        tilt : Float, optional
            socket 'Tilt' (id: Tilt)


        Returns
        -------
        Curve
        """
        node = Node('Set Curve Tilt', {'Curve': curve, 'Selection': selection, 'Tilt': tilt})
        return node._out

    @classmethod
    def set_geometry_bundle(cls, geometry: Geometry = None, bundle: Bundle = None):
        """ > Node Set Geometry Bundle

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        bundle : Bundle, optional
            socket 'Bundle' (id: Bundle)


        Returns
        -------
        Geometry
        """
        node = Node('Set Geometry Bundle', {'Geometry': geometry, 'Bundle': bundle})
        return node._out

    @classmethod
    def set_geometry_name(cls, geometry: Geometry = None, name: String = None):
        """ > Node Set Geometry Name

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        name : String, optional
            socket 'Name' (id: Name)


        Returns
        -------
        Geometry
        """
        node = Node('Set Geometry Name', {'Geometry': geometry, 'Name': name})
        return node._out

    @classmethod
    def set_grease_pencil_color(cls,
                    grease_pencil: GreasePencil = None,
                    selection: Boolean = None,
                    color: Color = None,
                    opacity: Float = None,
                    mode: Literal['STROKE', 'FILL'] = 'STROKE'):
        """ > Node Set Grease Pencil Color

        Parameters
        ----------
        grease_pencil : GreasePencil, optional
            socket 'Grease Pencil' (id: Grease Pencil)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        color : Color, optional
            socket 'Color' (id: Color)

        opacity : Float, optional
            socket 'Opacity' (id: Opacity)

        mode : Literal['Stroke', 'Fill']
            parameter `mode`


        Returns
        -------
        GreasePencil
        """
        utils.check_enum_arg('Set Grease Pencil Color', 'mode', mode, 'set_grease_pencil_color', ('STROKE', 'FILL'))
        node = Node('Set Grease Pencil Color', {'Grease Pencil': grease_pencil, 'Selection': selection, 'Color': color, 'Opacity': opacity}, mode=mode)
        return node._out

    @classmethod
    def set_grease_pencil_depth(cls,
                    grease_pencil: GreasePencil = None,
                    depth_order: Literal['2D', '3D'] = '2D'):
        """ > Node Set Grease Pencil Depth

        Parameters
        ----------
        grease_pencil : GreasePencil, optional
            socket 'Grease Pencil' (id: Grease Pencil)

        depth_order : Literal['2D Layers', '3D Location']
            parameter `depth_order`


        Returns
        -------
        GreasePencil
        """
        utils.check_enum_arg('Set Grease Pencil Depth', 'depth_order', depth_order, 'set_grease_pencil_depth', ('2D', '3D'))
        node = Node('Set Grease Pencil Depth', {'Grease Pencil': grease_pencil}, depth_order=depth_order)
        return node._out

    @classmethod
    def set_grease_pencil_softness(cls,
                    grease_pencil: GreasePencil = None,
                    selection: Boolean = None,
                    softness: Float = None):
        """ > Node Set Grease Pencil Softness

        Parameters
        ----------
        grease_pencil : GreasePencil, optional
            socket 'Grease Pencil' (id: Grease Pencil)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        softness : Float, optional
            socket 'Softness' (id: Softness)


        Returns
        -------
        GreasePencil
        """
        node = Node('Set Grease Pencil Softness', {'Grease Pencil': grease_pencil, 'Selection': selection, 'Softness': softness})
        return node._out

    @classmethod
    def set_grid_background(cls,
                    grid: Float = None,
                    background: Float = None,
                    update_inactive: Boolean = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Set Grid Background

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        background : Float, optional
            socket 'Background' (id: Background)

        update_inactive : Boolean, optional
            socket 'Update Inactive' (id: Update Inactive)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Set Grid Background', {'Grid': grid, 'Background': background, 'Update Inactive': update_inactive}, data_type=data_type)
        return node._out

    @classmethod
    def set_grid_transform(cls,
                    grid: Float = None,
                    transform: Matrix = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
        """ > Node Set Grid Transform

        Parameters
        ----------
        grid : Float, optional
            socket 'Grid' (id: Grid)

        transform : Matrix, optional
            socket 'Transform' (id: Transform)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
            parameter `data_type`


        Returns
        -------
        Boolean
            peer sockets: grid_ (Float)

        """
        node = Node('Set Grid Transform', {'Grid': grid, 'Transform': transform}, data_type=data_type)
        return node._out

    @classmethod
    def set_id(cls, geometry: Geometry = None, selection: Boolean = None, id: Integer = None):
        """ > Node Set ID

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        id : Integer, optional
            socket 'ID' (id: ID)


        Returns
        -------
        Geometry
        """
        node = Node('Set ID', {'Geometry': geometry, 'Selection': selection, 'ID': id})
        return node._out

    @classmethod
    def set_instance_transform(cls,
                    instances: Instances = None,
                    selection: Boolean = None,
                    transform: Matrix = None):
        """ > Node Set Instance Transform

        Parameters
        ----------
        instances : Instances, optional
            socket 'Instances' (id: Instances)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        transform : Matrix, optional
            socket 'Transform' (id: Transform)


        Returns
        -------
        Instances
        """
        node = Node('Set Instance Transform', {'Instances': instances, 'Selection': selection, 'Transform': transform})
        return node._out

    @classmethod
    def set_material(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    material: Material = None):
        """ > Node Set Material

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        material : Material, optional
            socket 'Material' (id: Material)


        Returns
        -------
        Geometry
        """
        node = Node('Set Material', {'Geometry': geometry, 'Selection': selection, 'Material': material})
        return node._out

    @classmethod
    def set_material_index(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    material_index: Integer = None):
        """ > Node Set Material Index

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        material_index : Integer, optional
            socket 'Material Index' (id: Material Index)


        Returns
        -------
        Geometry
        """
        node = Node('Set Material Index', {'Geometry': geometry, 'Selection': selection, 'Material Index': material_index})
        return node._out

    @classmethod
    def set_mesh_normal(cls,
                    mesh: Mesh = None,
                    remove_custom: Boolean = None,
                    edge_sharpness: Boolean = None,
                    face_sharpness: Boolean = None,
                    domain: Literal['POINT', 'FACE', 'CORNER'] = 'POINT',
                    mode: Literal['SHARPNESS', 'FREE', 'TANGENT_SPACE'] = 'SHARPNESS'):
        """ > Node Set Mesh Normal

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        remove_custom : Boolean, optional
            socket 'Remove Custom' (id: Remove Custom)

        edge_sharpness : Boolean, optional
            socket 'Edge Sharpness' (id: Edge Sharpness)

        face_sharpness : Boolean, optional
            socket 'Face Sharpness' (id: Face Sharpness)

        domain : Literal['Point', 'Face', 'Face Corner']
            parameter `domain`

        mode : Literal['Sharpness', 'Free', 'Tangent Space']
            parameter `mode`


        Returns
        -------
        Mesh
        """
        utils.check_enum_arg('Set Mesh Normal', 'domain', domain, 'set_mesh_normal', ('POINT', 'FACE', 'CORNER'))
        utils.check_enum_arg('Set Mesh Normal', 'mode', mode, 'set_mesh_normal', ('SHARPNESS', 'FREE', 'TANGENT_SPACE'))
        node = Node('Set Mesh Normal', {'Mesh': mesh, 'Remove Custom': remove_custom, 'Edge Sharpness': edge_sharpness, 'Face Sharpness': face_sharpness}, domain=domain, mode=mode)
        return node._out

    @classmethod
    def set_point_radius(cls, points: Cloud = None, selection: Boolean = None, radius: Float = None):
        """ > Node Set Point Radius

        Parameters
        ----------
        points : Cloud, optional
            socket 'Points' (id: Points)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        radius : Float, optional
            socket 'Radius' (id: Radius)


        Returns
        -------
        Cloud
        """
        node = Node('Set Point Radius', {'Points': points, 'Selection': selection, 'Radius': radius})
        return node._out

    @classmethod
    def set_position(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    position: Vector = None,
                    offset: Vector = None):
        """ > Node Set Position

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        position : Vector, optional
            socket 'Position' (id: Position)

        offset : Vector, optional
            socket 'Offset' (id: Offset)


        Returns
        -------
        Geometry
        """
        node = Node('Set Position', {'Geometry': geometry, 'Selection': selection, 'Position': position, 'Offset': offset})
        return node._out

    @classmethod
    def set_shade_smooth(cls,
                    mesh: Mesh = None,
                    selection: Boolean = None,
                    shade_smooth: Boolean = None,
                    domain: Literal['EDGE', 'FACE'] = 'FACE'):
        """ > Node Set Shade Smooth

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        shade_smooth : Boolean, optional
            socket 'Shade Smooth' (id: Shade Smooth)

        domain : Literal['Edge', 'Face']
            parameter `domain`


        Returns
        -------
        Mesh
        """
        utils.check_enum_arg('Set Shade Smooth', 'domain', domain, 'set_shade_smooth', ('EDGE', 'FACE'))
        node = Node('Set Shade Smooth', {'Geometry': mesh, 'Selection': selection, 'Shade Smooth': shade_smooth}, domain=domain)
        return node._out

    @classmethod
    def set_spline_cyclic(cls, curve: Curve = None, selection: Boolean = None, cyclic: Boolean = None):
        """ > Node Set Spline Cyclic

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        cyclic : Boolean, optional
            socket 'Cyclic' (id: Cyclic)


        Returns
        -------
        Curve
        """
        node = Node('Set Spline Cyclic', {'Geometry': curve, 'Selection': selection, 'Cyclic': cyclic})
        return node._out

    @classmethod
    def set_spline_resolution(cls,
                    curve: Curve = None,
                    selection: Boolean = None,
                    resolution: Integer = None):
        """ > Node Set Spline Resolution

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        resolution : Integer, optional
            socket 'Resolution' (id: Resolution)


        Returns
        -------
        Curve
        """
        node = Node('Set Spline Resolution', {'Geometry': curve, 'Selection': selection, 'Resolution': resolution})
        return node._out

    @utils.classproperty
    def simulation_input(self):
        """ > Node Simulation Input

        Returns
        -------
        Float
        """
        node = Node('Simulation Input', )
        return node._out

    @classmethod
    def simulation_output(cls, skip: Boolean = None, geometry: Geometry = None):
        """ > Node Simulation Output

        Parameters
        ----------
        skip : Boolean, optional
            socket 'Skip' (id: Skip)

        geometry : Geometry, optional
            socket 'Geometry' (id: Item_0)


        Returns
        -------
        Geometry
        """
        node = Node('Simulation Output', {'Skip': skip, 'Item_0': geometry})
        return node._out

    @classmethod
    def sort_elements(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    group_id: Integer = None,
                    sort_weight: Float = None,
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE'] = 'POINT'):
        """ > Node Sort Elements

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        group_id : Integer, optional
            socket 'Group ID' (id: Group ID)

        sort_weight : Float, optional
            socket 'Sort Weight' (id: Sort Weight)

        domain : Literal['Point', 'Edge', 'Face', 'Spline', 'Instance']
            parameter `domain`


        Returns
        -------
        Geometry
        """
        utils.check_enum_arg('Sort Elements', 'domain', domain, 'sort_elements', ('POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE'))
        node = Node('Sort Elements', {'Geometry': geometry, 'Selection': selection, 'Group ID': group_id, 'Sort Weight': sort_weight}, domain=domain)
        return node._out

    @classmethod
    def spline_length(cls):
        """ > Node Spline Length

        Returns
        -------
        Float
            peer sockets: point_count_ (Integer)

        """
        node = Node('Spline Length', )
        return node

    @classmethod
    def spline_parameter(cls):
        """ > Node Spline Parameter

        Returns
        -------
        Float
            peer sockets: length_ (Float), index_ (Integer)

        """
        node = Node('Spline Parameter', )
        return node

    @classmethod
    def split_edges(cls, mesh: Mesh = None, selection: Boolean = None):
        """ > Node Split Edges

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)


        Returns
        -------
        Mesh
        """
        node = Node('Split Edges', {'Mesh': mesh, 'Selection': selection})
        return node._out

    @classmethod
    def split_to_instances(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    group_id: Integer = None,
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
        """ > Node Split to Instances

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        group_id : Integer, optional
            socket 'Group ID' (id: Group ID)

        domain : Literal['Point', 'Edge', 'Face', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Instances
            peer sockets: group_id_ (Integer)

        """
        utils.check_enum_arg('Split to Instances', 'domain', domain, 'split_to_instances', ('POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Split to Instances', {'Geometry': geometry, 'Selection': selection, 'Group ID': group_id}, domain=domain)
        return node._out

    @classmethod
    def store_named_attribute(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    name: String = None,
                    value: Float = None,
                    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'):
        """ > Node Store Named Attribute

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        name : String, optional
            socket 'Name' (id: Name)

        value : Float, optional
            socket 'Value' (id: Value)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix', '8-Bit Integer', '2D Vector', 'Byte Color']
            parameter `data_type`

        domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`


        Returns
        -------
        Geometry
        """
        utils.check_enum_arg('Store Named Attribute', 'domain', domain, 'store_named_attribute', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Store Named Attribute', {'Geometry': geometry, 'Selection': selection, 'Name': name, 'Value': value}, data_type=data_type, domain=domain)
        return node._out

    @classmethod
    def store_named_grid(cls,
                    volume: Volume = None,
                    name: String = None,
                    grid: Float = None,
                    data_type: Literal['BOOLEAN', 'FLOAT', 'INT', 'VECTOR_FLOAT'] = 'FLOAT'):
        """ > Node Store Named Grid

        Parameters
        ----------
        volume : Volume, optional
            socket 'Volume' (id: Volume)

        name : String, optional
            socket 'Name' (id: Name)

        grid : Float, optional
            socket 'Grid' (id: Grid)

        data_type : Literal['Boolean', 'Float', 'Integer', 'Vector']
            parameter `data_type`


        Returns
        -------
        Volume
        """
        node = Node('Store Named Grid', {'Volume': volume, 'Name': name, 'Grid': grid}, data_type=data_type)
        return node._out

    @classmethod
    def join_strings(cls, *strings: String, delimiter: String = None):
        """ > Node Join Strings

        Parameters
        ----------
        delimiter : String, optional
            socket 'Delimiter' (id: Delimiter)

        strings : String, optional
            socket 'Strings' (id: Strings)


        Returns
        -------
        String
        """
        node = Node('Join Strings', {'Delimiter': delimiter, 'Strings': list(strings)})
        return node._out

    @classmethod
    def string_to_curves(cls,
                    string: String = None,
                    size: Float = None,
                    font: Font = None,
                    align_x: Literal['Left', 'Center', 'Right', 'Justify', 'Flush'] = None,
                    align_y: Literal['Top', 'Top Baseline', 'Middle', 'Bottom Baseline', 'Bottom'] = None,
                    pivot_point: Literal['Midpoint', 'Top Left', 'Top Center', 'Top Right', 'Bottom Left', 'Bottom Center', 'Bottom Right'] = None,
                    character_spacing: Float = None,
                    word_spacing: Float = None,
                    line_spacing: Float = None,
                    overflow: Literal['Overflow', 'Scale To Fit', 'Truncate'] = None,
                    text_box_width: Float = None,
                    text_box_height: Float = None):
        """ > Node String to Curves

        Parameters
        ----------
        string : String, optional
            socket 'String' (id: String)

        size : Float, optional
            socket 'Size' (id: Size)

        font : Font, optional
            socket 'Font' (id: Font)

        align_x : menu='Left', optional
            ('Left', 'Center', 'Right', 'Justify', 'Flush')

        align_y : menu='Top Baseline', optional
            ('Top', 'Top Baseline', 'Middle', 'Bottom Baseline', 'Bottom')

        pivot_point : menu='Midpoint', optional
            ('Midpoint', 'Top Left', 'Top Center', 'Top Right', 'Bottom Left', 'Bottom Center', 'Bottom Right')

        character_spacing : Float, optional
            socket 'Character Spacing' (id: Character Spacing)

        word_spacing : Float, optional
            socket 'Word Spacing' (id: Word Spacing)

        line_spacing : Float, optional
            socket 'Line Spacing' (id: Line Spacing)

        overflow : menu='Overflow', optional
            ('Overflow', 'Scale To Fit', 'Truncate')

        text_box_width : Float, optional
            socket 'Text Box Width' (id: Text Box Width)

        text_box_height : Float, optional
            socket 'Text Box Height' (id: Text Box Height)


        Returns
        -------
        Instances
            peer sockets: remainder_ (String), line_ (Integer), word_ (Integer), pivot_point_ (Vector)

        """
        node = Node('String to Curves', {'String': string, 'Size': size, 'Font': font, 'Align X': align_x, 'Align Y': align_y, 'Pivot Point': pivot_point, 'Character Spacing': character_spacing, 'Word Spacing': word_spacing, 'Line Spacing': line_spacing, 'Overflow': overflow, 'Text Box Width': text_box_width, 'Text Box Height': text_box_height})
        return node._out

    @classmethod
    def subdivide_curve(cls, curve: Curve = None, cuts: Integer = None):
        """ > Node Subdivide Curve

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        cuts : Integer, optional
            socket 'Cuts' (id: Cuts)


        Returns
        -------
        Curve
        """
        node = Node('Subdivide Curve', {'Curve': curve, 'Cuts': cuts})
        return node._out

    @classmethod
    def subdivide_mesh(cls, mesh: Mesh = None, level: Integer = None):
        """ > Node Subdivide Mesh

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        level : Integer, optional
            socket 'Level' (id: Level)


        Returns
        -------
        Mesh
        """
        node = Node('Subdivide Mesh', {'Mesh': mesh, 'Level': level})
        return node._out

    @classmethod
    def subdivision_surface(cls,
                    mesh: Mesh = None,
                    level: Integer = None,
                    edge_crease: Float = None,
                    vertex_crease: Float = None,
                    limit_surface: Boolean = None,
                    uv_smooth: Literal['None', 'Keep Corners', 'Keep Corners, Junctions', 'Keep Corners, Junctions, Concave', 'Keep Boundaries', 'All'] = None,
                    boundary_smooth: Literal['Keep Corners', 'All'] = None):
        """ > Node Subdivision Surface

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        level : Integer, optional
            socket 'Level' (id: Level)

        edge_crease : Float, optional
            socket 'Edge Crease' (id: Edge Crease)

        vertex_crease : Float, optional
            socket 'Vertex Crease' (id: Vertex Crease)

        limit_surface : Boolean, optional
            socket 'Limit Surface' (id: Limit Surface)

        uv_smooth : menu='Keep Boundaries', optional
            ('None', 'Keep Corners', 'Keep Corners, Junctions', 'Keep Corners, Junctions, Concave', 'Keep Boundaries', 'All')

        boundary_smooth : menu='All', optional
            ('Keep Corners', 'All')


        Returns
        -------
        Mesh
        """
        node = Node('Subdivision Surface', {'Mesh': mesh, 'Level': level, 'Edge Crease': edge_crease, 'Vertex Crease': vertex_crease, 'Limit Surface': limit_surface, 'UV Smooth': uv_smooth, 'Boundary Smooth': boundary_smooth})
        return node._out

    @classmethod
    def switch(cls,
                    switch: Boolean = None,
                    false: Float = None,
                    true: Float = None,
                    input_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT'):
        """ > Node Switch

        Parameters
        ----------
        switch : Boolean, optional
            socket 'Switch' (id: Switch)

        false : Float, optional
            socket 'False' (id: False)

        true : Float, optional
            socket 'True' (id: True)

        input_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
            parameter `input_type`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Switch', 'input_type', input_type, 'switch', ('FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'))
        node = Node('Switch', {'Switch': switch, 'False': false, 'True': true}, input_type=input_type)
        return node._out

    @classmethod
    def _3d_cursor(cls):
        """ > Node 3D Cursor

        Returns
        -------
        Vector
            peer sockets: rotation_ (Rotation)

        """
        node = Node('3D Cursor', )
        return node

    @classmethod
    def active_element(cls, domain: Literal['POINT', 'EDGE', 'FACE', 'LAYER'] = 'POINT'):
        """ > Node Active Element

        Parameters
        ----------
        domain : Literal['Point', 'Edge', 'Face', 'Layer']
            parameter `domain`


        Returns
        -------
        Integer
            peer sockets: exists_ (Boolean)

        """
        utils.check_enum_arg('Active Element', 'domain', domain, 'active_element', ('POINT', 'EDGE', 'FACE', 'LAYER'))
        node = Node('Active Element', domain=domain)
        return node

    @classmethod
    def face_set(cls):
        """ > Node Face Set

        Returns
        -------
        Integer
            peer sockets: exists_ (Boolean)

        """
        node = Node('Face Set', )
        return node

    @classmethod
    def mouse_position(cls):
        """ > Node Mouse Position

        Returns
        -------
        Integer
            peer sockets: mouse_y_ (Integer), region_width_ (Integer), region_height_ (Integer)

        """
        node = Node('Mouse Position', )
        return node

    @classmethod
    def selection(cls):
        """ > Node Selection

        Returns
        -------
        Boolean
            peer sockets: float_ (Float)

        """
        node = Node('Selection', )
        return node

    @classmethod
    def set_face_set(cls, mesh: Mesh = None, selection: Boolean = None, face_set: Integer = None):
        """ > Node Set Face Set

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        face_set : Integer, optional
            socket 'Face Set' (id: Face Set)


        Returns
        -------
        Mesh
        """
        node = Node('Set Face Set', {'Mesh': mesh, 'Selection': selection, 'Face Set': face_set})
        return node._out

    @classmethod
    def set_selection(cls,
                    geometry: Geometry = None,
                    selection: Boolean = None,
                    domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE'] = 'POINT',
                    selection_type: Literal['BOOLEAN', 'FLOAT'] = 'BOOLEAN'):
        """ > Node Set Selection

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        domain : Literal['Point', 'Edge', 'Face', 'Spline']
            parameter `domain`

        selection_type : Literal['Boolean', 'Float']
            parameter `selection_type`


        Returns
        -------
        Geometry
        """
        utils.check_enum_arg('Set Selection', 'domain', domain, 'set_selection', ('POINT', 'EDGE', 'FACE', 'CURVE'))
        utils.check_enum_arg('Set Selection', 'selection_type', selection_type, 'set_selection', ('BOOLEAN', 'FLOAT'))
        node = Node('Set Selection', {'Geometry': geometry, 'Selection': selection}, domain=domain, selection_type=selection_type)
        return node._out

    @classmethod
    def transform_geometry(cls,
                    geometry: Geometry = None,
                    mode: Literal['Components', 'Matrix'] = None,
                    translation: Vector = None,
                    rotation: Rotation = None,
                    scale: Vector = None,
                    transform: Matrix = None):
        """ > Node Transform Geometry

        Parameters
        ----------
        geometry : Geometry, optional
            socket 'Geometry' (id: Geometry)

        mode : menu='Components', optional
            ('Components', 'Matrix')

        translation : Vector, optional
            socket 'Translation' (id: Translation)

        rotation : Rotation, optional
            socket 'Rotation' (id: Rotation)

        scale : Vector, optional
            socket 'Scale' (id: Scale)

        transform : Matrix, optional
            socket 'Transform' (id: Transform)


        Returns
        -------
        Geometry
        """
        node = Node('Transform Geometry', {'Geometry': geometry, 'Mode': mode, 'Translation': translation, 'Rotation': rotation, 'Scale': scale, 'Transform': transform})
        return node._out

    @classmethod
    def translate_instances(cls,
                    instances: Instances = None,
                    selection: Boolean = None,
                    translation: Vector = None,
                    local_space: Boolean = None):
        """ > Node Translate Instances

        Parameters
        ----------
        instances : Instances, optional
            socket 'Instances' (id: Instances)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        translation : Vector, optional
            socket 'Translation' (id: Translation)

        local_space : Boolean, optional
            socket 'Local Space' (id: Local Space)


        Returns
        -------
        Instances
        """
        node = Node('Translate Instances', {'Instances': instances, 'Selection': selection, 'Translation': translation, 'Local Space': local_space})
        return node._out

    @classmethod
    def triangulate(cls,
                    mesh: Mesh = None,
                    selection: Boolean = None,
                    quad_method: Literal['Beauty', 'Fixed', 'Fixed Alternate', 'Shortest Diagonal', 'Longest Diagonal'] = None,
                    n_gon_method: Literal['Beauty', 'Clip'] = None):
        """ > Node Triangulate

        Parameters
        ----------
        mesh : Mesh, optional
            socket 'Mesh' (id: Mesh)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        quad_method : menu='Shortest Diagonal', optional
            ('Beauty', 'Fixed', 'Fixed Alternate', 'Shortest Diagonal', 'Longest Diagonal')

        n_gon_method : menu='Beauty', optional
            ('Beauty', 'Clip')


        Returns
        -------
        Mesh
        """
        node = Node('Triangulate', {'Mesh': mesh, 'Selection': selection, 'Quad Method': quad_method, 'N-gon Method': n_gon_method})
        return node._out

    @classmethod
    def trim_curve(cls,
                    curve: Curve = None,
                    selection: Boolean = None,
                    start: Float = None,
                    end: Float = None,
                    start_1: Float = None,
                    end_1: Float = None,
                    mode: Literal['FACTOR', 'LENGTH'] = 'FACTOR'):
        """ > Node Trim Curve

        Parameters
        ----------
        curve : Curve, optional
            socket 'Curve' (id: Curve)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        start : Float, optional
            socket 'Start' (id: Start)

        end : Float, optional
            socket 'End' (id: End)

        start_1 : Float, optional
            socket 'Start' (id: Start_001)

        end_1 : Float, optional
            socket 'End' (id: End_001)

        mode : Literal['Factor', 'Length']
            parameter `mode`


        Returns
        -------
        Curve
        """
        utils.check_enum_arg('Trim Curve', 'mode', mode, 'trim_curve', ('FACTOR', 'LENGTH'))
        node = Node('Trim Curve', {'Curve': curve, 'Selection': selection, 'Start': start, 'End': end, 'Start_001': start_1, 'End_001': end_1}, mode=mode)
        return node._out

    @classmethod
    def pack_uv_islands(cls,
                    uv: Vector = None,
                    selection: Boolean = None,
                    margin: Float = None,
                    rotate: Boolean = None,
                    method: Literal['Bounding Box', 'Convex Hull', 'Exact Shape'] = None,
                    bottom_left: Vector = None,
                    top_right: Vector = None):
        """ > Node Pack UV Islands

        Parameters
        ----------
        uv : Vector, optional
            socket 'UV' (id: UV)

        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        margin : Float, optional
            socket 'Margin' (id: Margin)

        rotate : Boolean, optional
            socket 'Rotate' (id: Rotate)

        method : menu='Bounding Box', optional
            ('Bounding Box', 'Convex Hull', 'Exact Shape')

        bottom_left : Vector, optional
            socket 'Bottom Left' (id: Bottom Left)

        top_right : Vector, optional
            socket 'Top Right' (id: Top Right)


        Returns
        -------
        Vector
        """
        node = Node('Pack UV Islands', {'UV': uv, 'Selection': selection, 'Margin': margin, 'Rotate': rotate, 'Method': method, 'Bottom Left': bottom_left, 'Top Right': top_right})
        return node._out

    @classmethod
    def uv_tangent(cls, method: Literal['Exact', 'Fast'] = None, uv: Vector = None):
        """ > Node UV Tangent

        Parameters
        ----------
        method : menu='Exact', optional
            ('Exact', 'Fast')

        uv : Vector, optional
            socket 'UV' (id: UV)


        Returns
        -------
        Vector
        """
        node = Node('UV Tangent', {'Method': method, 'UV': uv})
        return node._out

    @classmethod
    def uv_unwrap(cls,
                    selection: Boolean = None,
                    seam: Boolean = None,
                    margin: Float = None,
                    fill_holes: Boolean = None,
                    method: Literal['Angle Based', 'Conformal', 'Minimum Stretch'] = None,
                    iterations: Integer = None,
                    no_flip: Boolean = None):
        """ > Node UV Unwrap

        Parameters
        ----------
        selection : Boolean, optional
            socket 'Selection' (id: Selection)

        seam : Boolean, optional
            socket 'Seam' (id: Seam)

        margin : Float, optional
            socket 'Margin' (id: Margin)

        fill_holes : Boolean, optional
            socket 'Fill Holes' (id: Fill Holes)

        method : menu='Angle Based', optional
            ('Angle Based', 'Conformal', 'Minimum Stretch')

        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)

        no_flip : Boolean, optional
            socket 'No Flip' (id: No Flip)


        Returns
        -------
        Vector
        """
        node = Node('UV Unwrap', {'Selection': selection, 'Seam': seam, 'Margin': margin, 'Fill Holes': fill_holes, 'Method': method, 'Iterations': iterations, 'No Flip': no_flip})
        return node._out

    @classmethod
    def vertex_of_corner(cls, corner_index: Integer = None):
        """ > Node Vertex of Corner

        Parameters
        ----------
        corner_index : Integer, optional
            socket 'Corner Index' (id: Corner Index)


        Returns
        -------
        Integer
        """
        node = Node('Vertex of Corner', {'Corner Index': corner_index})
        return node._out

    @classmethod
    def viewer(cls,
                    named_sockets: dict = {},
                    domain: Literal['AUTO', 'POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'AUTO',
                    ui_shortcut = 0,
                    **sockets):
        """ > Node Viewer

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        domain : Literal['Auto', 'Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
            parameter `domain`

        ui_shortcut : int
            parameter `ui_shortcut`

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        None
        """
        utils.check_enum_arg('Viewer', 'domain', domain, 'viewer', ('AUTO', 'POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
        node = Node('Viewer', named_sockets, domain=domain, ui_shortcut=ui_shortcut, **sockets)
        return node._out

    @classmethod
    def viewport_transform(cls):
        """ > Node Viewport Transform

        Returns
        -------
        Matrix
            peer sockets: view_ (Matrix), is_orthographic_ (Boolean)

        """
        node = Node('Viewport Transform', )
        return node

    @classmethod
    def volume_cube(cls,
                    density: Float = None,
                    background: Float = None,
                    min: Vector = None,
                    max: Vector = None,
                    resolution_x: Integer = None,
                    resolution_y: Integer = None,
                    resolution_z: Integer = None):
        """ > Node Volume Cube

        Parameters
        ----------
        density : Float, optional
            socket 'Density' (id: Density)

        background : Float, optional
            socket 'Background' (id: Background)

        min : Vector, optional
            socket 'Min' (id: Min)

        max : Vector, optional
            socket 'Max' (id: Max)

        resolution_x : Integer, optional
            socket 'Resolution X' (id: Resolution X)

        resolution_y : Integer, optional
            socket 'Resolution Y' (id: Resolution Y)

        resolution_z : Integer, optional
            socket 'Resolution Z' (id: Resolution Z)


        Returns
        -------
        Volume
        """
        node = Node('Volume Cube', {'Density': density, 'Background': background, 'Min': min, 'Max': max, 'Resolution X': resolution_x, 'Resolution Y': resolution_y, 'Resolution Z': resolution_z})
        return node._out

    @classmethod
    def volume_to_mesh(cls,
                    volume: Volume = None,
                    resolution_mode: Literal['Grid', 'Amount', 'Size'] = None,
                    voxel_size: Float = None,
                    voxel_amount: Float = None,
                    threshold: Float = None,
                    adaptivity: Float = None):
        """ > Node Volume to Mesh

        Parameters
        ----------
        volume : Volume, optional
            socket 'Volume' (id: Volume)

        resolution_mode : menu='Grid', optional
            ('Grid', 'Amount', 'Size')

        voxel_size : Float, optional
            socket 'Voxel Size' (id: Voxel Size)

        voxel_amount : Float, optional
            socket 'Voxel Amount' (id: Voxel Amount)

        threshold : Float, optional
            socket 'Threshold' (id: Threshold)

        adaptivity : Float, optional
            socket 'Adaptivity' (id: Adaptivity)


        Returns
        -------
        Mesh
        """
        node = Node('Volume to Mesh', {'Volume': volume, 'Resolution Mode': resolution_mode, 'Voxel Size': voxel_size, 'Voxel Amount': voxel_amount, 'Threshold': threshold, 'Adaptivity': adaptivity})
        return node._out

    @classmethod
    def warning(cls,
                    show: Boolean = None,
                    message: String = None,
                    warning_type: Literal['ERROR', 'WARNING', 'INFO'] = 'ERROR'):
        """ > Node Warning

        Parameters
        ----------
        show : Boolean, optional
            socket 'Show' (id: Show)

        message : String, optional
            socket 'Message' (id: Message)

        warning_type : Literal['Error', 'Warning', 'Info']
            parameter `warning_type`


        Returns
        -------
        Boolean
        """
        utils.check_enum_arg('Warning', 'warning_type', warning_type, 'warning', ('ERROR', 'WARNING', 'INFO'))
        node = Node('Warning', {'Show': show, 'Message': message}, warning_type=warning_type)
        return node._out

    @utils.classproperty
    def closure_input(self):
        """ > Node Closure Input

        Returns
        -------
        None
        """
        node = Node('Closure Input', )
        return node._out

    @classmethod
    def closure_output(cls, active_input_index = 0, active_output_index = 0, define_signature = False):
        """ > Node Closure Output

        Parameters
        ----------
        active_input_index : int
            parameter `active_input_index`

        active_output_index : int
            parameter `active_output_index`

        define_signature : bool
            parameter `define_signature`


        Returns
        -------
        Closure
        """
        node = Node('Closure Output', active_input_index=active_input_index, active_output_index=active_output_index, define_signature=define_signature)
        return node._out

    @classmethod
    def combine_bundle(cls, named_sockets: dict = {}, define_signature = False, **sockets):
        """ > Node Combine Bundle

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        define_signature : bool
            parameter `define_signature`

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        Bundle
        """
        node = Node('Combine Bundle', named_sockets, define_signature=define_signature, **sockets)
        return node._out

    @classmethod
    def enable_output(cls,
                    enable: Boolean = None,
                    value: Float = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT'):
        """ > Node Enable Output

        Parameters
        ----------
        enable : Boolean, optional
            socket 'Enable' (id: Enable)

        value : Float, optional
            socket 'Value' (id: Value)

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
            parameter `data_type`


        Returns
        -------
        Float
        """
        node = Node('Enable Output', {'Enable': enable, 'Value': value}, data_type=data_type)
        return node._out

    @classmethod
    def evaluate_closure(cls,
                    closure: Closure = None,
                    active_input_index = 0,
                    active_output_index = 0,
                    define_signature = False):
        """ > Node Evaluate Closure

        Parameters
        ----------
        closure : Closure, optional
            socket 'Closure' (id: Closure)

        active_input_index : int
            parameter `active_input_index`

        active_output_index : int
            parameter `active_output_index`

        define_signature : bool
            parameter `define_signature`


        Returns
        -------
        None
        """
        node = Node('Evaluate Closure', {'Closure': closure}, active_input_index=active_input_index, active_output_index=active_output_index, define_signature=define_signature)
        return node._out

    @classmethod
    def frame(cls, label_size = 20, shrink = True, text = None):
        """ > Node Frame

        Parameters
        ----------
        label_size : int
            parameter `label_size`

        shrink : bool
            parameter `shrink`

        text : NoneType
            parameter `text`


        Returns
        -------
        None
        """
        node = Node('Frame', label_size=label_size, shrink=shrink, text=text)
        return node._out

    @classmethod
    def get_bundle_item(cls,
                    bundle: Bundle = None,
                    path: String = None,
                    remove: Boolean = None,
                    socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
                    structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO'):
        """ > Node Get Bundle Item

        Parameters
        ----------
        bundle : Bundle, optional
            socket 'Bundle' (id: Bundle)

        path : String, optional
            socket 'Path' (id: Path)

        remove : Boolean, optional
            socket 'Remove' (id: Remove)

        socket_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
            parameter `socket_type`

        structure_type : Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']
            parameter `structure_type`


        Returns
        -------
        Bundle
            peer sockets: item_ (Float), exists_ (Boolean)

        """
        utils.check_enum_arg('Get Bundle Item', 'socket_type', socket_type, 'get_bundle_item', ('FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'))
        utils.check_enum_arg('Get Bundle Item', 'structure_type', structure_type, 'get_bundle_item', ('AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'))
        node = Node('Get Bundle Item', {'Bundle': bundle, 'Path': path, 'Remove': remove}, socket_type=socket_type, structure_type=structure_type)
        return node._out

    @utils.classproperty
    def group_input(self):
        """ > Node Group Input

        Returns
        -------
        None
        """
        node = Node('Group Input', )
        return node._out

    @classmethod
    def group_output(cls, is_active_output = True):
        """ > Node Group Output

        Parameters
        ----------
        is_active_output : bool
            parameter `is_active_output`


        Returns
        -------
        None
        """
        node = Node('Group Output', is_active_output=is_active_output)
        return node._out

    @classmethod
    def join_bundle(cls, *bundle: Bundle):
        """ > Node Join Bundle

        Parameters
        ----------
        bundle : Bundle, optional
            socket 'Bundle' (id: Bundle)


        Returns
        -------
        Bundle
        """
        node = Node('Join Bundle', {'Bundle': list(bundle)})
        return node._out

    @classmethod
    def reroute(cls, input: Color = None, socket_idname = 'NodeSocketColor'):
        """ > Node Reroute

        Parameters
        ----------
        input : Color, optional
            socket 'Input' (id: Input)

        socket_idname : str
            parameter `socket_idname`


        Returns
        -------
        Color
        """
        node = Node('Reroute', {'Input': input}, socket_idname=socket_idname)
        return node._out

    @classmethod
    def separate_bundle(cls,
                    named_sockets: dict = {},
                    bundle: Bundle = None,
                    define_signature = False,
                    **sockets):
        """ > Node Separate Bundle

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        bundle : Bundle, optional
            socket 'Bundle' (id: Bundle)

        define_signature : bool
            parameter `define_signature`

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        None
        """
        node = Node('Separate Bundle', {'Bundle': bundle, **named_sockets}, define_signature=define_signature, **sockets)
        return node

    @classmethod
    def store_bundle_item(cls,
                    bundle: Bundle = None,
                    path: String = None,
                    item: Float = None,
                    socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
                    structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO'):
        """ > Node Store Bundle Item

        Parameters
        ----------
        bundle : Bundle, optional
            socket 'Bundle' (id: Bundle)

        path : String, optional
            socket 'Path' (id: Path)

        item : Float, optional
            socket 'Item' (id: Item)

        socket_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
            parameter `socket_type`

        structure_type : Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']
            parameter `structure_type`


        Returns
        -------
        Bundle
        """
        utils.check_enum_arg('Store Bundle Item', 'socket_type', socket_type, 'store_bundle_item', ('FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'))
        utils.check_enum_arg('Store Bundle Item', 'structure_type', structure_type, 'store_bundle_item', ('AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'))
        node = Node('Store Bundle Item', {'Bundle': bundle, 'Path': path, 'Item': item}, socket_type=socket_type, structure_type=structure_type)
        return node._out

    @classmethod
    def blackbody(cls, temperature: Float = None):
        """ > Node Blackbody

        Parameters
        ----------
        temperature : Float, optional
            socket 'Temperature' (id: Temperature)


        Returns
        -------
        Color
        """
        node = Node('Blackbody', {'Temperature': temperature})
        return node._out

    @classmethod
    def clamp(cls,
                    value: Float = None,
                    min: Float = None,
                    max: Float = None,
                    clamp_type: Literal['MINMAX', 'RANGE'] = 'MINMAX'):
        """ > Node Clamp

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        min : Float, optional
            socket 'Min' (id: Min)

        max : Float, optional
            socket 'Max' (id: Max)

        clamp_type : Literal['Min Max', 'Range']
            parameter `clamp_type`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Clamp', 'clamp_type', clamp_type, 'clamp', ('MINMAX', 'RANGE'))
        node = Node('Clamp', {'Value': value, 'Min': min, 'Max': max}, clamp_type=clamp_type)
        return node._out

    @classmethod
    def combine_xyz(cls, x: Float = None, y: Float = None, z: Float = None):
        """ > Node Combine XYZ

        Parameters
        ----------
        x : Float, optional
            socket 'X' (id: X)

        y : Float, optional
            socket 'Y' (id: Y)

        z : Float, optional
            socket 'Z' (id: Z)


        Returns
        -------
        Vector
        """
        node = Node('Combine XYZ', {'X': x, 'Y': y, 'Z': z})
        return node._out

    @classmethod
    def float_curve(cls, value: Float = None, factor: Float = None):
        """ > Node Float Curve

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        factor : Float, optional
            socket 'Factor' (id: Factor)


        Returns
        -------
        Float
        """
        node = NodeCurves('Float Curve', {'Value': value, 'Factor': factor})
        return node._out

    @classmethod
    def gamma(cls, color: Color = None, gamma: Float = None):
        """ > Node Gamma

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        gamma : Float, optional
            socket 'Gamma' (id: Gamma)


        Returns
        -------
        Color
        """
        node = Node('Gamma', {'Color': color, 'Gamma': gamma})
        return node._out

    @classmethod
    def map_range(cls,
                    value: Float = None,
                    from_min: Float = None,
                    from_max: Float = None,
                    to_min: Float = None,
                    to_max: Float = None,
                    steps: Float = None,
                    vector: Vector = None,
                    from_min_1: Vector = None,
                    from_max_1: Vector = None,
                    to_min_1: Vector = None,
                    to_max_1: Vector = None,
                    steps_1: Vector = None,
                    clamp = True,
                    data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
                    interpolation_type: Literal['LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'] = 'LINEAR'):
        """ > Node Map Range

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        from_min : Float, optional
            socket 'From Min' (id: From Min)

        from_max : Float, optional
            socket 'From Max' (id: From Max)

        to_min : Float, optional
            socket 'To Min' (id: To Min)

        to_max : Float, optional
            socket 'To Max' (id: To Max)

        steps : Float, optional
            socket 'Steps' (id: Steps)

        vector : Vector, optional
            socket 'Vector' (id: Vector)

        from_min_1 : Vector, optional
            socket 'From Min' (id: From_Min_FLOAT3)

        from_max_1 : Vector, optional
            socket 'From Max' (id: From_Max_FLOAT3)

        to_min_1 : Vector, optional
            socket 'To Min' (id: To_Min_FLOAT3)

        to_max_1 : Vector, optional
            socket 'To Max' (id: To_Max_FLOAT3)

        steps_1 : Vector, optional
            socket 'Steps' (id: Steps_FLOAT3)

        clamp : bool
            parameter `clamp`

        data_type : Literal['Float', 'Vector']
            parameter `data_type`

        interpolation_type : Literal['Linear', 'Stepped Linear', 'Smooth Step', 'Smoother Step']
            parameter `interpolation_type`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Map Range', 'interpolation_type', interpolation_type, 'map_range', ('LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'))
        node = Node('Map Range', {'Value': value, 'From Min': from_min, 'From Max': from_max, 'To Min': to_min, 'To Max': to_max, 'Steps': steps, 'Vector': vector, 'From_Min_FLOAT3': from_min_1, 'From_Max_FLOAT3': from_max_1, 'To_Min_FLOAT3': to_min_1, 'To_Max_FLOAT3': to_max_1, 'Steps_FLOAT3': steps_1}, clamp=clamp, data_type=data_type, interpolation_type=interpolation_type)
        return node._out

    @classmethod
    def math(cls,
                    value: Float = None,
                    value_1: Float = None,
                    value_2: Float = None,
                    operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'POWER', 'LOGARITHM', 'SQRT', 'INVERSE_SQRT', 'ABSOLUTE', 'EXPONENT', 'MINIMUM', 'MAXIMUM', 'LESS_THAN', 'GREATER_THAN', 'SIGN', 'COMPARE', 'SMOOTH_MIN', 'SMOOTH_MAX', 'ROUND', 'FLOOR', 'CEIL', 'TRUNC', 'FRACT', 'MODULO', 'FLOORED_MODULO', 'WRAP', 'SNAP', 'PINGPONG', 'SINE', 'COSINE', 'TANGENT', 'ARCSINE', 'ARCCOSINE', 'ARCTANGENT', 'ARCTAN2', 'SINH', 'COSH', 'TANH', 'RADIANS', 'DEGREES'] = 'ADD',
                    use_clamp = False):
        """ > Node Math

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        value_1 : Float, optional
            socket 'Value' (id: Value_001)

        value_2 : Float, optional
            socket 'Value' (id: Value_002)

        operation : Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Power', 'Logarithm', 'Square Root', 'Inverse Square Root', 'Absolute', 'Exponent', 'Minimum', 'Maximum', 'Less Than', 'Greater Than', 'Sign', 'Compare', 'Smooth Minimum', 'Smooth Maximum', 'Round', 'Floor', 'Ceil', 'Truncate', 'Fraction', 'Truncated Modulo', 'Floored Modulo', 'Wrap', 'Snap', 'Ping-Pong', 'Sine', 'Cosine', 'Tangent', 'Arcsine', 'Arccosine', 'Arctangent', 'Arctan2', 'Hyperbolic Sine', 'Hyperbolic Cosine', 'Hyperbolic Tangent', 'To Radians', 'To Degrees']
            parameter `operation`

        use_clamp : bool
            parameter `use_clamp`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Math', 'operation', operation, 'math', ('ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'POWER', 'LOGARITHM', 'SQRT', 'INVERSE_SQRT', 'ABSOLUTE', 'EXPONENT', 'MINIMUM', 'MAXIMUM', 'LESS_THAN', 'GREATER_THAN', 'SIGN', 'COMPARE', 'SMOOTH_MIN', 'SMOOTH_MAX', 'ROUND', 'FLOOR', 'CEIL', 'TRUNC', 'FRACT', 'MODULO', 'FLOORED_MODULO', 'WRAP', 'SNAP', 'PINGPONG', 'SINE', 'COSINE', 'TANGENT', 'ARCSINE', 'ARCCOSINE', 'ARCTANGENT', 'ARCTAN2', 'SINH', 'COSH', 'TANH', 'RADIANS', 'DEGREES'))
        node = Node('Math', {'Value': value, 'Value_001': value_1, 'Value_002': value_2}, operation=operation, use_clamp=use_clamp)
        return node._out

    @classmethod
    def mix(cls,
                    a: Float = None,
                    b: Float = None,
                    a_1: Vector = None,
                    b_1: Vector = None,
                    a_2: Color = None,
                    b_2: Color = None,
                    a_3: Rotation = None,
                    b_3: Rotation = None,
                    factor: Vector = None,
                    blend_type: Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'] = 'MIX',
                    clamp_factor = True,
                    clamp_result = False,
                    data_type: Literal['FLOAT', 'VECTOR', 'RGBA', 'ROTATION'] = 'FLOAT',
                    factor_mode: Literal['UNIFORM', 'NON_UNIFORM'] = 'UNIFORM'):
        """ > Node Mix

        Parameters
        ----------
        a : Float, optional
            socket 'A' (id: A_Float)

        b : Float, optional
            socket 'B' (id: B_Float)

        a_1 : Vector, optional
            socket 'A' (id: A_Vector)

        b_1 : Vector, optional
            socket 'B' (id: B_Vector)

        a_2 : Color, optional
            socket 'A' (id: A_Color)

        b_2 : Color, optional
            socket 'B' (id: B_Color)

        a_3 : Rotation, optional
            socket 'A' (id: A_Rotation)

        b_3 : Rotation, optional
            socket 'B' (id: B_Rotation)

        factor : Vector, optional
            socket 'Factor' (id: Factor_Vector)

        blend_type : Literal['Mix', 'Darken', 'Multiply', 'Color Burn', 'Lighten', 'Screen', 'Color Dodge', 'Add', 'Overlay', 'Soft Light', 'Linear Light', 'Difference', 'Exclusion', 'Subtract', 'Divide', 'Hue', 'Saturation', 'Color', 'Value']
            parameter `blend_type`

        clamp_factor : bool
            parameter `clamp_factor`

        clamp_result : bool
            parameter `clamp_result`

        data_type : Literal['Float', 'Vector', 'Color', 'Rotation']
            parameter `data_type`

        factor_mode : Literal['Uniform', 'Non-Uniform']
            parameter `factor_mode`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Mix', 'blend_type', blend_type, 'mix', ('MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'))
        utils.check_enum_arg('Mix', 'factor_mode', factor_mode, 'mix', ('UNIFORM', 'NON_UNIFORM'))
        node = Node('Mix', {'A_Float': a, 'B_Float': b, 'A_Vector': a_1, 'B_Vector': b_1, 'A_Color': a_2, 'B_Color': b_2, 'A_Rotation': a_3, 'B_Rotation': b_3, 'Factor_Vector': factor}, blend_type=blend_type, clamp_factor=clamp_factor, clamp_result=clamp_result, data_type=data_type, factor_mode=factor_mode)
        return node._out

    @classmethod
    def rgb_curves(cls, color: Color = None, factor: Float = None):
        """ > Node RGB Curves

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        factor : Float, optional
            socket 'Factor' (id: Fac)


        Returns
        -------
        Color
        """
        node = NodeCurves('RGB Curves', {'Color': color, 'Fac': factor})
        return node._out

    @classmethod
    def radial_tiling(cls,
                    vector: Vector = None,
                    sides: Float = None,
                    roundness: Float = None,
                    normalize = False):
        """ > Node Radial Tiling

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        sides : Float, optional
            socket 'Sides' (id: Sides)

        roundness : Float, optional
            socket 'Roundness' (id: Roundness)

        normalize : bool
            parameter `normalize`


        Returns
        -------
        Vector
            peer sockets: segment_id_ (Float), segment_width_ (Float), segment_rotation_ (Float)

        """
        node = Node('Radial Tiling', {'Vector': vector, 'Sides': sides, 'Roundness': roundness}, normalize=normalize)
        return node._out

    @classmethod
    def separate_xyz(cls, vector: Vector = None):
        """ > Node Separate XYZ

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)


        Returns
        -------
        Float
            peer sockets: y_ (Float), z_ (Float)

        """
        node = Node('Separate XYZ', {'Vector': vector})
        return node

    @classmethod
    def brick_texture(cls,
                    vector: Vector = None,
                    color1: Color = None,
                    color2: Color = None,
                    mortar: Color = None,
                    scale: Float = None,
                    mortar_size: Float = None,
                    mortar_smooth: Float = None,
                    bias: Float = None,
                    brick_width: Float = None,
                    row_height: Float = None,
                    offset = 0.5,
                    offset_frequency = 2,
                    squash = 1.0,
                    squash_frequency = 2):
        """ > Node Brick Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        color1 : Color, optional
            socket 'Color1' (id: Color1)

        color2 : Color, optional
            socket 'Color2' (id: Color2)

        mortar : Color, optional
            socket 'Mortar' (id: Mortar)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        mortar_size : Float, optional
            socket 'Mortar Size' (id: Mortar Size)

        mortar_smooth : Float, optional
            socket 'Mortar Smooth' (id: Mortar Smooth)

        bias : Float, optional
            socket 'Bias' (id: Bias)

        brick_width : Float, optional
            socket 'Brick Width' (id: Brick Width)

        row_height : Float, optional
            socket 'Row Height' (id: Row Height)

        offset : float
            parameter `offset`

        offset_frequency : int
            parameter `offset_frequency`

        squash : float
            parameter `squash`

        squash_frequency : int
            parameter `squash_frequency`


        Returns
        -------
        Color
            peer sockets: factor_ (Float)

        """
        node = Node('Brick Texture', {'Vector': vector, 'Color1': color1, 'Color2': color2, 'Mortar': mortar, 'Scale': scale, 'Mortar Size': mortar_size, 'Mortar Smooth': mortar_smooth, 'Bias': bias, 'Brick Width': brick_width, 'Row Height': row_height}, offset=offset, offset_frequency=offset_frequency, squash=squash, squash_frequency=squash_frequency)
        return node._out

    @classmethod
    def checker_texture(cls,
                    vector: Vector = None,
                    color1: Color = None,
                    color2: Color = None,
                    scale: Float = None):
        """ > Node Checker Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        color1 : Color, optional
            socket 'Color1' (id: Color1)

        color2 : Color, optional
            socket 'Color2' (id: Color2)

        scale : Float, optional
            socket 'Scale' (id: Scale)


        Returns
        -------
        Color
            peer sockets: factor_ (Float)

        """
        node = Node('Checker Texture', {'Vector': vector, 'Color1': color1, 'Color2': color2, 'Scale': scale})
        return node._out

    @classmethod
    def gabor_texture(cls,
                    vector: Vector = None,
                    scale: Float = None,
                    frequency: Float = None,
                    anisotropy: Float = None,
                    orientation: Float = None,
                    orientation_1: Vector = None,
                    gabor_type: Literal['2D', '3D'] = '2D'):
        """ > Node Gabor Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        frequency : Float, optional
            socket 'Frequency' (id: Frequency)

        anisotropy : Float, optional
            socket 'Anisotropy' (id: Anisotropy)

        orientation : Float, optional
            socket 'Orientation' (id: Orientation 2D)

        orientation_1 : Vector, optional
            socket 'Orientation' (id: Orientation 3D)

        gabor_type : Literal['2D', '3D']
            parameter `gabor_type`


        Returns
        -------
        Float
            peer sockets: phase_ (Float), intensity_ (Float)

        """
        utils.check_enum_arg('Gabor Texture', 'gabor_type', gabor_type, 'gabor_texture', ('2D', '3D'))
        node = Node('Gabor Texture', {'Vector': vector, 'Scale': scale, 'Frequency': frequency, 'Anisotropy': anisotropy, 'Orientation 2D': orientation, 'Orientation 3D': orientation_1}, gabor_type=gabor_type)
        return node._out

    @classmethod
    def gradient_texture(cls,
                    vector: Vector = None,
                    gradient_type: Literal['LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'] = 'LINEAR'):
        """ > Node Gradient Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        gradient_type : Literal['Linear', 'Quadratic', 'Easing', 'Diagonal', 'Spherical', 'Quadratic Sphere', 'Radial']
            parameter `gradient_type`


        Returns
        -------
        Color
            peer sockets: factor_ (Float)

        """
        utils.check_enum_arg('Gradient Texture', 'gradient_type', gradient_type, 'gradient_texture', ('LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'))
        node = Node('Gradient Texture', {'Vector': vector}, gradient_type=gradient_type)
        return node._out

    @classmethod
    def magic_texture(cls,
                    vector: Vector = None,
                    scale: Float = None,
                    distortion: Float = None,
                    turbulence_depth = 2):
        """ > Node Magic Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        distortion : Float, optional
            socket 'Distortion' (id: Distortion)

        turbulence_depth : int
            parameter `turbulence_depth`


        Returns
        -------
        Color
            peer sockets: factor_ (Float)

        """
        node = Node('Magic Texture', {'Vector': vector, 'Scale': scale, 'Distortion': distortion}, turbulence_depth=turbulence_depth)
        return node._out

    @classmethod
    def noise_texture(cls,
                    vector: Vector = None,
                    w: Float = None,
                    scale: Float = None,
                    detail: Float = None,
                    roughness: Float = None,
                    lacunarity: Float = None,
                    offset: Float = None,
                    gain: Float = None,
                    distortion: Float = None,
                    noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D',
                    noise_type: Literal['MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'] = 'FBM',
                    normalize = True):
        """ > Node Noise Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        w : Float, optional
            socket 'W' (id: W)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        detail : Float, optional
            socket 'Detail' (id: Detail)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        lacunarity : Float, optional
            socket 'Lacunarity' (id: Lacunarity)

        offset : Float, optional
            socket 'Offset' (id: Offset)

        gain : Float, optional
            socket 'Gain' (id: Gain)

        distortion : Float, optional
            socket 'Distortion' (id: Distortion)

        noise_dimensions : Literal['1D', '2D', '3D', '4D']
            parameter `noise_dimensions`

        noise_type : Literal['Multifractal', 'Ridged Multifractal', 'Hybrid Multifractal', 'fBM', 'Hetero Terrain']
            parameter `noise_type`

        normalize : bool
            parameter `normalize`


        Returns
        -------
        Float
            peer sockets: color_ (Color)

        """
        utils.check_enum_arg('Noise Texture', 'noise_dimensions', noise_dimensions, 'noise_texture', ('1D', '2D', '3D', '4D'))
        utils.check_enum_arg('Noise Texture', 'noise_type', noise_type, 'noise_texture', ('MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'))
        node = Node('Noise Texture', {'Vector': vector, 'W': w, 'Scale': scale, 'Detail': detail, 'Roughness': roughness, 'Lacunarity': lacunarity, 'Offset': offset, 'Gain': gain, 'Distortion': distortion}, noise_dimensions=noise_dimensions, noise_type=noise_type, normalize=normalize)
        return node._out

    @classmethod
    def voronoi_texture(cls,
                    vector: Vector = None,
                    w: Float = None,
                    scale: Float = None,
                    detail: Float = None,
                    roughness: Float = None,
                    lacunarity: Float = None,
                    smoothness: Float = None,
                    exponent: Float = None,
                    randomness: Float = None,
                    distance: Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'] = 'EUCLIDEAN',
                    feature: Literal['F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'] = 'F1',
                    normalize = False,
                    voronoi_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D'):
        """ > Node Voronoi Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        w : Float, optional
            socket 'W' (id: W)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        detail : Float, optional
            socket 'Detail' (id: Detail)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        lacunarity : Float, optional
            socket 'Lacunarity' (id: Lacunarity)

        smoothness : Float, optional
            socket 'Smoothness' (id: Smoothness)

        exponent : Float, optional
            socket 'Exponent' (id: Exponent)

        randomness : Float, optional
            socket 'Randomness' (id: Randomness)

        distance : Literal['Euclidean', 'Manhattan', 'Chebychev', 'Minkowski']
            parameter `distance`

        feature : Literal['F1', 'F2', 'Smooth F1', 'Distance to Edge', 'N-Sphere Radius']
            parameter `feature`

        normalize : bool
            parameter `normalize`

        voronoi_dimensions : Literal['1D', '2D', '3D', '4D']
            parameter `voronoi_dimensions`


        Returns
        -------
        Float
            peer sockets: color_ (Color), position_ (Vector)

        """
        utils.check_enum_arg('Voronoi Texture', 'distance', distance, 'voronoi_texture', ('EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'))
        utils.check_enum_arg('Voronoi Texture', 'feature', feature, 'voronoi_texture', ('F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'))
        utils.check_enum_arg('Voronoi Texture', 'voronoi_dimensions', voronoi_dimensions, 'voronoi_texture', ('1D', '2D', '3D', '4D'))
        node = Node('Voronoi Texture', {'Vector': vector, 'W': w, 'Scale': scale, 'Detail': detail, 'Roughness': roughness, 'Lacunarity': lacunarity, 'Smoothness': smoothness, 'Exponent': exponent, 'Randomness': randomness}, distance=distance, feature=feature, normalize=normalize, voronoi_dimensions=voronoi_dimensions)
        return node._out

    @classmethod
    def wave_texture(cls,
                    vector: Vector = None,
                    scale: Float = None,
                    distortion: Float = None,
                    detail: Float = None,
                    detail_scale: Float = None,
                    detail_roughness: Float = None,
                    phase_offset: Float = None,
                    bands_direction: Literal['X', 'Y', 'Z', 'DIAGONAL'] = 'X',
                    rings_direction: Literal['X', 'Y', 'Z', 'SPHERICAL'] = 'X',
                    wave_profile: Literal['SIN', 'SAW', 'TRI'] = 'SIN',
                    wave_type: Literal['BANDS', 'RINGS'] = 'BANDS'):
        """ > Node Wave Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        distortion : Float, optional
            socket 'Distortion' (id: Distortion)

        detail : Float, optional
            socket 'Detail' (id: Detail)

        detail_scale : Float, optional
            socket 'Detail Scale' (id: Detail Scale)

        detail_roughness : Float, optional
            socket 'Detail Roughness' (id: Detail Roughness)

        phase_offset : Float, optional
            socket 'Phase Offset' (id: Phase Offset)

        bands_direction : Literal['X', 'Y', 'Z', 'Diagonal']
            parameter `bands_direction`

        rings_direction : Literal['X', 'Y', 'Z', 'Spherical']
            parameter `rings_direction`

        wave_profile : Literal['Sine', 'Saw', 'Triangle']
            parameter `wave_profile`

        wave_type : Literal['Bands', 'Rings']
            parameter `wave_type`


        Returns
        -------
        Color
            peer sockets: factor_ (Float)

        """
        utils.check_enum_arg('Wave Texture', 'bands_direction', bands_direction, 'wave_texture', ('X', 'Y', 'Z', 'DIAGONAL'))
        utils.check_enum_arg('Wave Texture', 'rings_direction', rings_direction, 'wave_texture', ('X', 'Y', 'Z', 'SPHERICAL'))
        utils.check_enum_arg('Wave Texture', 'wave_profile', wave_profile, 'wave_texture', ('SIN', 'SAW', 'TRI'))
        utils.check_enum_arg('Wave Texture', 'wave_type', wave_type, 'wave_texture', ('BANDS', 'RINGS'))
        node = Node('Wave Texture', {'Vector': vector, 'Scale': scale, 'Distortion': distortion, 'Detail': detail, 'Detail Scale': detail_scale, 'Detail Roughness': detail_roughness, 'Phase Offset': phase_offset}, bands_direction=bands_direction, rings_direction=rings_direction, wave_profile=wave_profile, wave_type=wave_type)
        return node._out

    @classmethod
    def white_noise_texture(cls,
                    vector: Vector = None,
                    w: Float = None,
                    noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D'):
        """ > Node White Noise Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        w : Float, optional
            socket 'W' (id: W)

        noise_dimensions : Literal['1D', '2D', '3D', '4D']
            parameter `noise_dimensions`


        Returns
        -------
        Float
            peer sockets: color_ (Color)

        """
        utils.check_enum_arg('White Noise Texture', 'noise_dimensions', noise_dimensions, 'white_noise_texture', ('1D', '2D', '3D', '4D'))
        node = Node('White Noise Texture', {'Vector': vector, 'W': w}, noise_dimensions=noise_dimensions)
        return node._out

    @classmethod
    def color_ramp(cls, fac=None, stops=None, interpolation='LINEAR'):
        """ Node Color Ramp

        Exposes utilities to manage the color ramp

        ``` python
        ramp1 = Float(.5).color_ramp(stops=[.1, .9])
        ramp2 = ColorRamp(.5, stops=[(.1, (1, 0, 0)), (.5, 1), (.9, (0, 0, 1))])
        ```

        Parameters
        ----------
        fac : Float, optional

        stops : list[tuple[float, tuple]]
            Stops made of (float, color as tuple of floats)

        interpolation : {'EASE', 'CARDINAL', 'LINEAR', 'B_SPLINE', 'CONSTANT'}

        """
        node = ColorRamp(fac=fac, stops=stops, interpolation=interpolation)
        return node._out

    @utils.classproperty
    def value(self):
        """ > Node Value

        Returns
        -------
        Float
        """
        node = Node('Value', )
        return node._out

    @classmethod
    def vector_curves(cls, vector: Vector = None, factor: Float = None):
        """ > Node Vector Curves

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        factor : Float, optional
            socket 'Factor' (id: Fac)


        Returns
        -------
        Vector
        """
        node = NodeCurves('Vector Curves', {'Vector': vector, 'Fac': factor})
        return node._out

    @classmethod
    def vector_math(cls,
                    vector: Vector = None,
                    vector_1: Vector = None,
                    vector_2: Vector = None,
                    scale: Float = None,
                    operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'CROSS_PRODUCT', 'PROJECT', 'REFLECT', 'REFRACT', 'FACEFORWARD', 'DOT_PRODUCT', 'DISTANCE', 'LENGTH', 'SCALE', 'NORMALIZE', 'ABSOLUTE', 'POWER', 'SIGN', 'MINIMUM', 'MAXIMUM', 'ROUND', 'FLOOR', 'CEIL', 'FRACTION', 'MODULO', 'WRAP', 'SNAP', 'SINE', 'COSINE', 'TANGENT'] = 'ADD'):
        """ > Node Vector Math

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        vector_1 : Vector, optional
            socket 'Vector' (id: Vector_001)

        vector_2 : Vector, optional
            socket 'Vector' (id: Vector_002)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        operation : Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Cross Product', 'Project', 'Reflect', 'Refract', 'Faceforward', 'Dot Product', 'Distance', 'Length', 'Scale', 'Normalize', 'Absolute', 'Power', 'Sign', 'Minimum', 'Maximum', 'Round', 'Floor', 'Ceil', 'Fraction', 'Modulo', 'Wrap', 'Snap', 'Sine', 'Cosine', 'Tangent']
            parameter `operation`


        Returns
        -------
        Vector
        """
        utils.check_enum_arg('Vector Math', 'operation', operation, 'vector_math', ('ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'CROSS_PRODUCT', 'PROJECT', 'REFLECT', 'REFRACT', 'FACEFORWARD', 'DOT_PRODUCT', 'DISTANCE', 'LENGTH', 'SCALE', 'NORMALIZE', 'ABSOLUTE', 'POWER', 'SIGN', 'MINIMUM', 'MAXIMUM', 'ROUND', 'FLOOR', 'CEIL', 'FRACTION', 'MODULO', 'WRAP', 'SNAP', 'SINE', 'COSINE', 'TANGENT'))
        node = Node('Vector Math', {'Vector': vector, 'Vector_001': vector_1, 'Vector_002': vector_2, 'Scale': scale}, operation=operation)
        return node._out

    @classmethod
    def vector_rotate(cls,
                    vector: Vector = None,
                    center: Vector = None,
                    axis: Vector = None,
                    angle: Float = None,
                    rotation: Vector = None,
                    invert = False,
                    rotation_type: Literal['AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'] = 'AXIS_ANGLE'):
        """ > Node Vector Rotate

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        center : Vector, optional
            socket 'Center' (id: Center)

        axis : Vector, optional
            socket 'Axis' (id: Axis)

        angle : Float, optional
            socket 'Angle' (id: Angle)

        rotation : Vector, optional
            socket 'Rotation' (id: Rotation)

        invert : bool
            parameter `invert`

        rotation_type : Literal['Axis Angle', 'X Axis', 'Y Axis', 'Z Axis', 'Euler']
            parameter `rotation_type`


        Returns
        -------
        Vector
        """
        utils.check_enum_arg('Vector Rotate', 'rotation_type', rotation_type, 'vector_rotate', ('AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'))
        node = Node('Vector Rotate', {'Vector': vector, 'Center': center, 'Axis': axis, 'Angle': angle, 'Rotation': rotation}, invert=invert, rotation_type=rotation_type)
        return node._out

_3d_cursor() classmethod

Node 3D Cursor

Returns:

Type	Description
Vector	peer sockets: rotation_ (Rotation)

Source code in core/generated/static_nd.py

@classmethod
def _3d_cursor(cls):
    """ > Node 3D Cursor

    Returns
    -------
    Vector
        peer sockets: rotation_ (Rotation)

    """
    node = Node('3D Cursor', )
    return node

accumulate_field(value=None, group_id=None, data_type='FLOAT', domain='POINT') classmethod

Node Accumulate Field

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
group_id	Integer	socket 'Group ID' (id: Group Index)	None
data_type	Literal['Float', 'Integer', 'Vector', 'Transform']	parameter data_type	'FLOAT'
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Float	peer sockets: trailing_ (Float), total_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def accumulate_field(cls,
                value: Float = None,
                group_id: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'FLOAT_VECTOR', 'TRANSFORM'] = 'FLOAT',
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
    """ > Node Accumulate Field

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    group_id : Integer, optional
        socket 'Group ID' (id: Group Index)

    data_type : Literal['Float', 'Integer', 'Vector', 'Transform']
        parameter `data_type`

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Float
        peer sockets: trailing_ (Float), total_ (Float)

    """
    utils.check_enum_arg('Accumulate Field', 'domain', domain, 'accumulate_field', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Accumulate Field', {'Value': value, 'Group Index': group_id}, data_type=data_type, domain=domain)
    return node._out

active_camera()

Node Active Camera

Returns:

Type	Description
Object

Source code in core/generated/static_nd.py

@utils.classproperty
def active_camera(self):
    """ > Node Active Camera

    Returns
    -------
    Object
    """
    node = Node('Active Camera', )
    return node._out

active_element(domain='POINT') classmethod

Node Active Element

Parameters:

Name	Type	Description	Default
domain	Literal['Point', 'Edge', 'Face', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Integer	peer sockets: exists_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def active_element(cls, domain: Literal['POINT', 'EDGE', 'FACE', 'LAYER'] = 'POINT'):
    """ > Node Active Element

    Parameters
    ----------
    domain : Literal['Point', 'Edge', 'Face', 'Layer']
        parameter `domain`


    Returns
    -------
    Integer
        peer sockets: exists_ (Boolean)

    """
    utils.check_enum_arg('Active Element', 'domain', domain, 'active_element', ('POINT', 'EDGE', 'FACE', 'LAYER'))
    node = Node('Active Element', domain=domain)
    return node

advect_grid(grid=None, velocity=None, time_step=None, integration_scheme=None, limiter=None, data_type='FLOAT') classmethod

Node Advect Grid

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
velocity	Vector	socket 'Velocity' (id: Velocity)	None
time_step	Float	socket 'Time Step' (id: Time Step)	None
integration_scheme	menu='Runge-Kutta 3'	('Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC')	None
limiter	menu='Clamp'	('None', 'Clamp', 'Revert')	None
data_type	Literal['Float', 'Integer', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def advect_grid(cls,
                grid: Float = None,
                velocity: Vector = None,
                time_step: Float = None,
                integration_scheme: Literal['Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC'] = None,
                limiter: Literal['None', 'Clamp', 'Revert'] = None,
                data_type: Literal['FLOAT', 'INT', 'VECTOR'] = 'FLOAT'):
    """ > Node Advect Grid

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    velocity : Vector, optional
        socket 'Velocity' (id: Velocity)

    time_step : Float, optional
        socket 'Time Step' (id: Time Step)

    integration_scheme : menu='Runge-Kutta 3', optional
        ('Semi-Lagrangian', 'Midpoint', 'Runge-Kutta 3', 'Runge-Kutta 4', 'MacCormack', 'BFECC')

    limiter : menu='Clamp', optional
        ('None', 'Clamp', 'Revert')

    data_type : Literal['Float', 'Integer', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Advect Grid', {'Grid': grid, 'Velocity': velocity, 'Time Step': time_step, 'Integration Scheme': integration_scheme, 'Limiter': limiter}, data_type=data_type)
    return node._out

align_rotation_to_vector(rotation=None, vector=None, factor=None, axis='Z', pivot_axis='AUTO') classmethod

Node Align Rotation to Vector

Parameters:

Name	Type	Description	Default
rotation	Rotation	socket 'Rotation' (id: Rotation)	None
vector	Vector	socket 'Vector' (id: Vector)	None
factor	Float	socket 'Factor' (id: Factor)	None
axis	Literal['X', 'Y', 'Z']	parameter axis	'Z'
pivot_axis	Literal['Auto', 'X', 'Y', 'Z']	parameter pivot_axis	'AUTO'

Returns:

Type	Description
Rotation

Source code in core/generated/static_nd.py

@classmethod
def align_rotation_to_vector(cls,
                rotation: Rotation = None,
                vector: Vector = None,
                factor: Float = None,
                axis: Literal['X', 'Y', 'Z'] = 'Z',
                pivot_axis: Literal['AUTO', 'X', 'Y', 'Z'] = 'AUTO'):
    """ > Node Align Rotation to Vector

    Parameters
    ----------
    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)

    vector : Vector, optional
        socket 'Vector' (id: Vector)

    factor : Float, optional
        socket 'Factor' (id: Factor)

    axis : Literal['X', 'Y', 'Z']
        parameter `axis`

    pivot_axis : Literal['Auto', 'X', 'Y', 'Z']
        parameter `pivot_axis`


    Returns
    -------
    Rotation
    """
    utils.check_enum_arg('Align Rotation to Vector', 'axis', axis, 'align_rotation_to_vector', ('X', 'Y', 'Z'))
    utils.check_enum_arg('Align Rotation to Vector', 'pivot_axis', pivot_axis, 'align_rotation_to_vector', ('AUTO', 'X', 'Y', 'Z'))
    node = Node('Align Rotation to Vector', {'Rotation': rotation, 'Vector': vector, 'Factor': factor}, axis=axis, pivot_axis=pivot_axis)
    return node._out

arc(resolution=None, start=None, middle=None, end=None, radius=None, start_angle=None, sweep_angle=None, offset_angle=None, connect_center=None, invert_arc=None, mode='RADIUS') classmethod

Node Arc

Parameters:

Name	Type	Description	Default
resolution	Integer	socket 'Resolution' (id: Resolution)	None
start	Vector	socket 'Start' (id: Start)	None
middle	Vector	socket 'Middle' (id: Middle)	None
end	Vector	socket 'End' (id: End)	None
radius	Float	socket 'Radius' (id: Radius)	None
start_angle	Float	socket 'Start Angle' (id: Start Angle)	None
sweep_angle	Float	socket 'Sweep Angle' (id: Sweep Angle)	None
offset_angle	Float	socket 'Offset Angle' (id: Offset Angle)	None
connect_center	Boolean	socket 'Connect Center' (id: Connect Center)	None
invert_arc	Boolean	socket 'Invert Arc' (id: Invert Arc)	None
mode	Literal['Points', 'Radius']	parameter mode	'RADIUS'

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def arc(cls,
                resolution: Integer = None,
                start: Vector = None,
                middle: Vector = None,
                end: Vector = None,
                radius: Float = None,
                start_angle: Float = None,
                sweep_angle: Float = None,
                offset_angle: Float = None,
                connect_center: Boolean = None,
                invert_arc: Boolean = None,
                mode: Literal['POINTS', 'RADIUS'] = 'RADIUS'):
    """ > Node Arc

    Parameters
    ----------
    resolution : Integer, optional
        socket 'Resolution' (id: Resolution)

    start : Vector, optional
        socket 'Start' (id: Start)

    middle : Vector, optional
        socket 'Middle' (id: Middle)

    end : Vector, optional
        socket 'End' (id: End)

    radius : Float, optional
        socket 'Radius' (id: Radius)

    start_angle : Float, optional
        socket 'Start Angle' (id: Start Angle)

    sweep_angle : Float, optional
        socket 'Sweep Angle' (id: Sweep Angle)

    offset_angle : Float, optional
        socket 'Offset Angle' (id: Offset Angle)

    connect_center : Boolean, optional
        socket 'Connect Center' (id: Connect Center)

    invert_arc : Boolean, optional
        socket 'Invert Arc' (id: Invert Arc)

    mode : Literal['Points', 'Radius']
        parameter `mode`


    Returns
    -------
    Curve
    """
    utils.check_enum_arg('Arc', 'mode', mode, 'arc', ('POINTS', 'RADIUS'))
    node = Node('Arc', {'Resolution': resolution, 'Start': start, 'Middle': middle, 'End': end, 'Radius': radius, 'Start Angle': start_angle, 'Sweep Angle': sweep_angle, 'Offset Angle': offset_angle, 'Connect Center': connect_center, 'Invert Arc': invert_arc}, mode=mode)
    return node._out

attribute_statistic(geometry=None, selection=None, attribute=None, data_type='FLOAT', domain='POINT') classmethod

Node Attribute Statistic

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
attribute	Float	socket 'Attribute' (id: Attribute)	None
data_type	Literal['Float', 'Vector']	parameter data_type	'FLOAT'
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Float	peer sockets: median_ (Float), sum_ (Float), min_ (Float), max_ (Float), range_ (Float), standard_deviation_ (Float), variance_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def attribute_statistic(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                attribute: Float = None,
                data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
    """ > Node Attribute Statistic

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    attribute : Float, optional
        socket 'Attribute' (id: Attribute)

    data_type : Literal['Float', 'Vector']
        parameter `data_type`

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Float
        peer sockets: median_ (Float), sum_ (Float), min_ (Float), max_ (Float), range_ (Float), standard_deviation_ (Float), variance_ (Float)

    """
    utils.check_enum_arg('Attribute Statistic', 'domain', domain, 'attribute_statistic', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Attribute Statistic', {'Geometry': geometry, 'Selection': selection, 'Attribute': attribute}, data_type=data_type, domain=domain)
    return node._out

axes_to_rotation(primary_axis_1=None, secondary_axis_1=None, primary_axis='Z', secondary_axis='X') classmethod

Node Axes to Rotation

Parameters:

Name	Type	Description	Default
primary_axis_1	Vector	socket 'Primary Axis' (id: Primary Axis)	None
secondary_axis_1	Vector	socket 'Secondary Axis' (id: Secondary Axis)	None
primary_axis	Literal['X', 'Y', 'Z']	parameter primary_axis	'Z'
secondary_axis	Literal['X', 'Y', 'Z']	parameter secondary_axis	'X'

Returns:

Type	Description
Rotation

Source code in core/generated/static_nd.py

@classmethod
def axes_to_rotation(cls,
                primary_axis_1: Vector = None,
                secondary_axis_1: Vector = None,
                primary_axis: Literal['X', 'Y', 'Z'] = 'Z',
                secondary_axis: Literal['X', 'Y', 'Z'] = 'X'):
    """ > Node Axes to Rotation

    Parameters
    ----------
    primary_axis_1 : Vector, optional
        socket 'Primary Axis' (id: Primary Axis)

    secondary_axis_1 : Vector, optional
        socket 'Secondary Axis' (id: Secondary Axis)

    primary_axis : Literal['X', 'Y', 'Z']
        parameter `primary_axis`

    secondary_axis : Literal['X', 'Y', 'Z']
        parameter `secondary_axis`


    Returns
    -------
    Rotation
    """
    utils.check_enum_arg('Axes to Rotation', 'primary_axis', primary_axis, 'axes_to_rotation', ('X', 'Y', 'Z'))
    utils.check_enum_arg('Axes to Rotation', 'secondary_axis', secondary_axis, 'axes_to_rotation', ('X', 'Y', 'Z'))
    node = Node('Axes to Rotation', {'Primary Axis': primary_axis_1, 'Secondary Axis': secondary_axis_1}, primary_axis=primary_axis, secondary_axis=secondary_axis)
    return node._out

axis_angle_to_rotation(axis=None, angle=None) classmethod

Node Axis Angle to Rotation

Parameters:

Name	Type	Description	Default
axis	Vector	socket 'Axis' (id: Axis)	None
angle	Float	socket 'Angle' (id: Angle)	None

Returns:

Type	Description
Rotation

Source code in core/generated/static_nd.py

@classmethod
def axis_angle_to_rotation(cls, axis: Vector = None, angle: Float = None):
    """ > Node Axis Angle to Rotation

    Parameters
    ----------
    axis : Vector, optional
        socket 'Axis' (id: Axis)

    angle : Float, optional
        socket 'Angle' (id: Angle)


    Returns
    -------
    Rotation
    """
    node = Node('Axis Angle to Rotation', {'Axis': axis, 'Angle': angle})
    return node._out

bake(named_sockets={}, **sockets) classmethod

Node Bake

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@classmethod
def bake(cls, named_sockets: dict = {}, **sockets):
    """ > Node Bake

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    None
    """
    node = Node('Bake', named_sockets, **sockets)
    return node._out

bezier_segment(resolution=None, start=None, start_handle=None, end_handle=None, end=None, mode='POSITION') classmethod

Node Bézier Segment

Parameters:

Name	Type	Description	Default
resolution	Integer	socket 'Resolution' (id: Resolution)	None
start	Vector	socket 'Start' (id: Start)	None
start_handle	Vector	socket 'Start Handle' (id: Start Handle)	None
end_handle	Vector	socket 'End Handle' (id: End Handle)	None
end	Vector	socket 'End' (id: End)	None
mode	Literal['Position', 'Offset']	parameter mode	'POSITION'

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def bezier_segment(cls,
                resolution: Integer = None,
                start: Vector = None,
                start_handle: Vector = None,
                end_handle: Vector = None,
                end: Vector = None,
                mode: Literal['POSITION', 'OFFSET'] = 'POSITION'):
    """ > Node Bézier Segment

    Parameters
    ----------
    resolution : Integer, optional
        socket 'Resolution' (id: Resolution)

    start : Vector, optional
        socket 'Start' (id: Start)

    start_handle : Vector, optional
        socket 'Start Handle' (id: Start Handle)

    end_handle : Vector, optional
        socket 'End Handle' (id: End Handle)

    end : Vector, optional
        socket 'End' (id: End)

    mode : Literal['Position', 'Offset']
        parameter `mode`


    Returns
    -------
    Curve
    """
    utils.check_enum_arg('Bézier Segment', 'mode', mode, 'bezier_segment', ('POSITION', 'OFFSET'))
    node = Node('Bézier Segment', {'Resolution': resolution, 'Start': start, 'Start Handle': start_handle, 'End Handle': end_handle, 'End': end}, mode=mode)
    return node._out

bit_math(a=None, b=None, shift=None, operation='AND') classmethod

Node Bit Math

Parameters:

Name	Type	Description	Default
a	Integer	socket 'A' (id: A)	None
b	Integer	socket 'B' (id: B)	None
shift	Integer	socket 'Shift' (id: Shift)	None
operation	Literal['And', 'Or', 'Exclusive Or', 'Not', 'Shift', 'Rotate']	parameter operation	'AND'

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def bit_math(cls,
                a: Integer = None,
                b: Integer = None,
                shift: Integer = None,
                operation: Literal['AND', 'OR', 'XOR', 'NOT', 'SHIFT', 'ROTATE'] = 'AND'):
    """ > Node Bit Math

    Parameters
    ----------
    a : Integer, optional
        socket 'A' (id: A)

    b : Integer, optional
        socket 'B' (id: B)

    shift : Integer, optional
        socket 'Shift' (id: Shift)

    operation : Literal['And', 'Or', 'Exclusive Or', 'Not', 'Shift', 'Rotate']
        parameter `operation`


    Returns
    -------
    Integer
    """
    utils.check_enum_arg('Bit Math', 'operation', operation, 'bit_math', ('AND', 'OR', 'XOR', 'NOT', 'SHIFT', 'ROTATE'))
    node = Node('Bit Math', {'A': a, 'B': b, 'Shift': shift}, operation=operation)
    return node._out

blackbody(temperature=None) classmethod

Node Blackbody

Parameters:

Name	Type	Description	Default
temperature	Float	socket 'Temperature' (id: Temperature)	None

Returns:

Type	Description
Color

Source code in core/generated/static_nd.py

@classmethod
def blackbody(cls, temperature: Float = None):
    """ > Node Blackbody

    Parameters
    ----------
    temperature : Float, optional
        socket 'Temperature' (id: Temperature)


    Returns
    -------
    Color
    """
    node = Node('Blackbody', {'Temperature': temperature})
    return node._out

blur_attribute(value=None, iterations=None, weight=None, data_type='FLOAT') classmethod

Node Blur Attribute

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None
weight	Float	socket 'Weight' (id: Weight)	None
data_type	Literal['Float', 'Integer', 'Vector', 'Color']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def blur_attribute(cls,
                value: Float = None,
                iterations: Integer = None,
                weight: Float = None,
                data_type: Literal['FLOAT', 'INT', 'FLOAT_VECTOR', 'FLOAT_COLOR'] = 'FLOAT'):
    """ > Node Blur Attribute

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    data_type : Literal['Float', 'Integer', 'Vector', 'Color']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Blur Attribute', {'Value': value, 'Iterations': iterations, 'Weight': weight}, data_type=data_type)
    return node._out

bone_info(armature=None, bone_name=None, transform_space='ORIGINAL') classmethod

Node Bone Info

Parameters:

Name	Type	Description	Default
armature	Object	socket 'Armature' (id: Armature)	None
bone_name	String	socket 'Bone Name' (id: Bone Name)	None
transform_space	Literal['Original', 'Relative']	parameter transform_space	'ORIGINAL'

Returns:

Type	Description
Matrix	peer sockets: local_pose_ (Matrix), transform_pose_ (Matrix), rest_pose_ (Matrix), rest_length_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def bone_info(cls,
                armature: Object = None,
                bone_name: String = None,
                transform_space: Literal['ORIGINAL', 'RELATIVE'] = 'ORIGINAL'):
    """ > Node Bone Info

    Parameters
    ----------
    armature : Object, optional
        socket 'Armature' (id: Armature)

    bone_name : String, optional
        socket 'Bone Name' (id: Bone Name)

    transform_space : Literal['Original', 'Relative']
        parameter `transform_space`


    Returns
    -------
    Matrix
        peer sockets: local_pose_ (Matrix), transform_pose_ (Matrix), rest_pose_ (Matrix), rest_length_ (Float)

    """
    utils.check_enum_arg('Bone Info', 'transform_space', transform_space, 'bone_info', ('ORIGINAL', 'RELATIVE'))
    node = Node('Bone Info', {'Armature': armature, 'Bone Name': bone_name}, transform_space=transform_space)
    return node._out

boolean(boolean=False) classmethod

Node Boolean

Parameters:

Name	Type	Description	Default
boolean	bool	parameter boolean	False

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def boolean(cls, boolean = False):
    """ > Node Boolean

    Parameters
    ----------
    boolean : bool
        parameter `boolean`


    Returns
    -------
    Boolean
    """
    node = Node('Boolean', boolean=boolean)
    return node._out

boolean_math(boolean=None, boolean_1=None, operation='AND') classmethod

Node Boolean Math

Parameters:

Name	Type	Description	Default
boolean	Boolean	socket 'Boolean' (id: Boolean)	None
boolean_1	Boolean	socket 'Boolean' (id: Boolean_001)	None
operation	Literal['And', 'Or', 'Not', 'Not And', 'Nor', 'Equal', 'Not Equal', 'Imply', 'Subtract']	parameter operation	'AND'

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def boolean_math(cls,
                boolean: Boolean = None,
                boolean_1: Boolean = None,
                operation: Literal['AND', 'OR', 'NOT', 'NAND', 'NOR', 'XNOR', 'XOR', 'IMPLY', 'NIMPLY'] = 'AND'):
    """ > Node Boolean Math

    Parameters
    ----------
    boolean : Boolean, optional
        socket 'Boolean' (id: Boolean)

    boolean_1 : Boolean, optional
        socket 'Boolean' (id: Boolean_001)

    operation : Literal['And', 'Or', 'Not', 'Not And', 'Nor', 'Equal', 'Not Equal', 'Imply', 'Subtract']
        parameter `operation`


    Returns
    -------
    Boolean
    """
    utils.check_enum_arg('Boolean Math', 'operation', operation, 'boolean_math', ('AND', 'OR', 'NOT', 'NAND', 'NOR', 'XNOR', 'XOR', 'IMPLY', 'NIMPLY'))
    node = Node('Boolean Math', {'Boolean': boolean, 'Boolean_001': boolean_1}, operation=operation)
    return node._out

bounding_box(geometry=None, use_radius=None) classmethod

Node Bounding Box

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
use_radius	Boolean	socket 'Use Radius' (id: Use Radius)	None

Returns:

Type	Description
Mesh	peer sockets: min_ (Vector), max_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def bounding_box(cls, geometry: Geometry = None, use_radius: Boolean = None):
    """ > Node Bounding Box

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    use_radius : Boolean, optional
        socket 'Use Radius' (id: Use Radius)


    Returns
    -------
    Mesh
        peer sockets: min_ (Vector), max_ (Vector)

    """
    node = Node('Bounding Box', {'Geometry': geometry, 'Use Radius': use_radius})
    return node._out

brick_texture(vector=None, color1=None, color2=None, mortar=None, scale=None, mortar_size=None, mortar_smooth=None, bias=None, brick_width=None, row_height=None, offset=0.5, offset_frequency=2, squash=1.0, squash_frequency=2) classmethod

Node Brick Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
color1	Color	socket 'Color1' (id: Color1)	None
color2	Color	socket 'Color2' (id: Color2)	None
mortar	Color	socket 'Mortar' (id: Mortar)	None
scale	Float	socket 'Scale' (id: Scale)	None
mortar_size	Float	socket 'Mortar Size' (id: Mortar Size)	None
mortar_smooth	Float	socket 'Mortar Smooth' (id: Mortar Smooth)	None
bias	Float	socket 'Bias' (id: Bias)	None
brick_width	Float	socket 'Brick Width' (id: Brick Width)	None
row_height	Float	socket 'Row Height' (id: Row Height)	None
offset	float	parameter offset	0.5
offset_frequency	int	parameter offset_frequency	2
squash	float	parameter squash	1.0
squash_frequency	int	parameter squash_frequency	2

Returns:

Type	Description
Color	peer sockets: factor_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def brick_texture(cls,
                vector: Vector = None,
                color1: Color = None,
                color2: Color = None,
                mortar: Color = None,
                scale: Float = None,
                mortar_size: Float = None,
                mortar_smooth: Float = None,
                bias: Float = None,
                brick_width: Float = None,
                row_height: Float = None,
                offset = 0.5,
                offset_frequency = 2,
                squash = 1.0,
                squash_frequency = 2):
    """ > Node Brick Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    color1 : Color, optional
        socket 'Color1' (id: Color1)

    color2 : Color, optional
        socket 'Color2' (id: Color2)

    mortar : Color, optional
        socket 'Mortar' (id: Mortar)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    mortar_size : Float, optional
        socket 'Mortar Size' (id: Mortar Size)

    mortar_smooth : Float, optional
        socket 'Mortar Smooth' (id: Mortar Smooth)

    bias : Float, optional
        socket 'Bias' (id: Bias)

    brick_width : Float, optional
        socket 'Brick Width' (id: Brick Width)

    row_height : Float, optional
        socket 'Row Height' (id: Row Height)

    offset : float
        parameter `offset`

    offset_frequency : int
        parameter `offset_frequency`

    squash : float
        parameter `squash`

    squash_frequency : int
        parameter `squash_frequency`


    Returns
    -------
    Color
        peer sockets: factor_ (Float)

    """
    node = Node('Brick Texture', {'Vector': vector, 'Color1': color1, 'Color2': color2, 'Mortar': mortar, 'Scale': scale, 'Mortar Size': mortar_size, 'Mortar Smooth': mortar_smooth, 'Bias': bias, 'Brick Width': brick_width, 'Row Height': row_height}, offset=offset, offset_frequency=offset_frequency, squash=squash, squash_frequency=squash_frequency)
    return node._out

camera_info(camera=None) classmethod

Node Camera Info

Parameters:

Name	Type	Description	Default
camera	Object	socket 'Camera' (id: Camera)	None

Returns:

Type	Description
Matrix	peer sockets: focal_length_ (Float), sensor_ (Vector), shift_ (Vector), clip_start_ (Float), clip_end_ (Float), focus_distance_ (Float), is_orthographic_ (Boolean), orthographic_scale_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def camera_info(cls, camera: Object = None):
    """ > Node Camera Info

    Parameters
    ----------
    camera : Object, optional
        socket 'Camera' (id: Camera)


    Returns
    -------
    Matrix
        peer sockets: focal_length_ (Float), sensor_ (Vector), shift_ (Vector), clip_start_ (Float), clip_end_ (Float), focus_distance_ (Float), is_orthographic_ (Boolean), orthographic_scale_ (Float)

    """
    node = Node('Camera Info', {'Camera': camera})
    return node._out

capture_attribute(named_sockets={}, geometry=None, domain='POINT', **sockets) classmethod

Node Capture Attribute

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def capture_attribute(cls,
                named_sockets: dict = {},
                geometry: Geometry = None,
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT',
                **sockets):
    """ > Node Capture Attribute

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('Capture Attribute', 'domain', domain, 'capture_attribute', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Capture Attribute', {'Geometry': geometry, **named_sockets}, domain=domain, **sockets)
    return node._out

checker_texture(vector=None, color1=None, color2=None, scale=None) classmethod

Node Checker Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
color1	Color	socket 'Color1' (id: Color1)	None
color2	Color	socket 'Color2' (id: Color2)	None
scale	Float	socket 'Scale' (id: Scale)	None

Returns:

Type	Description
Color	peer sockets: factor_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def checker_texture(cls,
                vector: Vector = None,
                color1: Color = None,
                color2: Color = None,
                scale: Float = None):
    """ > Node Checker Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    color1 : Color, optional
        socket 'Color1' (id: Color1)

    color2 : Color, optional
        socket 'Color2' (id: Color2)

    scale : Float, optional
        socket 'Scale' (id: Scale)


    Returns
    -------
    Color
        peer sockets: factor_ (Float)

    """
    node = Node('Checker Texture', {'Vector': vector, 'Color1': color1, 'Color2': color2, 'Scale': scale})
    return node._out

clamp(value=None, min=None, max=None, clamp_type='MINMAX') classmethod

Node Clamp

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
min	Float	socket 'Min' (id: Min)	None
max	Float	socket 'Max' (id: Max)	None
clamp_type	Literal['Min Max', 'Range']	parameter clamp_type	'MINMAX'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def clamp(cls,
                value: Float = None,
                min: Float = None,
                max: Float = None,
                clamp_type: Literal['MINMAX', 'RANGE'] = 'MINMAX'):
    """ > Node Clamp

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    min : Float, optional
        socket 'Min' (id: Min)

    max : Float, optional
        socket 'Max' (id: Max)

    clamp_type : Literal['Min Max', 'Range']
        parameter `clamp_type`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Clamp', 'clamp_type', clamp_type, 'clamp', ('MINMAX', 'RANGE'))
    node = Node('Clamp', {'Value': value, 'Min': min, 'Max': max}, clamp_type=clamp_type)
    return node._out

clip_grid(grid=None, min_x=None, min_y=None, min_z=None, max_x=None, max_y=None, max_z=None, data_type='FLOAT') classmethod

Node Clip Grid

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
min_x	Integer	socket 'Min X' (id: Min X)	None
min_y	Integer	socket 'Min Y' (id: Min Y)	None
min_z	Integer	socket 'Min Z' (id: Min Z)	None
max_x	Integer	socket 'Max X' (id: Max X)	None
max_y	Integer	socket 'Max Y' (id: Max Y)	None
max_z	Integer	socket 'Max Z' (id: Max Z)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def clip_grid(cls,
                grid: Float = None,
                min_x: Integer = None,
                min_y: Integer = None,
                min_z: Integer = None,
                max_x: Integer = None,
                max_y: Integer = None,
                max_z: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Clip Grid

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    min_x : Integer, optional
        socket 'Min X' (id: Min X)

    min_y : Integer, optional
        socket 'Min Y' (id: Min Y)

    min_z : Integer, optional
        socket 'Min Z' (id: Min Z)

    max_x : Integer, optional
        socket 'Max X' (id: Max X)

    max_y : Integer, optional
        socket 'Max Y' (id: Max Y)

    max_z : Integer, optional
        socket 'Max Z' (id: Max Z)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Clip Grid', {'Grid': grid, 'Min X': min_x, 'Min Y': min_y, 'Min Z': min_z, 'Max X': max_x, 'Max Y': max_y, 'Max Z': max_z}, data_type=data_type)
    return node._out

closure_input()

Node Closure Input

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@utils.classproperty
def closure_input(self):
    """ > Node Closure Input

    Returns
    -------
    None
    """
    node = Node('Closure Input', )
    return node._out

closure_output(active_input_index=0, active_output_index=0, define_signature=False) classmethod

Node Closure Output

Parameters:

Name	Type	Description	Default
active_input_index	int	parameter active_input_index	0
active_output_index	int	parameter active_output_index	0
define_signature	bool	parameter define_signature	False

Returns:

Type	Description
Closure

Source code in core/generated/static_nd.py

@classmethod
def closure_output(cls, active_input_index = 0, active_output_index = 0, define_signature = False):
    """ > Node Closure Output

    Parameters
    ----------
    active_input_index : int
        parameter `active_input_index`

    active_output_index : int
        parameter `active_output_index`

    define_signature : bool
        parameter `define_signature`


    Returns
    -------
    Closure
    """
    node = Node('Closure Output', active_input_index=active_input_index, active_output_index=active_output_index, define_signature=define_signature)
    return node._out

collection(collection=None) classmethod

Node Collection

Parameters:

Name	Type	Description	Default
collection	NoneType	parameter collection	None

Returns:

Type	Description
Collection

Source code in core/generated/static_nd.py

@classmethod
def collection(cls, collection = None):
    """ > Node Collection

    Parameters
    ----------
    collection : NoneType
        parameter `collection`


    Returns
    -------
    Collection
    """
    node = Node('Collection', collection=collection)
    return node._out

collection_info(collection=None, separate_children=None, reset_children=None, transform_space='ORIGINAL') classmethod

Node Collection Info

Parameters:

Name	Type	Description	Default
collection	Collection	socket 'Collection' (id: Collection)	None
separate_children	Boolean	socket 'Separate Children' (id: Separate Children)	None
reset_children	Boolean	socket 'Reset Children' (id: Reset Children)	None
transform_space	Literal['Original', 'Relative']	parameter transform_space	'ORIGINAL'

Returns:

Type	Description
Instances

Source code in core/generated/static_nd.py

@classmethod
def collection_info(cls,
                collection: Collection = None,
                separate_children: Boolean = None,
                reset_children: Boolean = None,
                transform_space: Literal['ORIGINAL', 'RELATIVE'] = 'ORIGINAL'):
    """ > Node Collection Info

    Parameters
    ----------
    collection : Collection, optional
        socket 'Collection' (id: Collection)

    separate_children : Boolean, optional
        socket 'Separate Children' (id: Separate Children)

    reset_children : Boolean, optional
        socket 'Reset Children' (id: Reset Children)

    transform_space : Literal['Original', 'Relative']
        parameter `transform_space`


    Returns
    -------
    Instances
    """
    utils.check_enum_arg('Collection Info', 'transform_space', transform_space, 'collection_info', ('ORIGINAL', 'RELATIVE'))
    node = Node('Collection Info', {'Collection': collection, 'Separate Children': separate_children, 'Reset Children': reset_children}, transform_space=transform_space)
    return node._out

color()

Node Color

Returns:

Type	Description
Color

Source code in core/generated/static_nd.py

@utils.classproperty
def color(self):
    """ > Node Color

    Returns
    -------
    Color
    """
    node = Node('Color', )
    return node._out

color_ramp(fac=None, stops=None, interpolation='LINEAR') classmethod

Node Color Ramp

Exposes utilities to manage the color ramp

ramp1 = Float(.5).color_ramp(stops=[.1, .9])
ramp2 = ColorRamp(.5, stops=[(.1, (1, 0, 0)), (.5, 1), (.9, (0, 0, 1))])

Parameters:

Name	Type	Description	Default
fac	Float		None
stops	list[tuple[float, tuple]]	Stops made of (float, color as tuple of floats)	None
interpolation	('EASE', 'CARDINAL', 'LINEAR', 'B_SPLINE', 'CONSTANT')		'EASE'

Source code in core/generated/static_nd.py

@classmethod
def color_ramp(cls, fac=None, stops=None, interpolation='LINEAR'):
    """ Node Color Ramp

    Exposes utilities to manage the color ramp

    ``` python
    ramp1 = Float(.5).color_ramp(stops=[.1, .9])
    ramp2 = ColorRamp(.5, stops=[(.1, (1, 0, 0)), (.5, 1), (.9, (0, 0, 1))])
    ```

    Parameters
    ----------
    fac : Float, optional

    stops : list[tuple[float, tuple]]
        Stops made of (float, color as tuple of floats)

    interpolation : {'EASE', 'CARDINAL', 'LINEAR', 'B_SPLINE', 'CONSTANT'}

    """
    node = ColorRamp(fac=fac, stops=stops, interpolation=interpolation)
    return node._out

combine_bundle(named_sockets={}, define_signature=False, **sockets) classmethod

Node Combine Bundle

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
define_signature	bool	parameter define_signature	False
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
Bundle

Source code in core/generated/static_nd.py

@classmethod
def combine_bundle(cls, named_sockets: dict = {}, define_signature = False, **sockets):
    """ > Node Combine Bundle

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    define_signature : bool
        parameter `define_signature`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    Bundle
    """
    node = Node('Combine Bundle', named_sockets, define_signature=define_signature, **sockets)
    return node._out

combine_color(red=None, green=None, blue=None, alpha=None, mode='RGB') classmethod

Node Combine Color

Parameters:

Name	Type	Description	Default
red	Float	socket 'Red' (id: Red)	None
green	Float	socket 'Green' (id: Green)	None
blue	Float	socket 'Blue' (id: Blue)	None
alpha	Float	socket 'Alpha' (id: Alpha)	None
mode	Literal['RGB', 'HSV', 'HSL']	parameter mode	'RGB'

Returns:

Type	Description
Color

Source code in core/generated/static_nd.py

@classmethod
def combine_color(cls,
                red: Float = None,
                green: Float = None,
                blue: Float = None,
                alpha: Float = None,
                mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB'):
    """ > Node Combine Color

    Parameters
    ----------
    red : Float, optional
        socket 'Red' (id: Red)

    green : Float, optional
        socket 'Green' (id: Green)

    blue : Float, optional
        socket 'Blue' (id: Blue)

    alpha : Float, optional
        socket 'Alpha' (id: Alpha)

    mode : Literal['RGB', 'HSV', 'HSL']
        parameter `mode`


    Returns
    -------
    Color
    """
    utils.check_enum_arg('Combine Color', 'mode', mode, 'combine_color', ('RGB', 'HSV', 'HSL'))
    node = Node('Combine Color', {'Red': red, 'Green': green, 'Blue': blue, 'Alpha': alpha}, mode=mode)
    return node._out

combine_matrix(column_1_row_1=None, column_1_row_2=None, column_1_row_3=None, column_1_row_4=None, column_2_row_1=None, column_2_row_2=None, column_2_row_3=None, column_2_row_4=None, column_3_row_1=None, column_3_row_2=None, column_3_row_3=None, column_3_row_4=None, column_4_row_1=None, column_4_row_2=None, column_4_row_3=None, column_4_row_4=None) classmethod

Node Combine Matrix

Parameters:

Name	Type	Description	Default
column_1_row_1	Float	socket 'Column 1 Row 1' (id: Column 1 Row 1)	None
column_1_row_2	Float	socket 'Column 1 Row 2' (id: Column 1 Row 2)	None
column_1_row_3	Float	socket 'Column 1 Row 3' (id: Column 1 Row 3)	None
column_1_row_4	Float	socket 'Column 1 Row 4' (id: Column 1 Row 4)	None
column_2_row_1	Float	socket 'Column 2 Row 1' (id: Column 2 Row 1)	None
column_2_row_2	Float	socket 'Column 2 Row 2' (id: Column 2 Row 2)	None
column_2_row_3	Float	socket 'Column 2 Row 3' (id: Column 2 Row 3)	None
column_2_row_4	Float	socket 'Column 2 Row 4' (id: Column 2 Row 4)	None
column_3_row_1	Float	socket 'Column 3 Row 1' (id: Column 3 Row 1)	None
column_3_row_2	Float	socket 'Column 3 Row 2' (id: Column 3 Row 2)	None
column_3_row_3	Float	socket 'Column 3 Row 3' (id: Column 3 Row 3)	None
column_3_row_4	Float	socket 'Column 3 Row 4' (id: Column 3 Row 4)	None
column_4_row_1	Float	socket 'Column 4 Row 1' (id: Column 4 Row 1)	None
column_4_row_2	Float	socket 'Column 4 Row 2' (id: Column 4 Row 2)	None
column_4_row_3	Float	socket 'Column 4 Row 3' (id: Column 4 Row 3)	None
column_4_row_4	Float	socket 'Column 4 Row 4' (id: Column 4 Row 4)	None

Returns:

Type	Description
Matrix

Source code in core/generated/static_nd.py

@classmethod
def combine_matrix(cls,
                column_1_row_1: Float = None,
                column_1_row_2: Float = None,
                column_1_row_3: Float = None,
                column_1_row_4: Float = None,
                column_2_row_1: Float = None,
                column_2_row_2: Float = None,
                column_2_row_3: Float = None,
                column_2_row_4: Float = None,
                column_3_row_1: Float = None,
                column_3_row_2: Float = None,
                column_3_row_3: Float = None,
                column_3_row_4: Float = None,
                column_4_row_1: Float = None,
                column_4_row_2: Float = None,
                column_4_row_3: Float = None,
                column_4_row_4: Float = None):
    """ > Node Combine Matrix

    Parameters
    ----------
    column_1_row_1 : Float, optional
        socket 'Column 1 Row 1' (id: Column 1 Row 1)

    column_1_row_2 : Float, optional
        socket 'Column 1 Row 2' (id: Column 1 Row 2)

    column_1_row_3 : Float, optional
        socket 'Column 1 Row 3' (id: Column 1 Row 3)

    column_1_row_4 : Float, optional
        socket 'Column 1 Row 4' (id: Column 1 Row 4)

    column_2_row_1 : Float, optional
        socket 'Column 2 Row 1' (id: Column 2 Row 1)

    column_2_row_2 : Float, optional
        socket 'Column 2 Row 2' (id: Column 2 Row 2)

    column_2_row_3 : Float, optional
        socket 'Column 2 Row 3' (id: Column 2 Row 3)

    column_2_row_4 : Float, optional
        socket 'Column 2 Row 4' (id: Column 2 Row 4)

    column_3_row_1 : Float, optional
        socket 'Column 3 Row 1' (id: Column 3 Row 1)

    column_3_row_2 : Float, optional
        socket 'Column 3 Row 2' (id: Column 3 Row 2)

    column_3_row_3 : Float, optional
        socket 'Column 3 Row 3' (id: Column 3 Row 3)

    column_3_row_4 : Float, optional
        socket 'Column 3 Row 4' (id: Column 3 Row 4)

    column_4_row_1 : Float, optional
        socket 'Column 4 Row 1' (id: Column 4 Row 1)

    column_4_row_2 : Float, optional
        socket 'Column 4 Row 2' (id: Column 4 Row 2)

    column_4_row_3 : Float, optional
        socket 'Column 4 Row 3' (id: Column 4 Row 3)

    column_4_row_4 : Float, optional
        socket 'Column 4 Row 4' (id: Column 4 Row 4)


    Returns
    -------
    Matrix
    """
    node = Node('Combine Matrix', {'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})
    return node._out

combine_transform(translation=None, rotation=None, scale=None) classmethod

Node Combine Transform

Parameters:

Name	Type	Description	Default
translation	Vector	socket 'Translation' (id: Translation)	None
rotation	Rotation	socket 'Rotation' (id: Rotation)	None
scale	Vector	socket 'Scale' (id: Scale)	None

Returns:

Type	Description
Matrix

Source code in core/generated/static_nd.py

@classmethod
def combine_transform(cls,
                translation: Vector = None,
                rotation: Rotation = None,
                scale: Vector = None):
    """ > Node Combine Transform

    Parameters
    ----------
    translation : Vector, optional
        socket 'Translation' (id: Translation)

    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)

    scale : Vector, optional
        socket 'Scale' (id: Scale)


    Returns
    -------
    Matrix
    """
    node = Node('Combine Transform', {'Translation': translation, 'Rotation': rotation, 'Scale': scale})
    return node._out

combine_xyz(x=None, y=None, z=None) classmethod

Node Combine XYZ

Parameters:

Name	Type	Description	Default
x	Float	socket 'X' (id: X)	None
y	Float	socket 'Y' (id: Y)	None
z	Float	socket 'Z' (id: Z)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def combine_xyz(cls, x: Float = None, y: Float = None, z: Float = None):
    """ > Node Combine XYZ

    Parameters
    ----------
    x : Float, optional
        socket 'X' (id: X)

    y : Float, optional
        socket 'Y' (id: Y)

    z : Float, optional
        socket 'Z' (id: Z)


    Returns
    -------
    Vector
    """
    node = Node('Combine XYZ', {'X': x, 'Y': y, 'Z': z})
    return node._out

compare(a=None, b=None, a_1=None, b_1=None, a_2=None, b_2=None, a_3=None, b_3=None, a_4=None, b_4=None, c=None, angle=None, epsilon=None, data_type='FLOAT', mode='ELEMENT', operation='GREATER_THAN') classmethod

Node Compare

Parameters:

Name	Type	Description	Default
a	Float	socket 'A' (id: A)	None
b	Float	socket 'B' (id: B)	None
a_1	Integer	socket 'A' (id: A_INT)	None
b_1	Integer	socket 'B' (id: B_INT)	None
a_2	Vector	socket 'A' (id: A_VEC3)	None
b_2	Vector	socket 'B' (id: B_VEC3)	None
a_3	Color	socket 'A' (id: A_COL)	None
b_3	Color	socket 'B' (id: B_COL)	None
a_4	String	socket 'A' (id: A_STR)	None
b_4	String	socket 'B' (id: B_STR)	None
c	Float	socket 'C' (id: C)	None
angle	Float	socket 'Angle' (id: Angle)	None
epsilon	Float	socket 'Epsilon' (id: Epsilon)	None
data_type	Literal['Float', 'Integer', 'Vector', 'Color', 'String']	parameter data_type	'FLOAT'
mode	Literal['Element-Wise', 'Length', 'Average', 'Dot Product', 'Direction']	parameter mode	'ELEMENT'
operation	Literal['Less Than', 'Less Than or Equal', 'Greater Than', 'Greater Than or Equal', 'Equal', 'Not Equal']	parameter operation	'GREATER_THAN'

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def compare(cls,
                a: Float = None,
                b: Float = None,
                a_1: Integer = None,
                b_1: Integer = None,
                a_2: Vector = None,
                b_2: Vector = None,
                a_3: Color = None,
                b_3: Color = None,
                a_4: String = None,
                b_4: String = None,
                c: Float = None,
                angle: Float = None,
                epsilon: Float = None,
                data_type: Literal['FLOAT', 'INT', 'VECTOR', 'RGBA', 'STRING'] = 'FLOAT',
                mode: Literal['ELEMENT', 'LENGTH', 'AVERAGE', 'DOT_PRODUCT', 'DIRECTION'] = 'ELEMENT',
                operation: Literal['LESS_THAN', 'LESS_EQUAL', 'GREATER_THAN', 'GREATER_EQUAL', 'EQUAL', 'NOT_EQUAL'] = 'GREATER_THAN'):
    """ > Node Compare

    Parameters
    ----------
    a : Float, optional
        socket 'A' (id: A)

    b : Float, optional
        socket 'B' (id: B)

    a_1 : Integer, optional
        socket 'A' (id: A_INT)

    b_1 : Integer, optional
        socket 'B' (id: B_INT)

    a_2 : Vector, optional
        socket 'A' (id: A_VEC3)

    b_2 : Vector, optional
        socket 'B' (id: B_VEC3)

    a_3 : Color, optional
        socket 'A' (id: A_COL)

    b_3 : Color, optional
        socket 'B' (id: B_COL)

    a_4 : String, optional
        socket 'A' (id: A_STR)

    b_4 : String, optional
        socket 'B' (id: B_STR)

    c : Float, optional
        socket 'C' (id: C)

    angle : Float, optional
        socket 'Angle' (id: Angle)

    epsilon : Float, optional
        socket 'Epsilon' (id: Epsilon)

    data_type : Literal['Float', 'Integer', 'Vector', 'Color', 'String']
        parameter `data_type`

    mode : Literal['Element-Wise', 'Length', 'Average', 'Dot Product', 'Direction']
        parameter `mode`

    operation : Literal['Less Than', 'Less Than or Equal', 'Greater Than', 'Greater Than or Equal', 'Equal', 'Not Equal']
        parameter `operation`


    Returns
    -------
    Boolean
    """
    utils.check_enum_arg('Compare', 'mode', mode, 'compare', ('ELEMENT', 'LENGTH', 'AVERAGE', 'DOT_PRODUCT', 'DIRECTION'))
    utils.check_enum_arg('Compare', 'operation', operation, 'compare', ('LESS_THAN', 'LESS_EQUAL', 'GREATER_THAN', 'GREATER_EQUAL', 'EQUAL', 'NOT_EQUAL'))
    node = Node('Compare', {'A': a, 'B': b, 'A_INT': a_1, 'B_INT': b_1, 'A_VEC3': a_2, 'B_VEC3': b_2, 'A_COL': a_3, 'B_COL': b_3, 'A_STR': a_4, 'B_STR': b_4, 'C': c, 'Angle': angle, 'Epsilon': epsilon}, data_type=data_type, mode=mode, operation=operation)
    return node._out

cone(vertices=None, side_segments=None, fill_segments=None, radius_top=None, radius_bottom=None, depth=None, fill_type='NGON') classmethod

Node Cone

Parameters:

Name	Type	Description	Default
vertices	Integer	socket 'Vertices' (id: Vertices)	None
side_segments	Integer	socket 'Side Segments' (id: Side Segments)	None
fill_segments	Integer	socket 'Fill Segments' (id: Fill Segments)	None
radius_top	Float	socket 'Radius Top' (id: Radius Top)	None
radius_bottom	Float	socket 'Radius Bottom' (id: Radius Bottom)	None
depth	Float	socket 'Depth' (id: Depth)	None
fill_type	Literal['None', 'N-Gon', 'Triangles']	parameter fill_type	'NGON'

Returns:

Type	Description
Mesh	peer sockets: top_ (Boolean), bottom_ (Boolean), side_ (Boolean), uv_map_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def cone(cls,
                vertices: Integer = None,
                side_segments: Integer = None,
                fill_segments: Integer = None,
                radius_top: Float = None,
                radius_bottom: Float = None,
                depth: Float = None,
                fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NGON'):
    """ > Node Cone

    Parameters
    ----------
    vertices : Integer, optional
        socket 'Vertices' (id: Vertices)

    side_segments : Integer, optional
        socket 'Side Segments' (id: Side Segments)

    fill_segments : Integer, optional
        socket 'Fill Segments' (id: Fill Segments)

    radius_top : Float, optional
        socket 'Radius Top' (id: Radius Top)

    radius_bottom : Float, optional
        socket 'Radius Bottom' (id: Radius Bottom)

    depth : Float, optional
        socket 'Depth' (id: Depth)

    fill_type : Literal['None', 'N-Gon', 'Triangles']
        parameter `fill_type`


    Returns
    -------
    Mesh
        peer sockets: top_ (Boolean), bottom_ (Boolean), side_ (Boolean), uv_map_ (Vector)

    """
    utils.check_enum_arg('Cone', 'fill_type', fill_type, 'cone', ('NONE', 'NGON', 'TRIANGLE_FAN'))
    node = Node('Cone', {'Vertices': vertices, 'Side Segments': side_segments, 'Fill Segments': fill_segments, 'Radius Top': radius_top, 'Radius Bottom': radius_bottom, 'Depth': depth}, fill_type=fill_type)
    return node._out

convex_hull(geometry=None) classmethod

Node Convex Hull

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def convex_hull(cls, geometry: Geometry = None):
    """ > Node Convex Hull

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)


    Returns
    -------
    Mesh
    """
    node = Node('Convex Hull', {'Geometry': geometry})
    return node._out

corners_of_edge(edge_index=None, weights=None, sort_index=None) classmethod

Node Corners of Edge

Parameters:

Name	Type	Description	Default
edge_index	Integer	socket 'Edge Index' (id: Edge Index)	None
weights	Float	socket 'Weights' (id: Weights)	None
sort_index	Integer	socket 'Sort Index' (id: Sort Index)	None

Returns:

Type	Description
Integer	peer sockets: total_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def corners_of_edge(cls,
                edge_index: Integer = None,
                weights: Float = None,
                sort_index: Integer = None):
    """ > Node Corners of Edge

    Parameters
    ----------
    edge_index : Integer, optional
        socket 'Edge Index' (id: Edge Index)

    weights : Float, optional
        socket 'Weights' (id: Weights)

    sort_index : Integer, optional
        socket 'Sort Index' (id: Sort Index)


    Returns
    -------
    Integer
        peer sockets: total_ (Integer)

    """
    node = Node('Corners of Edge', {'Edge Index': edge_index, 'Weights': weights, 'Sort Index': sort_index})
    return node._out

corners_of_face(face_index=None, weights=None, sort_index=None) classmethod

Node Corners of Face

Parameters:

Name	Type	Description	Default
face_index	Integer	socket 'Face Index' (id: Face Index)	None
weights	Float	socket 'Weights' (id: Weights)	None
sort_index	Integer	socket 'Sort Index' (id: Sort Index)	None

Returns:

Type	Description
Integer	peer sockets: total_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def corners_of_face(cls,
                face_index: Integer = None,
                weights: Float = None,
                sort_index: Integer = None):
    """ > Node Corners of Face

    Parameters
    ----------
    face_index : Integer, optional
        socket 'Face Index' (id: Face Index)

    weights : Float, optional
        socket 'Weights' (id: Weights)

    sort_index : Integer, optional
        socket 'Sort Index' (id: Sort Index)


    Returns
    -------
    Integer
        peer sockets: total_ (Integer)

    """
    node = Node('Corners of Face', {'Face Index': face_index, 'Weights': weights, 'Sort Index': sort_index})
    return node._out

corners_of_vertex(vertex_index=None, weights=None, sort_index=None) classmethod

Node Corners of Vertex

Parameters:

Name	Type	Description	Default
vertex_index	Integer	socket 'Vertex Index' (id: Vertex Index)	None
weights	Float	socket 'Weights' (id: Weights)	None
sort_index	Integer	socket 'Sort Index' (id: Sort Index)	None

Returns:

Type	Description
Integer	peer sockets: total_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def corners_of_vertex(cls,
                vertex_index: Integer = None,
                weights: Float = None,
                sort_index: Integer = None):
    """ > Node Corners of Vertex

    Parameters
    ----------
    vertex_index : Integer, optional
        socket 'Vertex Index' (id: Vertex Index)

    weights : Float, optional
        socket 'Weights' (id: Weights)

    sort_index : Integer, optional
        socket 'Sort Index' (id: Sort Index)


    Returns
    -------
    Integer
        peer sockets: total_ (Integer)

    """
    node = Node('Corners of Vertex', {'Vertex Index': vertex_index, 'Weights': weights, 'Sort Index': sort_index})
    return node._out

cube(size=None, vertices_x=None, vertices_y=None, vertices_z=None) classmethod

Node Cube

Parameters:

Name	Type	Description	Default
size	Vector	socket 'Size' (id: Size)	None
vertices_x	Integer	socket 'Vertices X' (id: Vertices X)	None
vertices_y	Integer	socket 'Vertices Y' (id: Vertices Y)	None
vertices_z	Integer	socket 'Vertices Z' (id: Vertices Z)	None

Returns:

Type	Description
Mesh	peer sockets: uv_map_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def cube(cls,
                size: Vector = None,
                vertices_x: Integer = None,
                vertices_y: Integer = None,
                vertices_z: Integer = None):
    """ > Node Cube

    Parameters
    ----------
    size : Vector, optional
        socket 'Size' (id: Size)

    vertices_x : Integer, optional
        socket 'Vertices X' (id: Vertices X)

    vertices_y : Integer, optional
        socket 'Vertices Y' (id: Vertices Y)

    vertices_z : Integer, optional
        socket 'Vertices Z' (id: Vertices Z)


    Returns
    -------
    Mesh
        peer sockets: uv_map_ (Vector)

    """
    node = Node('Cube', {'Size': size, 'Vertices X': vertices_x, 'Vertices Y': vertices_y, 'Vertices Z': vertices_z})
    return node._out

cube_grid_topology(bounds_min=None, bounds_max=None, resolution_x=None, resolution_y=None, resolution_z=None, min_x=None, min_y=None, min_z=None) classmethod

Node Cube Grid Topology

Parameters:

Name	Type	Description	Default
bounds_min	Vector	socket 'Bounds Min' (id: Bounds Min)	None
bounds_max	Vector	socket 'Bounds Max' (id: Bounds Max)	None
resolution_x	Integer	socket 'Resolution X' (id: Resolution X)	None
resolution_y	Integer	socket 'Resolution Y' (id: Resolution Y)	None
resolution_z	Integer	socket 'Resolution Z' (id: Resolution Z)	None
min_x	Integer	socket 'Min X' (id: Min X)	None
min_y	Integer	socket 'Min Y' (id: Min Y)	None
min_z	Integer	socket 'Min Z' (id: Min Z)	None

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def cube_grid_topology(cls,
                bounds_min: Vector = None,
                bounds_max: Vector = None,
                resolution_x: Integer = None,
                resolution_y: Integer = None,
                resolution_z: Integer = None,
                min_x: Integer = None,
                min_y: Integer = None,
                min_z: Integer = None):
    """ > Node Cube Grid Topology

    Parameters
    ----------
    bounds_min : Vector, optional
        socket 'Bounds Min' (id: Bounds Min)

    bounds_max : Vector, optional
        socket 'Bounds Max' (id: Bounds Max)

    resolution_x : Integer, optional
        socket 'Resolution X' (id: Resolution X)

    resolution_y : Integer, optional
        socket 'Resolution Y' (id: Resolution Y)

    resolution_z : Integer, optional
        socket 'Resolution Z' (id: Resolution Z)

    min_x : Integer, optional
        socket 'Min X' (id: Min X)

    min_y : Integer, optional
        socket 'Min Y' (id: Min Y)

    min_z : Integer, optional
        socket 'Min Z' (id: Min Z)


    Returns
    -------
    Boolean
    """
    node = Node('Cube Grid Topology', {'Bounds Min': bounds_min, 'Bounds Max': bounds_max, 'Resolution X': resolution_x, 'Resolution Y': resolution_y, 'Resolution Z': resolution_z, 'Min X': min_x, 'Min Y': min_y, 'Min Z': min_z})
    return node._out

curve_circle(resolution=None, point_1=None, point_2=None, point_3=None, radius=None, mode='RADIUS') classmethod

Node Curve Circle

Parameters:

Name	Type	Description	Default
resolution	Integer	socket 'Resolution' (id: Resolution)	None
point_1	Vector	socket 'Point 1' (id: Point 1)	None
point_2	Vector	socket 'Point 2' (id: Point 2)	None
point_3	Vector	socket 'Point 3' (id: Point 3)	None
radius	Float	socket 'Radius' (id: Radius)	None
mode	Literal['Points', 'Radius']	parameter mode	'RADIUS'

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def curve_circle(cls,
                resolution: Integer = None,
                point_1: Vector = None,
                point_2: Vector = None,
                point_3: Vector = None,
                radius: Float = None,
                mode: Literal['POINTS', 'RADIUS'] = 'RADIUS'):
    """ > Node Curve Circle

    Parameters
    ----------
    resolution : Integer, optional
        socket 'Resolution' (id: Resolution)

    point_1 : Vector, optional
        socket 'Point 1' (id: Point 1)

    point_2 : Vector, optional
        socket 'Point 2' (id: Point 2)

    point_3 : Vector, optional
        socket 'Point 3' (id: Point 3)

    radius : Float, optional
        socket 'Radius' (id: Radius)

    mode : Literal['Points', 'Radius']
        parameter `mode`


    Returns
    -------
    Curve
    """
    utils.check_enum_arg('Curve Circle', 'mode', mode, 'curve_circle', ('POINTS', 'RADIUS'))
    node = Node('Curve Circle', {'Resolution': resolution, 'Point 1': point_1, 'Point 2': point_2, 'Point 3': point_3, 'Radius': radius}, mode=mode)
    return node._out

curve_handle_positions(relative=None) classmethod

Node Curve Handle Positions

Parameters:

Name	Type	Description	Default
relative	Boolean	socket 'Relative' (id: Relative)	None

Returns:

Type	Description
Vector	peer sockets: right_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def curve_handle_positions(cls, relative: Boolean = None):
    """ > Node Curve Handle Positions

    Parameters
    ----------
    relative : Boolean, optional
        socket 'Relative' (id: Relative)


    Returns
    -------
    Vector
        peer sockets: right_ (Vector)

    """
    node = Node('Curve Handle Positions', {'Relative': relative})
    return node._out

curve_length(curve=None) classmethod

Node Curve Length

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def curve_length(cls, curve: Curve = None):
    """ > Node Curve Length

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)


    Returns
    -------
    Float
    """
    node = Node('Curve Length', {'Curve': curve})
    return node._out

curve_line(start=None, end=None, direction=None, length=None, mode='POINTS') classmethod

Node Curve Line

Parameters:

Name	Type	Description	Default
start	Vector	socket 'Start' (id: Start)	None
end	Vector	socket 'End' (id: End)	None
direction	Vector	socket 'Direction' (id: Direction)	None
length	Float	socket 'Length' (id: Length)	None
mode	Literal['Points', 'Direction']	parameter mode	'POINTS'

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def curve_line(cls,
                start: Vector = None,
                end: Vector = None,
                direction: Vector = None,
                length: Float = None,
                mode: Literal['POINTS', 'DIRECTION'] = 'POINTS'):
    """ > Node Curve Line

    Parameters
    ----------
    start : Vector, optional
        socket 'Start' (id: Start)

    end : Vector, optional
        socket 'End' (id: End)

    direction : Vector, optional
        socket 'Direction' (id: Direction)

    length : Float, optional
        socket 'Length' (id: Length)

    mode : Literal['Points', 'Direction']
        parameter `mode`


    Returns
    -------
    Curve
    """
    utils.check_enum_arg('Curve Line', 'mode', mode, 'curve_line', ('POINTS', 'DIRECTION'))
    node = Node('Curve Line', {'Start': start, 'End': end, 'Direction': direction, 'Length': length}, mode=mode)
    return node._out

curve_of_point(point_index=None) classmethod

Node Curve of Point

Parameters:

Name	Type	Description	Default
point_index	Integer	socket 'Point Index' (id: Point Index)	None

Returns:

Type	Description
Integer	peer sockets: index_in_curve_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def curve_of_point(cls, point_index: Integer = None):
    """ > Node Curve of Point

    Parameters
    ----------
    point_index : Integer, optional
        socket 'Point Index' (id: Point Index)


    Returns
    -------
    Integer
        peer sockets: index_in_curve_ (Integer)

    """
    node = Node('Curve of Point', {'Point Index': point_index})
    return node._out

curve_tangent()

Node Curve Tangent

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@utils.classproperty
def curve_tangent(self):
    """ > Node Curve Tangent

    Returns
    -------
    Vector
    """
    node = Node('Curve Tangent', )
    return node._out

curve_tilt()

Node Curve Tilt

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@utils.classproperty
def curve_tilt(self):
    """ > Node Curve Tilt

    Returns
    -------
    Float
    """
    node = Node('Curve Tilt', )
    return node._out

curve_to_mesh(curve=None, profile_curve=None, scale=None, fill_caps=None) classmethod

Node Curve to Mesh

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
profile_curve	Curve	socket 'Profile Curve' (id: Profile Curve)	None
scale	Float	socket 'Scale' (id: Scale)	None
fill_caps	Boolean	socket 'Fill Caps' (id: Fill Caps)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def curve_to_mesh(cls,
                curve: Curve = None,
                profile_curve: Curve = None,
                scale: Float = None,
                fill_caps: Boolean = None):
    """ > Node Curve to Mesh

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    profile_curve : Curve, optional
        socket 'Profile Curve' (id: Profile Curve)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    fill_caps : Boolean, optional
        socket 'Fill Caps' (id: Fill Caps)


    Returns
    -------
    Mesh
    """
    node = Node('Curve to Mesh', {'Curve': curve, 'Profile Curve': profile_curve, 'Scale': scale, 'Fill Caps': fill_caps})
    return node._out

curve_to_points(curve=None, count=None, length=None, mode='COUNT') classmethod

Node Curve to Points

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
count	Integer	socket 'Count' (id: Count)	None
length	Float	socket 'Length' (id: Length)	None
mode	Literal['Evaluated', 'Count', 'Length']	parameter mode	'COUNT'

Returns:

Type	Description
Cloud	peer sockets: tangent_ (Vector), normal_ (Vector), rotation_ (Rotation)

Source code in core/generated/static_nd.py

@classmethod
def curve_to_points(cls,
                curve: Curve = None,
                count: Integer = None,
                length: Float = None,
                mode: Literal['EVALUATED', 'COUNT', 'LENGTH'] = 'COUNT'):
    """ > Node Curve to Points

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    count : Integer, optional
        socket 'Count' (id: Count)

    length : Float, optional
        socket 'Length' (id: Length)

    mode : Literal['Evaluated', 'Count', 'Length']
        parameter `mode`


    Returns
    -------
    Cloud
        peer sockets: tangent_ (Vector), normal_ (Vector), rotation_ (Rotation)

    """
    utils.check_enum_arg('Curve to Points', 'mode', mode, 'curve_to_points', ('EVALUATED', 'COUNT', 'LENGTH'))
    node = Node('Curve to Points', {'Curve': curve, 'Count': count, 'Length': length}, mode=mode)
    return node._out

curves_to_grease_pencil(curves=None, selection=None, instances_as_layers=None) classmethod

Node Curves to Grease Pencil

Parameters:

Name	Type	Description	Default
curves	Curve	socket 'Curves' (id: Curves)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
instances_as_layers	Boolean	socket 'Instances as Layers' (id: Instances as Layers)	None

Returns:

Type	Description
GreasePencil

Source code in core/generated/static_nd.py

@classmethod
def curves_to_grease_pencil(cls,
                curves: Curve = None,
                selection: Boolean = None,
                instances_as_layers: Boolean = None):
    """ > Node Curves to Grease Pencil

    Parameters
    ----------
    curves : Curve, optional
        socket 'Curves' (id: Curves)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    instances_as_layers : Boolean, optional
        socket 'Instances as Layers' (id: Instances as Layers)


    Returns
    -------
    GreasePencil
    """
    node = Node('Curves to Grease Pencil', {'Curves': curves, 'Selection': selection, 'Instances as Layers': instances_as_layers})
    return node._out

cylinder(vertices=None, side_segments=None, fill_segments=None, radius=None, depth=None, fill_type='NGON') classmethod

Node Cylinder

Parameters:

Name	Type	Description	Default
vertices	Integer	socket 'Vertices' (id: Vertices)	None
side_segments	Integer	socket 'Side Segments' (id: Side Segments)	None
fill_segments	Integer	socket 'Fill Segments' (id: Fill Segments)	None
radius	Float	socket 'Radius' (id: Radius)	None
depth	Float	socket 'Depth' (id: Depth)	None
fill_type	Literal['None', 'N-Gon', 'Triangles']	parameter fill_type	'NGON'

Returns:

Type	Description
Mesh	peer sockets: top_ (Boolean), side_ (Boolean), bottom_ (Boolean), uv_map_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def cylinder(cls,
                vertices: Integer = None,
                side_segments: Integer = None,
                fill_segments: Integer = None,
                radius: Float = None,
                depth: Float = None,
                fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NGON'):
    """ > Node Cylinder

    Parameters
    ----------
    vertices : Integer, optional
        socket 'Vertices' (id: Vertices)

    side_segments : Integer, optional
        socket 'Side Segments' (id: Side Segments)

    fill_segments : Integer, optional
        socket 'Fill Segments' (id: Fill Segments)

    radius : Float, optional
        socket 'Radius' (id: Radius)

    depth : Float, optional
        socket 'Depth' (id: Depth)

    fill_type : Literal['None', 'N-Gon', 'Triangles']
        parameter `fill_type`


    Returns
    -------
    Mesh
        peer sockets: top_ (Boolean), side_ (Boolean), bottom_ (Boolean), uv_map_ (Vector)

    """
    utils.check_enum_arg('Cylinder', 'fill_type', fill_type, 'cylinder', ('NONE', 'NGON', 'TRIANGLE_FAN'))
    node = Node('Cylinder', {'Vertices': vertices, 'Side Segments': side_segments, 'Fill Segments': fill_segments, 'Radius': radius, 'Depth': depth}, fill_type=fill_type)
    return node._out

deform_curves_on_surface(curves=None) classmethod

Node Deform Curves on Surface

Parameters:

Name	Type	Description	Default
curves	Curve	socket 'Curves' (id: Curves)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def deform_curves_on_surface(cls, curves: Curve = None):
    """ > Node Deform Curves on Surface

    Parameters
    ----------
    curves : Curve, optional
        socket 'Curves' (id: Curves)


    Returns
    -------
    Curve
    """
    node = Node('Deform Curves on Surface', {'Curves': curves})
    return node._out

delete_geometry(geometry=None, selection=None, domain='POINT', mode='ALL') classmethod

Node Delete Geometry

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
domain	Literal['Point', 'Edge', 'Face', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'
mode	Literal['All', 'Only Edges & Faces', 'Only Faces']	parameter mode	'ALL'

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def delete_geometry(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT',
                mode: Literal['ALL', 'EDGE_FACE', 'ONLY_FACE'] = 'ALL'):
    """ > Node Delete Geometry

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    domain : Literal['Point', 'Edge', 'Face', 'Spline', 'Instance', 'Layer']
        parameter `domain`

    mode : Literal['All', 'Only Edges & Faces', 'Only Faces']
        parameter `mode`


    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('Delete Geometry', 'domain', domain, 'delete_geometry', ('POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'))
    utils.check_enum_arg('Delete Geometry', 'mode', mode, 'delete_geometry', ('ALL', 'EDGE_FACE', 'ONLY_FACE'))
    node = Node('Delete Geometry', {'Geometry': geometry, 'Selection': selection}, domain=domain, mode=mode)
    return node._out

dial_gizmo(*value, position=None, up=None, screen_space=None, radius=None, color_id='PRIMARY') classmethod

Node Dial Gizmo

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	()
position	Vector	socket 'Position' (id: Position)	None
up	Vector	socket 'Up' (id: Up)	None
screen_space	Boolean	socket 'Screen Space' (id: Screen Space)	None
radius	Float	socket 'Radius' (id: Radius)	None
color_id	Literal['Primary', 'Secondary', 'X', 'Y', 'Z']	parameter color_id	'PRIMARY'

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def dial_gizmo(cls,
                *value: Float,
                position: Vector = None,
                up: Vector = None,
                screen_space: Boolean = None,
                radius: Float = None,
                color_id: Literal['PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'] = 'PRIMARY'):
    """ > Node Dial Gizmo

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    position : Vector, optional
        socket 'Position' (id: Position)

    up : Vector, optional
        socket 'Up' (id: Up)

    screen_space : Boolean, optional
        socket 'Screen Space' (id: Screen Space)

    radius : Float, optional
        socket 'Radius' (id: Radius)

    color_id : Literal['Primary', 'Secondary', 'X', 'Y', 'Z']
        parameter `color_id`


    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('Dial Gizmo', 'color_id', color_id, 'dial_gizmo', ('PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'))
    node = Node('Dial Gizmo', {'Value': list(value), 'Position': position, 'Up': up, 'Screen Space': screen_space, 'Radius': radius}, color_id=color_id)
    return node._out

distribute_points_in_grid(grid=None, density=None, seed=None, spacing=None, threshold=None, mode='DENSITY_RANDOM') classmethod

Node Distribute Points in Grid

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
density	Float	socket 'Density' (id: Density)	None
seed	Integer	socket 'Seed' (id: Seed)	None
spacing	Vector	socket 'Spacing' (id: Spacing)	None
threshold	Float	socket 'Threshold' (id: Threshold)	None
mode	Literal['Random', 'Grid']	parameter mode	'DENSITY_RANDOM'

Returns:

Type	Description
Cloud

Source code in core/generated/static_nd.py

@classmethod
def distribute_points_in_grid(cls,
                grid: Float = None,
                density: Float = None,
                seed: Integer = None,
                spacing: Vector = None,
                threshold: Float = None,
                mode: Literal['DENSITY_RANDOM', 'DENSITY_GRID'] = 'DENSITY_RANDOM'):
    """ > Node Distribute Points in Grid

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    density : Float, optional
        socket 'Density' (id: Density)

    seed : Integer, optional
        socket 'Seed' (id: Seed)

    spacing : Vector, optional
        socket 'Spacing' (id: Spacing)

    threshold : Float, optional
        socket 'Threshold' (id: Threshold)

    mode : Literal['Random', 'Grid']
        parameter `mode`


    Returns
    -------
    Cloud
    """
    utils.check_enum_arg('Distribute Points in Grid', 'mode', mode, 'distribute_points_in_grid', ('DENSITY_RANDOM', 'DENSITY_GRID'))
    node = Node('Distribute Points in Grid', {'Grid': grid, 'Density': density, 'Seed': seed, 'Spacing': spacing, 'Threshold': threshold}, mode=mode)
    return node._out

distribute_points_in_volume(volume=None, mode=None, density=None, seed=None, spacing=None, threshold=None) classmethod

Node Distribute Points in Volume

Parameters:

Name	Type	Description	Default
volume	Volume	socket 'Volume' (id: Volume)	None
mode	menu='Random'	('Random', 'Grid')	None
density	Float	socket 'Density' (id: Density)	None
seed	Integer	socket 'Seed' (id: Seed)	None
spacing	Vector	socket 'Spacing' (id: Spacing)	None
threshold	Float	socket 'Threshold' (id: Threshold)	None

Returns:

Type	Description
Cloud

Source code in core/generated/static_nd.py

@classmethod
def distribute_points_in_volume(cls,
                volume: Volume = None,
                mode: Literal['Random', 'Grid'] = None,
                density: Float = None,
                seed: Integer = None,
                spacing: Vector = None,
                threshold: Float = None):
    """ > Node Distribute Points in Volume

    Parameters
    ----------
    volume : Volume, optional
        socket 'Volume' (id: Volume)

    mode : menu='Random', optional
        ('Random', 'Grid')

    density : Float, optional
        socket 'Density' (id: Density)

    seed : Integer, optional
        socket 'Seed' (id: Seed)

    spacing : Vector, optional
        socket 'Spacing' (id: Spacing)

    threshold : Float, optional
        socket 'Threshold' (id: Threshold)


    Returns
    -------
    Cloud
    """
    node = Node('Distribute Points in Volume', {'Volume': volume, 'Mode': mode, 'Density': density, 'Seed': seed, 'Spacing': spacing, 'Threshold': threshold})
    return node._out

distribute_points_on_faces(mesh=None, selection=None, distance_min=None, density_max=None, density=None, density_factor=None, seed=None, distribute_method='RANDOM') classmethod

Node Distribute Points on Faces

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
distance_min	Float	socket 'Distance Min' (id: Distance Min)	None
density_max	Float	socket 'Density Max' (id: Density Max)	None
density	Float	socket 'Density' (id: Density)	None
density_factor	Float	socket 'Density Factor' (id: Density Factor)	None
seed	Integer	socket 'Seed' (id: Seed)	None
distribute_method	Literal['Random', 'Poisson Disk']	parameter distribute_method	'RANDOM'

Returns:

Type	Description
Cloud	peer sockets: normal_ (Vector), rotation_ (Rotation)

Source code in core/generated/static_nd.py

@classmethod
def distribute_points_on_faces(cls,
                mesh: Mesh = None,
                selection: Boolean = None,
                distance_min: Float = None,
                density_max: Float = None,
                density: Float = None,
                density_factor: Float = None,
                seed: Integer = None,
                distribute_method: Literal['RANDOM', 'POISSON'] = 'RANDOM'):
    """ > Node Distribute Points on Faces

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    distance_min : Float, optional
        socket 'Distance Min' (id: Distance Min)

    density_max : Float, optional
        socket 'Density Max' (id: Density Max)

    density : Float, optional
        socket 'Density' (id: Density)

    density_factor : Float, optional
        socket 'Density Factor' (id: Density Factor)

    seed : Integer, optional
        socket 'Seed' (id: Seed)

    distribute_method : Literal['Random', 'Poisson Disk']
        parameter `distribute_method`


    Returns
    -------
    Cloud
        peer sockets: normal_ (Vector), rotation_ (Rotation)

    """
    utils.check_enum_arg('Distribute Points on Faces', 'distribute_method', distribute_method, 'distribute_points_on_faces', ('RANDOM', 'POISSON'))
    node = Node('Distribute Points on Faces', {'Mesh': mesh, 'Selection': selection, 'Distance Min': distance_min, 'Density Max': density_max, 'Density': density, 'Density Factor': density_factor, 'Seed': seed}, distribute_method=distribute_method)
    return node._out

domain_size(geometry=None, component='MESH') classmethod

Node Domain Size

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
component	Literal['Mesh', 'Point Cloud', 'Curve', 'Instances', 'Grease Pencil']	parameter component	'MESH'

Returns:

Type	Description
Integer	peer sockets: edge_count_ (Integer), face_count_ (Integer), face_corner_count_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def domain_size(cls,
                geometry: Geometry = None,
                component: Literal['MESH', 'POINTCLOUD', 'CURVE', 'INSTANCES', 'GREASEPENCIL'] = 'MESH'):
    """ > Node Domain Size

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    component : Literal['Mesh', 'Point Cloud', 'Curve', 'Instances', 'Grease Pencil']
        parameter `component`


    Returns
    -------
    Integer
        peer sockets: edge_count_ (Integer), face_count_ (Integer), face_corner_count_ (Integer)

    """
    utils.check_enum_arg('Domain Size', 'component', component, 'domain_size', ('MESH', 'POINTCLOUD', 'CURVE', 'INSTANCES', 'GREASEPENCIL'))
    node = Node('Domain Size', {'Geometry': geometry}, component=component)
    return node._out

dual_mesh(mesh=None, keep_boundaries=None) classmethod

Node Dual Mesh

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
keep_boundaries	Boolean	socket 'Keep Boundaries' (id: Keep Boundaries)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def dual_mesh(cls, mesh: Mesh = None, keep_boundaries: Boolean = None):
    """ > Node Dual Mesh

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    keep_boundaries : Boolean, optional
        socket 'Keep Boundaries' (id: Keep Boundaries)


    Returns
    -------
    Mesh
    """
    node = Node('Dual Mesh', {'Mesh': mesh, 'Keep Boundaries': keep_boundaries})
    return node._out

duplicate_elements(geometry=None, selection=None, amount=None, domain='POINT') classmethod

Node Duplicate Elements

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
amount	Integer	socket 'Amount' (id: Amount)	None
domain	Literal['Point', 'Edge', 'Face', 'Spline', 'Layer', 'Instance']	parameter domain	'POINT'

Returns:

Type	Description
Geometry	peer sockets: duplicate_index_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def duplicate_elements(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                amount: Integer = None,
                domain: Literal['POINT', 'EDGE', 'FACE', 'SPLINE', 'LAYER', 'INSTANCE'] = 'POINT'):
    """ > Node Duplicate Elements

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    amount : Integer, optional
        socket 'Amount' (id: Amount)

    domain : Literal['Point', 'Edge', 'Face', 'Spline', 'Layer', 'Instance']
        parameter `domain`


    Returns
    -------
    Geometry
        peer sockets: duplicate_index_ (Integer)

    """
    utils.check_enum_arg('Duplicate Elements', 'domain', domain, 'duplicate_elements', ('POINT', 'EDGE', 'FACE', 'SPLINE', 'LAYER', 'INSTANCE'))
    node = Node('Duplicate Elements', {'Geometry': geometry, 'Selection': selection, 'Amount': amount}, domain=domain)
    return node._out

edge_angle() classmethod

Node Edge Angle

Returns:

Type	Description
Float	peer sockets: signed_angle_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def edge_angle(cls):
    """ > Node Edge Angle

    Returns
    -------
    Float
        peer sockets: signed_angle_ (Float)

    """
    node = Node('Edge Angle', )
    return node

edge_neighbors()

Node Edge Neighbors

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@utils.classproperty
def edge_neighbors(self):
    """ > Node Edge Neighbors

    Returns
    -------
    Integer
    """
    node = Node('Edge Neighbors', )
    return node._out

edge_paths_to_curves(mesh=None, start_vertices=None, next_vertex_index=None) classmethod

Node Edge Paths to Curves

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
start_vertices	Boolean	socket 'Start Vertices' (id: Start Vertices)	None
next_vertex_index	Integer	socket 'Next Vertex Index' (id: Next Vertex Index)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def edge_paths_to_curves(cls,
                mesh: Mesh = None,
                start_vertices: Boolean = None,
                next_vertex_index: Integer = None):
    """ > Node Edge Paths to Curves

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    start_vertices : Boolean, optional
        socket 'Start Vertices' (id: Start Vertices)

    next_vertex_index : Integer, optional
        socket 'Next Vertex Index' (id: Next Vertex Index)


    Returns
    -------
    Curve
    """
    node = Node('Edge Paths to Curves', {'Mesh': mesh, 'Start Vertices': start_vertices, 'Next Vertex Index': next_vertex_index})
    return node._out

edge_paths_to_selection(start_vertices=None, next_vertex_index=None) classmethod

Node Edge Paths to Selection

Parameters:

Name	Type	Description	Default
start_vertices	Boolean	socket 'Start Vertices' (id: Start Vertices)	None
next_vertex_index	Integer	socket 'Next Vertex Index' (id: Next Vertex Index)	None

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def edge_paths_to_selection(cls, start_vertices: Boolean = None, next_vertex_index: Integer = None):
    """ > Node Edge Paths to Selection

    Parameters
    ----------
    start_vertices : Boolean, optional
        socket 'Start Vertices' (id: Start Vertices)

    next_vertex_index : Integer, optional
        socket 'Next Vertex Index' (id: Next Vertex Index)


    Returns
    -------
    Boolean
    """
    node = Node('Edge Paths to Selection', {'Start Vertices': start_vertices, 'Next Vertex Index': next_vertex_index})
    return node._out

edge_vertices() classmethod

Node Edge Vertices

Returns:

Type	Description
Integer	peer sockets: vertex_index_2_ (Integer), position_1_ (Vector), position_2_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def edge_vertices(cls):
    """ > Node Edge Vertices

    Returns
    -------
    Integer
        peer sockets: vertex_index_2_ (Integer), position_1_ (Vector), position_2_ (Vector)

    """
    node = Node('Edge Vertices', )
    return node

edges_of_corner(corner_index=None) classmethod

Node Edges of Corner

Parameters:

Name	Type	Description	Default
corner_index	Integer	socket 'Corner Index' (id: Corner Index)	None

Returns:

Type	Description
Integer	peer sockets: previous_edge_index_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def edges_of_corner(cls, corner_index: Integer = None):
    """ > Node Edges of Corner

    Parameters
    ----------
    corner_index : Integer, optional
        socket 'Corner Index' (id: Corner Index)


    Returns
    -------
    Integer
        peer sockets: previous_edge_index_ (Integer)

    """
    node = Node('Edges of Corner', {'Corner Index': corner_index})
    return node._out

edges_of_vertex(vertex_index=None, weights=None, sort_index=None) classmethod

Node Edges of Vertex

Parameters:

Name	Type	Description	Default
vertex_index	Integer	socket 'Vertex Index' (id: Vertex Index)	None
weights	Float	socket 'Weights' (id: Weights)	None
sort_index	Integer	socket 'Sort Index' (id: Sort Index)	None

Returns:

Type	Description
Integer	peer sockets: total_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def edges_of_vertex(cls,
                vertex_index: Integer = None,
                weights: Float = None,
                sort_index: Integer = None):
    """ > Node Edges of Vertex

    Parameters
    ----------
    vertex_index : Integer, optional
        socket 'Vertex Index' (id: Vertex Index)

    weights : Float, optional
        socket 'Weights' (id: Weights)

    sort_index : Integer, optional
        socket 'Sort Index' (id: Sort Index)


    Returns
    -------
    Integer
        peer sockets: total_ (Integer)

    """
    node = Node('Edges of Vertex', {'Vertex Index': vertex_index, 'Weights': weights, 'Sort Index': sort_index})
    return node._out

edges_to_face_groups(boundary_edges=None) classmethod

Node Edges to Face Groups

Parameters:

Name	Type	Description	Default
boundary_edges	Boolean	socket 'Boundary Edges' (id: Boundary Edges)	None

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def edges_to_face_groups(cls, boundary_edges: Boolean = None):
    """ > Node Edges to Face Groups

    Parameters
    ----------
    boundary_edges : Boolean, optional
        socket 'Boundary Edges' (id: Boundary Edges)


    Returns
    -------
    Integer
    """
    node = Node('Edges to Face Groups', {'Boundary Edges': boundary_edges})
    return node._out

enable_output(enable=None, value=None, data_type='FLOAT') classmethod

Node Enable Output

Parameters:

Name	Type	Description	Default
enable	Boolean	socket 'Enable' (id: Enable)	None
value	Float	socket 'Value' (id: Value)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def enable_output(cls,
                enable: Boolean = None,
                value: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT'):
    """ > Node Enable Output

    Parameters
    ----------
    enable : Boolean, optional
        socket 'Enable' (id: Enable)

    value : Float, optional
        socket 'Value' (id: Value)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Enable Output', {'Enable': enable, 'Value': value}, data_type=data_type)
    return node._out

endpoint_selection(start_size=None, end_size=None) classmethod

Node Endpoint Selection

Parameters:

Name	Type	Description	Default
start_size	Integer	socket 'Start Size' (id: Start Size)	None
end_size	Integer	socket 'End Size' (id: End Size)	None

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def endpoint_selection(cls, start_size: Integer = None, end_size: Integer = None):
    """ > Node Endpoint Selection

    Parameters
    ----------
    start_size : Integer, optional
        socket 'Start Size' (id: Start Size)

    end_size : Integer, optional
        socket 'End Size' (id: End Size)


    Returns
    -------
    Boolean
    """
    node = Node('Endpoint Selection', {'Start Size': start_size, 'End Size': end_size})
    return node._out

euler_to_rotation(euler=None) classmethod

Node Euler to Rotation

Parameters:

Name	Type	Description	Default
euler	Vector	socket 'Euler' (id: Euler)	None

Returns:

Type	Description
Rotation

Source code in core/generated/static_nd.py

@classmethod
def euler_to_rotation(cls, euler: Vector = None):
    """ > Node Euler to Rotation

    Parameters
    ----------
    euler : Vector, optional
        socket 'Euler' (id: Euler)


    Returns
    -------
    Rotation
    """
    node = Node('Euler to Rotation', {'Euler': euler})
    return node._out

evaluate_at_index(value=None, index=None, data_type='FLOAT', domain='POINT') classmethod

Node Evaluate at Index

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
index	Integer	socket 'Index' (id: Index)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']	parameter data_type	'FLOAT'
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def evaluate_at_index(cls,
                value: Float = None,
                index: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
    """ > Node Evaluate at Index

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    index : Integer, optional
        socket 'Index' (id: Index)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
        parameter `data_type`

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Evaluate at Index', 'domain', domain, 'evaluate_at_index', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Evaluate at Index', {'Value': value, 'Index': index}, data_type=data_type, domain=domain)
    return node._out

evaluate_closure(closure=None, active_input_index=0, active_output_index=0, define_signature=False) classmethod

Node Evaluate Closure

Parameters:

Name	Type	Description	Default
closure	Closure	socket 'Closure' (id: Closure)	None
active_input_index	int	parameter active_input_index	0
active_output_index	int	parameter active_output_index	0
define_signature	bool	parameter define_signature	False

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@classmethod
def evaluate_closure(cls,
                closure: Closure = None,
                active_input_index = 0,
                active_output_index = 0,
                define_signature = False):
    """ > Node Evaluate Closure

    Parameters
    ----------
    closure : Closure, optional
        socket 'Closure' (id: Closure)

    active_input_index : int
        parameter `active_input_index`

    active_output_index : int
        parameter `active_output_index`

    define_signature : bool
        parameter `define_signature`


    Returns
    -------
    None
    """
    node = Node('Evaluate Closure', {'Closure': closure}, active_input_index=active_input_index, active_output_index=active_output_index, define_signature=define_signature)
    return node._out

evaluate_on_domain(value=None, data_type='FLOAT', domain='POINT') classmethod

Node Evaluate on Domain

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']	parameter data_type	'FLOAT'
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def evaluate_on_domain(cls,
                value: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
    """ > Node Evaluate on Domain

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
        parameter `data_type`

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Evaluate on Domain', 'domain', domain, 'evaluate_on_domain', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Evaluate on Domain', {'Value': value}, data_type=data_type, domain=domain)
    return node._out

extrude_mesh(mesh=None, selection=None, offset=None, offset_scale=None, individual=None, mode='FACES') classmethod

Node Extrude Mesh

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
offset	Vector	socket 'Offset' (id: Offset)	None
offset_scale	Float	socket 'Offset Scale' (id: Offset Scale)	None
individual	Boolean	socket 'Individual' (id: Individual)	None
mode	Literal['Vertices', 'Edges', 'Faces']	parameter mode	'FACES'

Returns:

Type	Description
Mesh	peer sockets: top_ (Boolean), side_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def extrude_mesh(cls,
                mesh: Mesh = None,
                selection: Boolean = None,
                offset: Vector = None,
                offset_scale: Float = None,
                individual: Boolean = None,
                mode: Literal['VERTICES', 'EDGES', 'FACES'] = 'FACES'):
    """ > Node Extrude Mesh

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    offset : Vector, optional
        socket 'Offset' (id: Offset)

    offset_scale : Float, optional
        socket 'Offset Scale' (id: Offset Scale)

    individual : Boolean, optional
        socket 'Individual' (id: Individual)

    mode : Literal['Vertices', 'Edges', 'Faces']
        parameter `mode`


    Returns
    -------
    Mesh
        peer sockets: top_ (Boolean), side_ (Boolean)

    """
    utils.check_enum_arg('Extrude Mesh', 'mode', mode, 'extrude_mesh', ('VERTICES', 'EDGES', 'FACES'))
    node = Node('Extrude Mesh', {'Mesh': mesh, 'Selection': selection, 'Offset': offset, 'Offset Scale': offset_scale, 'Individual': individual}, mode=mode)
    return node._out

face_area()

Node Face Area

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@utils.classproperty
def face_area(self):
    """ > Node Face Area

    Returns
    -------
    Float
    """
    node = Node('Face Area', )
    return node._out

face_group_boundaries(face_group_id=None) classmethod

Node Face Group Boundaries

Parameters:

Name	Type	Description	Default
face_group_id	Integer	socket 'Face Group ID' (id: Face Set)	None

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def face_group_boundaries(cls, face_group_id: Integer = None):
    """ > Node Face Group Boundaries

    Parameters
    ----------
    face_group_id : Integer, optional
        socket 'Face Group ID' (id: Face Set)


    Returns
    -------
    Boolean
    """
    node = Node('Face Group Boundaries', {'Face Set': face_group_id})
    return node._out

face_neighbors() classmethod

Node Face Neighbors

Returns:

Type	Description
Integer	peer sockets: face_count_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def face_neighbors(cls):
    """ > Node Face Neighbors

    Returns
    -------
    Integer
        peer sockets: face_count_ (Integer)

    """
    node = Node('Face Neighbors', )
    return node

face_of_corner(corner_index=None) classmethod

Node Face of Corner

Parameters:

Name	Type	Description	Default
corner_index	Integer	socket 'Corner Index' (id: Corner Index)	None

Returns:

Type	Description
Integer	peer sockets: index_in_face_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def face_of_corner(cls, corner_index: Integer = None):
    """ > Node Face of Corner

    Parameters
    ----------
    corner_index : Integer, optional
        socket 'Corner Index' (id: Corner Index)


    Returns
    -------
    Integer
        peer sockets: index_in_face_ (Integer)

    """
    node = Node('Face of Corner', {'Corner Index': corner_index})
    return node._out

face_set() classmethod

Node Face Set

Returns:

Type	Description
Integer	peer sockets: exists_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def face_set(cls):
    """ > Node Face Set

    Returns
    -------
    Integer
        peer sockets: exists_ (Boolean)

    """
    node = Node('Face Set', )
    return node

field_average(value=None, group_id=None, data_type='FLOAT', domain='POINT') classmethod

Node Field Average

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
group_id	Integer	socket 'Group ID' (id: Group Index)	None
data_type	Literal['Float', 'Vector']	parameter data_type	'FLOAT'
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Float	peer sockets: median_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def field_average(cls,
                value: Float = None,
                group_id: Integer = None,
                data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
    """ > Node Field Average

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    group_id : Integer, optional
        socket 'Group ID' (id: Group Index)

    data_type : Literal['Float', 'Vector']
        parameter `data_type`

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Float
        peer sockets: median_ (Float)

    """
    utils.check_enum_arg('Field Average', 'domain', domain, 'field_average', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Field Average', {'Value': value, 'Group Index': group_id}, data_type=data_type, domain=domain)
    return node._out

field_min_max(value=None, group_id=None, data_type='FLOAT', domain='POINT') classmethod

Node Field Min & Max

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
group_id	Integer	socket 'Group ID' (id: Group Index)	None
data_type	Literal['Float', 'Integer', 'Vector']	parameter data_type	'FLOAT'
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Float	peer sockets: max_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def field_min_max(cls,
                value: Float = None,
                group_id: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'FLOAT_VECTOR'] = 'FLOAT',
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
    """ > Node Field Min & Max

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    group_id : Integer, optional
        socket 'Group ID' (id: Group Index)

    data_type : Literal['Float', 'Integer', 'Vector']
        parameter `data_type`

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Float
        peer sockets: max_ (Float)

    """
    utils.check_enum_arg('Field Min & Max', 'domain', domain, 'field_min_max', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Field Min & Max', {'Value': value, 'Group Index': group_id}, data_type=data_type, domain=domain)
    return node._out

field_to_grid(named_sockets={}, topology=None, data_type='FLOAT', **sockets) classmethod

Node Field to Grid

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
topology	Float	socket 'Topology' (id: Topology)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@classmethod
def field_to_grid(cls,
                named_sockets: dict = {},
                topology: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT',
                **sockets):
    """ > Node Field to Grid

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    topology : Float, optional
        socket 'Topology' (id: Topology)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    None
    """
    node = Node('Field to Grid', {'Topology': topology, **named_sockets}, data_type=data_type, **sockets)
    return node._out

field_to_list(named_sockets={}, count=None, **sockets) classmethod

Node Field to List

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
count	Integer	socket 'Count' (id: Count)	None
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@classmethod
def field_to_list(cls, named_sockets: dict = {}, count: Integer = None, **sockets):
    """ > Node Field to List

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    count : Integer, optional
        socket 'Count' (id: Count)

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    None
    """
    node = Node('Field to List', {'Count': count, **named_sockets}, **sockets)
    return node._out

field_variance(value=None, group_id=None, data_type='FLOAT', domain='POINT') classmethod

Node Field Variance

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
group_id	Integer	socket 'Group ID' (id: Group Index)	None
data_type	Literal['Float', 'Vector']	parameter data_type	'FLOAT'
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Float	peer sockets: variance_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def field_variance(cls,
                value: Float = None,
                group_id: Integer = None,
                data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
    """ > Node Field Variance

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    group_id : Integer, optional
        socket 'Group ID' (id: Group Index)

    data_type : Literal['Float', 'Vector']
        parameter `data_type`

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Float
        peer sockets: variance_ (Float)

    """
    utils.check_enum_arg('Field Variance', 'domain', domain, 'field_variance', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Field Variance', {'Value': value, 'Group Index': group_id}, data_type=data_type, domain=domain)
    return node._out

fill_curve(curve=None, group_id=None, mode=None, fill_rule=None) classmethod

Node Fill Curve

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
group_id	Integer	socket 'Group ID' (id: Group ID)	None
mode	menu='Triangles'	('Triangles', 'N-gons')	None
fill_rule	menu='Even-Odd'	('Even-Odd', 'Non-Zero')	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def fill_curve(cls,
                curve: Curve = None,
                group_id: Integer = None,
                mode: Literal['Triangles', 'N-gons'] = None,
                fill_rule: Literal['Even-Odd', 'Non-Zero'] = None):
    """ > Node Fill Curve

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    group_id : Integer, optional
        socket 'Group ID' (id: Group ID)

    mode : menu='Triangles', optional
        ('Triangles', 'N-gons')

    fill_rule : menu='Even-Odd', optional
        ('Even-Odd', 'Non-Zero')


    Returns
    -------
    Mesh
    """
    node = Node('Fill Curve', {'Curve': curve, 'Group ID': group_id, 'Mode': mode, 'Fill Rule': fill_rule})
    return node._out

fillet_curve(curve=None, radius=None, limit_radius=None, mode=None, count=None) classmethod

Node Fillet Curve

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
radius	Float	socket 'Radius' (id: Radius)	None
limit_radius	Boolean	socket 'Limit Radius' (id: Limit Radius)	None
mode	menu='Bézier'	('Bézier', 'Poly')	None
count	Integer	socket 'Count' (id: Count)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def fillet_curve(cls,
                curve: Curve = None,
                radius: Float = None,
                limit_radius: Boolean = None,
                mode: Literal['Bézier', 'Poly'] = None,
                count: Integer = None):
    """ > Node Fillet Curve

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    radius : Float, optional
        socket 'Radius' (id: Radius)

    limit_radius : Boolean, optional
        socket 'Limit Radius' (id: Limit Radius)

    mode : menu='Bézier', optional
        ('Bézier', 'Poly')

    count : Integer, optional
        socket 'Count' (id: Count)


    Returns
    -------
    Curve
    """
    node = Node('Fillet Curve', {'Curve': curve, 'Radius': radius, 'Limit Radius': limit_radius, 'Mode': mode, 'Count': count})
    return node._out

find_in_string(string=None, search=None) classmethod

Node Find in String

Parameters:

Name	Type	Description	Default
string	String	socket 'String' (id: String)	None
search	String	socket 'Search' (id: Search)	None

Returns:

Type	Description
Integer	peer sockets: count_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def find_in_string(cls, string: String = None, search: String = None):
    """ > Node Find in String

    Parameters
    ----------
    string : String, optional
        socket 'String' (id: String)

    search : String, optional
        socket 'Search' (id: Search)


    Returns
    -------
    Integer
        peer sockets: count_ (Integer)

    """
    node = Node('Find in String', {'String': string, 'Search': search})
    return node._out

flip_faces(mesh=None, selection=None) classmethod

Node Flip Faces

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
selection	Boolean	socket 'Selection' (id: Selection)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def flip_faces(cls, mesh: Mesh = None, selection: Boolean = None):
    """ > Node Flip Faces

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)


    Returns
    -------
    Mesh
    """
    node = Node('Flip Faces', {'Mesh': mesh, 'Selection': selection})
    return node._out

float_curve(value=None, factor=None) classmethod

Node Float Curve

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
factor	Float	socket 'Factor' (id: Factor)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def float_curve(cls, value: Float = None, factor: Float = None):
    """ > Node Float Curve

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    factor : Float, optional
        socket 'Factor' (id: Factor)


    Returns
    -------
    Float
    """
    node = NodeCurves('Float Curve', {'Value': value, 'Factor': factor})
    return node._out

float_to_integer(float=None, rounding_mode='ROUND') classmethod

Node Float to Integer

Parameters:

Name	Type	Description	Default
float	Float	socket 'Float' (id: Float)	None
rounding_mode	Literal['Round', 'Floor', 'Ceiling', 'Truncate']	parameter rounding_mode	'ROUND'

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def float_to_integer(cls,
                float: Float = None,
                rounding_mode: Literal['ROUND', 'FLOOR', 'CEILING', 'TRUNCATE'] = 'ROUND'):
    """ > Node Float to Integer

    Parameters
    ----------
    float : Float, optional
        socket 'Float' (id: Float)

    rounding_mode : Literal['Round', 'Floor', 'Ceiling', 'Truncate']
        parameter `rounding_mode`


    Returns
    -------
    Integer
    """
    utils.check_enum_arg('Float to Integer', 'rounding_mode', rounding_mode, 'float_to_integer', ('ROUND', 'FLOOR', 'CEILING', 'TRUNCATE'))
    node = Node('Float to Integer', {'Float': float}, rounding_mode=rounding_mode)
    return node._out

for_each_geometry_element_input(geometry=None, selection=None) classmethod

Node For Each Geometry Element Input

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def for_each_geometry_element_input(cls, geometry: Geometry = None, selection: Boolean = None):
    """ > Node For Each Geometry Element Input

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)


    Returns
    -------
    Integer
    """
    node = Node('For Each Geometry Element Input', {'Geometry': geometry, 'Selection': selection})
    return node._out

for_each_geometry_element_output(geometry=None, active_generation_index=0, active_input_index=0, active_main_index=0, domain='POINT', inspection_index=0) classmethod

Node For Each Geometry Element Output

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Generation_0)	None
active_generation_index	int	parameter active_generation_index	0
active_input_index	int	parameter active_input_index	0
active_main_index	int	parameter active_main_index	0
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'
inspection_index	int	parameter inspection_index	0

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def for_each_geometry_element_output(cls,
                geometry: Geometry = None,
                active_generation_index = 0,
                active_input_index = 0,
                active_main_index = 0,
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT',
                inspection_index = 0):
    """ > Node For Each Geometry Element Output

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Generation_0)

    active_generation_index : int
        parameter `active_generation_index`

    active_input_index : int
        parameter `active_input_index`

    active_main_index : int
        parameter `active_main_index`

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`

    inspection_index : int
        parameter `inspection_index`


    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('For Each Geometry Element Output', 'domain', domain, 'for_each_geometry_element_output', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('For Each Geometry Element Output', {'Generation_0': geometry}, active_generation_index=active_generation_index, active_input_index=active_input_index, active_main_index=active_main_index, domain=domain, inspection_index=inspection_index)
    return node._out

format_string(named_sockets={}, format=None, **sockets) classmethod

Node Format String

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
format	String	socket 'Format' (id: Format)	None
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
String

Source code in core/generated/static_nd.py

@classmethod
def format_string(cls, named_sockets: dict = {}, format: String = None, **sockets):
    """ > Node Format String

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    format : String, optional
        socket 'Format' (id: Format)

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    String
    """
    node = Node('Format String', {'Format': format, **named_sockets}, **sockets)
    return node._out

frame(label_size=20, shrink=True, text=None) classmethod

Node Frame

Parameters:

Name	Type	Description	Default
label_size	int	parameter label_size	20
shrink	bool	parameter shrink	True
text	NoneType	parameter text	None

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@classmethod
def frame(cls, label_size = 20, shrink = True, text = None):
    """ > Node Frame

    Parameters
    ----------
    label_size : int
        parameter `label_size`

    shrink : bool
        parameter `shrink`

    text : NoneType
        parameter `text`


    Returns
    -------
    None
    """
    node = Node('Frame', label_size=label_size, shrink=shrink, text=text)
    return node._out

gabor_texture(vector=None, scale=None, frequency=None, anisotropy=None, orientation=None, orientation_1=None, gabor_type='2D') classmethod

Node Gabor Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
scale	Float	socket 'Scale' (id: Scale)	None
frequency	Float	socket 'Frequency' (id: Frequency)	None
anisotropy	Float	socket 'Anisotropy' (id: Anisotropy)	None
orientation	Float	socket 'Orientation' (id: Orientation 2D)	None
orientation_1	Vector	socket 'Orientation' (id: Orientation 3D)	None
gabor_type	Literal['2D', '3D']	parameter gabor_type	'2D'

Returns:

Type	Description
Float	peer sockets: phase_ (Float), intensity_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def gabor_texture(cls,
                vector: Vector = None,
                scale: Float = None,
                frequency: Float = None,
                anisotropy: Float = None,
                orientation: Float = None,
                orientation_1: Vector = None,
                gabor_type: Literal['2D', '3D'] = '2D'):
    """ > Node Gabor Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    frequency : Float, optional
        socket 'Frequency' (id: Frequency)

    anisotropy : Float, optional
        socket 'Anisotropy' (id: Anisotropy)

    orientation : Float, optional
        socket 'Orientation' (id: Orientation 2D)

    orientation_1 : Vector, optional
        socket 'Orientation' (id: Orientation 3D)

    gabor_type : Literal['2D', '3D']
        parameter `gabor_type`


    Returns
    -------
    Float
        peer sockets: phase_ (Float), intensity_ (Float)

    """
    utils.check_enum_arg('Gabor Texture', 'gabor_type', gabor_type, 'gabor_texture', ('2D', '3D'))
    node = Node('Gabor Texture', {'Vector': vector, 'Scale': scale, 'Frequency': frequency, 'Anisotropy': anisotropy, 'Orientation 2D': orientation, 'Orientation 3D': orientation_1}, gabor_type=gabor_type)
    return node._out

gamma(color=None, gamma=None) classmethod

Node Gamma

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
gamma	Float	socket 'Gamma' (id: Gamma)	None

Returns:

Type	Description
Color

Source code in core/generated/static_nd.py

@classmethod
def gamma(cls, color: Color = None, gamma: Float = None):
    """ > Node Gamma

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    gamma : Float, optional
        socket 'Gamma' (id: Gamma)


    Returns
    -------
    Color
    """
    node = Node('Gamma', {'Color': color, 'Gamma': gamma})
    return node._out

geometry_proximity(geometry=None, group_id=None, sample_position=None, sample_group_id=None, target_element='FACES') classmethod

Node Geometry Proximity

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Target)	None
group_id	Integer	socket 'Group ID' (id: Group ID)	None
sample_position	Vector	socket 'Sample Position' (id: Source Position)	None
sample_group_id	Integer	socket 'Sample Group ID' (id: Sample Group ID)	None
target_element	Literal['Points', 'Edges', 'Faces']	parameter target_element	'FACES'

Returns:

Type	Description
Vector	peer sockets: distance_ (Float), is_valid_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def geometry_proximity(cls,
                geometry: Geometry = None,
                group_id: Integer = None,
                sample_position: Vector = None,
                sample_group_id: Integer = None,
                target_element: Literal['POINTS', 'EDGES', 'FACES'] = 'FACES'):
    """ > Node Geometry Proximity

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Target)

    group_id : Integer, optional
        socket 'Group ID' (id: Group ID)

    sample_position : Vector, optional
        socket 'Sample Position' (id: Source Position)

    sample_group_id : Integer, optional
        socket 'Sample Group ID' (id: Sample Group ID)

    target_element : Literal['Points', 'Edges', 'Faces']
        parameter `target_element`


    Returns
    -------
    Vector
        peer sockets: distance_ (Float), is_valid_ (Boolean)

    """
    utils.check_enum_arg('Geometry Proximity', 'target_element', target_element, 'geometry_proximity', ('POINTS', 'EDGES', 'FACES'))
    node = Node('Geometry Proximity', {'Target': geometry, 'Group ID': group_id, 'Source Position': sample_position, 'Sample Group ID': sample_group_id}, target_element=target_element)
    return node._out

geometry_to_instance(*geometry) classmethod

Node Geometry to Instance

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	()

Returns:

Type	Description
Instances

Source code in core/generated/static_nd.py

@classmethod
def geometry_to_instance(cls, *geometry: Geometry):
    """ > Node Geometry to Instance

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)


    Returns
    -------
    Instances
    """
    node = Node('Geometry to Instance', {'Geometry': list(geometry)})
    return node._out

get_bundle_item(bundle=None, path=None, remove=None, socket_type='FLOAT', structure_type='AUTO') classmethod

Node Get Bundle Item

Parameters:

Name	Type	Description	Default
bundle	Bundle	socket 'Bundle' (id: Bundle)	None
path	String	socket 'Path' (id: Path)	None
remove	Boolean	socket 'Remove' (id: Remove)	None
socket_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']	parameter socket_type	'FLOAT'
structure_type	Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']	parameter structure_type	'AUTO'

Returns:

Type	Description
Bundle	peer sockets: item_ (Float), exists_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def get_bundle_item(cls,
                bundle: Bundle = None,
                path: String = None,
                remove: Boolean = None,
                socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
                structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO'):
    """ > Node Get Bundle Item

    Parameters
    ----------
    bundle : Bundle, optional
        socket 'Bundle' (id: Bundle)

    path : String, optional
        socket 'Path' (id: Path)

    remove : Boolean, optional
        socket 'Remove' (id: Remove)

    socket_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
        parameter `socket_type`

    structure_type : Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']
        parameter `structure_type`


    Returns
    -------
    Bundle
        peer sockets: item_ (Float), exists_ (Boolean)

    """
    utils.check_enum_arg('Get Bundle Item', 'socket_type', socket_type, 'get_bundle_item', ('FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'))
    utils.check_enum_arg('Get Bundle Item', 'structure_type', structure_type, 'get_bundle_item', ('AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'))
    node = Node('Get Bundle Item', {'Bundle': bundle, 'Path': path, 'Remove': remove}, socket_type=socket_type, structure_type=structure_type)
    return node._out

get_geometry_bundle(geometry=None, remove=None) classmethod

Node Get Geometry Bundle

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
remove	Boolean	socket 'Remove' (id: Remove)	None

Returns:

Type	Description
Geometry	peer sockets: bundle_ (Bundle)

Source code in core/generated/static_nd.py

@classmethod
def get_geometry_bundle(cls, geometry: Geometry = None, remove: Boolean = None):
    """ > Node Get Geometry Bundle

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    remove : Boolean, optional
        socket 'Remove' (id: Remove)


    Returns
    -------
    Geometry
        peer sockets: bundle_ (Bundle)

    """
    node = Node('Get Geometry Bundle', {'Geometry': geometry, 'Remove': remove})
    return node._out

get_list_item(list=None, index=None, socket_type='FLOAT', structure_type='AUTO') classmethod

Node Get List Item

Parameters:

Name	Type	Description	Default
list	Float	socket 'List' (id: List)	None
index	Integer	socket 'Index' (id: Index)	None
socket_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']	parameter socket_type	'FLOAT'
structure_type	Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']	parameter structure_type	'AUTO'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def get_list_item(cls,
                list: Float = None,
                index: Integer = None,
                socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
                structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO'):
    """ > Node Get List Item

    Parameters
    ----------
    list : Float, optional
        socket 'List' (id: List)

    index : Integer, optional
        socket 'Index' (id: Index)

    socket_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
        parameter `socket_type`

    structure_type : Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']
        parameter `structure_type`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Get List Item', 'socket_type', socket_type, 'get_list_item', ('FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'))
    utils.check_enum_arg('Get List Item', 'structure_type', structure_type, 'get_list_item', ('AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'))
    node = Node('Get List Item', {'List': list, 'Index': index}, socket_type=socket_type, structure_type=structure_type)
    return node._out

get_named_grid(volume=None, name=None, remove=None, data_type='FLOAT') classmethod

Node Get Named Grid

Parameters:

Name	Type	Description	Default
volume	Volume	socket 'Volume' (id: Volume)	None
name	String	socket 'Name' (id: Name)	None
remove	Boolean	socket 'Remove' (id: Remove)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Volume	peer sockets: grid_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def get_named_grid(cls,
                volume: Volume = None,
                name: String = None,
                remove: Boolean = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Get Named Grid

    Parameters
    ----------
    volume : Volume, optional
        socket 'Volume' (id: Volume)

    name : String, optional
        socket 'Name' (id: Name)

    remove : Boolean, optional
        socket 'Remove' (id: Remove)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Volume
        peer sockets: grid_ (Float)

    """
    node = Node('Get Named Grid', {'Volume': volume, 'Name': name, 'Remove': remove}, data_type=data_type)
    return node._out

gradient_texture(vector=None, gradient_type='LINEAR') classmethod

Node Gradient Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
gradient_type	Literal['Linear', 'Quadratic', 'Easing', 'Diagonal', 'Spherical', 'Quadratic Sphere', 'Radial']	parameter gradient_type	'LINEAR'

Returns:

Type	Description
Color	peer sockets: factor_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def gradient_texture(cls,
                vector: Vector = None,
                gradient_type: Literal['LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'] = 'LINEAR'):
    """ > Node Gradient Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    gradient_type : Literal['Linear', 'Quadratic', 'Easing', 'Diagonal', 'Spherical', 'Quadratic Sphere', 'Radial']
        parameter `gradient_type`


    Returns
    -------
    Color
        peer sockets: factor_ (Float)

    """
    utils.check_enum_arg('Gradient Texture', 'gradient_type', gradient_type, 'gradient_texture', ('LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'))
    node = Node('Gradient Texture', {'Vector': vector}, gradient_type=gradient_type)
    return node._out

grease_pencil_to_curves(grease_pencil=None, selection=None, layers_as_instances=None) classmethod

Node Grease Pencil to Curves

Parameters:

Name	Type	Description	Default
grease_pencil	GreasePencil	socket 'Grease Pencil' (id: Grease Pencil)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
layers_as_instances	Boolean	socket 'Layers as Instances' (id: Layers as Instances)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def grease_pencil_to_curves(cls,
                grease_pencil: GreasePencil = None,
                selection: Boolean = None,
                layers_as_instances: Boolean = None):
    """ > Node Grease Pencil to Curves

    Parameters
    ----------
    grease_pencil : GreasePencil, optional
        socket 'Grease Pencil' (id: Grease Pencil)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    layers_as_instances : Boolean, optional
        socket 'Layers as Instances' (id: Layers as Instances)


    Returns
    -------
    Curve
    """
    node = Node('Grease Pencil to Curves', {'Grease Pencil': grease_pencil, 'Selection': selection, 'Layers as Instances': layers_as_instances})
    return node._out

grid(size_x=None, size_y=None, vertices_x=None, vertices_y=None) classmethod

Node Grid

Parameters:

Name	Type	Description	Default
size_x	Float	socket 'Size X' (id: Size X)	None
size_y	Float	socket 'Size Y' (id: Size Y)	None
vertices_x	Integer	socket 'Vertices X' (id: Vertices X)	None
vertices_y	Integer	socket 'Vertices Y' (id: Vertices Y)	None

Returns:

Type	Description
Mesh	peer sockets: uv_map_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def grid(cls,
                size_x: Float = None,
                size_y: Float = None,
                vertices_x: Integer = None,
                vertices_y: Integer = None):
    """ > Node Grid

    Parameters
    ----------
    size_x : Float, optional
        socket 'Size X' (id: Size X)

    size_y : Float, optional
        socket 'Size Y' (id: Size Y)

    vertices_x : Integer, optional
        socket 'Vertices X' (id: Vertices X)

    vertices_y : Integer, optional
        socket 'Vertices Y' (id: Vertices Y)


    Returns
    -------
    Mesh
        peer sockets: uv_map_ (Vector)

    """
    node = Node('Grid', {'Size X': size_x, 'Size Y': size_y, 'Vertices X': vertices_x, 'Vertices Y': vertices_y})
    return node._out

grid_curl(grid=None) classmethod

Node Grid Curl

Parameters:

Name	Type	Description	Default
grid	Vector	socket 'Grid' (id: Grid)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def grid_curl(cls, grid: Vector = None):
    """ > Node Grid Curl

    Parameters
    ----------
    grid : Vector, optional
        socket 'Grid' (id: Grid)


    Returns
    -------
    Vector
    """
    node = Node('Grid Curl', {'Grid': grid})
    return node._out

grid_dilate_erode(grid=None, connectivity=None, tiles=None, steps=None, data_type='FLOAT') classmethod

Node Grid Dilate & Erode

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
connectivity	menu='Face'	('Face', 'Edge', 'Vertex')	None
tiles	menu='Preserve'	('Ignore', 'Expand', 'Preserve')	None
steps	Integer	socket 'Steps' (id: Steps)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def grid_dilate_erode(cls,
                grid: Float = None,
                connectivity: Literal['Face', 'Edge', 'Vertex'] = None,
                tiles: Literal['Ignore', 'Expand', 'Preserve'] = None,
                steps: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Grid Dilate & Erode

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    connectivity : menu='Face', optional
        ('Face', 'Edge', 'Vertex')

    tiles : menu='Preserve', optional
        ('Ignore', 'Expand', 'Preserve')

    steps : Integer, optional
        socket 'Steps' (id: Steps)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Grid Dilate & Erode', {'Grid': grid, 'Connectivity': connectivity, 'Tiles': tiles, 'Steps': steps}, data_type=data_type)
    return node._out

grid_divergence(grid=None) classmethod

Node Grid Divergence

Parameters:

Name	Type	Description	Default
grid	Vector	socket 'Grid' (id: Grid)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def grid_divergence(cls, grid: Vector = None):
    """ > Node Grid Divergence

    Parameters
    ----------
    grid : Vector, optional
        socket 'Grid' (id: Grid)


    Returns
    -------
    Float
    """
    node = Node('Grid Divergence', {'Grid': grid})
    return node._out

grid_gradient(grid=None) classmethod

Node Grid Gradient

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def grid_gradient(cls, grid: Float = None):
    """ > Node Grid Gradient

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)


    Returns
    -------
    Vector
    """
    node = Node('Grid Gradient', {'Grid': grid})
    return node._out

grid_info(grid=None, data_type='FLOAT') classmethod

Node Grid Info

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Matrix	peer sockets: background_value_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def grid_info(cls,
                grid: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Grid Info

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Matrix
        peer sockets: background_value_ (Float)

    """
    node = Node('Grid Info', {'Grid': grid}, data_type=data_type)
    return node._out

grid_laplacian(grid=None) classmethod

Node Grid Laplacian

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def grid_laplacian(cls, grid: Float = None):
    """ > Node Grid Laplacian

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)


    Returns
    -------
    Float
    """
    node = Node('Grid Laplacian', {'Grid': grid})
    return node._out

grid_mean(grid=None, width=None, iterations=None, data_type='FLOAT') classmethod

Node Grid Mean

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
width	Integer	socket 'Width' (id: Width)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None
data_type	Literal['Float', 'Integer', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def grid_mean(cls,
                grid: Float = None,
                width: Integer = None,
                iterations: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'VECTOR'] = 'FLOAT'):
    """ > Node Grid Mean

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    width : Integer, optional
        socket 'Width' (id: Width)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)

    data_type : Literal['Float', 'Integer', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Grid Mean', {'Grid': grid, 'Width': width, 'Iterations': iterations}, data_type=data_type)
    return node._out

grid_median(grid=None, width=None, iterations=None, data_type='FLOAT') classmethod

Node Grid Median

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
width	Integer	socket 'Width' (id: Width)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None
data_type	Literal['Float', 'Integer', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def grid_median(cls,
                grid: Float = None,
                width: Integer = None,
                iterations: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'VECTOR'] = 'FLOAT'):
    """ > Node Grid Median

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    width : Integer, optional
        socket 'Width' (id: Width)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)

    data_type : Literal['Float', 'Integer', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Grid Median', {'Grid': grid, 'Width': width, 'Iterations': iterations}, data_type=data_type)
    return node._out

grid_to_mesh(grid=None, threshold=None, adaptivity=None) classmethod

Node Grid to Mesh

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
threshold	Float	socket 'Threshold' (id: Threshold)	None
adaptivity	Float	socket 'Adaptivity' (id: Adaptivity)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def grid_to_mesh(cls, grid: Float = None, threshold: Float = None, adaptivity: Float = None):
    """ > Node Grid to Mesh

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    threshold : Float, optional
        socket 'Threshold' (id: Threshold)

    adaptivity : Float, optional
        socket 'Adaptivity' (id: Adaptivity)


    Returns
    -------
    Mesh
    """
    node = Node('Grid to Mesh', {'Grid': grid, 'Threshold': threshold, 'Adaptivity': adaptivity})
    return node._out

grid_to_points(grid=None, data_type='FLOAT') classmethod

Node Grid to Points

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Cloud	peer sockets: value_ (Float), x_ (Integer), y_ (Integer), z_ (Integer), is_tile_ (Boolean), extent_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def grid_to_points(cls,
                grid: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Grid to Points

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Cloud
        peer sockets: value_ (Float), x_ (Integer), y_ (Integer), z_ (Integer), is_tile_ (Boolean), extent_ (Integer)

    """
    node = Node('Grid to Points', {'Grid': grid}, data_type=data_type)
    return node._out

group(node_tree=None) classmethod

Node Group

Parameters:

Name	Type	Description	Default
node_tree	NoneType	parameter node_tree	None

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@classmethod
def group(cls, node_tree = None):
    """ > Node Group

    Parameters
    ----------
    node_tree : NoneType
        parameter `node_tree`


    Returns
    -------
    None
    """
    node = Node('Group', node_tree=node_tree)
    return node._out

group_input()

Node Group Input

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@utils.classproperty
def group_input(self):
    """ > Node Group Input

    Returns
    -------
    None
    """
    node = Node('Group Input', )
    return node._out

group_output(is_active_output=True) classmethod

Node Group Output

Parameters:

Name	Type	Description	Default
is_active_output	bool	parameter is_active_output	True

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@classmethod
def group_output(cls, is_active_output = True):
    """ > Node Group Output

    Parameters
    ----------
    is_active_output : bool
        parameter `is_active_output`


    Returns
    -------
    None
    """
    node = Node('Group Output', is_active_output=is_active_output)
    return node._out

handle_type_selection(handle_type='AUTO', mode={'LEFT', 'RIGHT'}) classmethod

Node Handle Type Selection

Parameters:

Name	Type	Description	Default
handle_type	Literal['Free', 'Auto', 'Vector', 'Align']	parameter handle_type	'AUTO'
mode	set	parameter mode	{'LEFT', 'RIGHT'}

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def handle_type_selection(cls,
                handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO',
                mode = {'LEFT', 'RIGHT'}):
    """ > Node Handle Type Selection

    Parameters
    ----------
    handle_type : Literal['Free', 'Auto', 'Vector', 'Align']
        parameter `handle_type`

    mode : set
        parameter `mode`


    Returns
    -------
    Boolean
    """
    utils.check_enum_arg('Handle Type Selection', 'handle_type', handle_type, 'handle_type_selection', ('FREE', 'AUTO', 'VECTOR', 'ALIGN'))
    node = Node('Handle Type Selection', handle_type=handle_type, mode=mode)
    return node._out

hash_value(value=None, seed=None, data_type='INT') classmethod

Node Hash Value

Parameters:

Name	Type	Description	Default
value	Integer	socket 'Value' (id: Value)	None
seed	Integer	socket 'Seed' (id: Seed)	None
data_type	Literal['Float', 'Integer', 'Vector', 'Color', 'Rotation', 'Matrix', 'String']	parameter data_type	'INT'

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def hash_value(cls,
                value: Integer = None,
                seed: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING'] = 'INT'):
    """ > Node Hash Value

    Parameters
    ----------
    value : Integer, optional
        socket 'Value' (id: Value)

    seed : Integer, optional
        socket 'Seed' (id: Seed)

    data_type : Literal['Float', 'Integer', 'Vector', 'Color', 'Rotation', 'Matrix', 'String']
        parameter `data_type`


    Returns
    -------
    Integer
    """
    node = Node('Hash Value', {'Value': value, 'Seed': seed}, data_type=data_type)
    return node._out

ico_sphere(radius=None, subdivisions=None) classmethod

Node Ico Sphere

Parameters:

Name	Type	Description	Default
radius	Float	socket 'Radius' (id: Radius)	None
subdivisions	Integer	socket 'Subdivisions' (id: Subdivisions)	None

Returns:

Type	Description
Mesh	peer sockets: uv_map_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def ico_sphere(cls, radius: Float = None, subdivisions: Integer = None):
    """ > Node Ico Sphere

    Parameters
    ----------
    radius : Float, optional
        socket 'Radius' (id: Radius)

    subdivisions : Integer, optional
        socket 'Subdivisions' (id: Subdivisions)


    Returns
    -------
    Mesh
        peer sockets: uv_map_ (Vector)

    """
    node = Node('Ico Sphere', {'Radius': radius, 'Subdivisions': subdivisions})
    return node._out

id()

Node ID

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@utils.classproperty
def id(self):
    """ > Node ID

    Returns
    -------
    Integer
    """
    node = Node('ID', )
    return node._out

image(image=None) classmethod

Node Image

Parameters:

Name	Type	Description	Default
image	NoneType	parameter image	None

Returns:

Type	Description
Image

Source code in core/generated/static_nd.py

@classmethod
def image(cls, image = None):
    """ > Node Image

    Parameters
    ----------
    image : NoneType
        parameter `image`


    Returns
    -------
    Image
    """
    node = Node('Image', image=image)
    return node._out

image_info(image=None, frame=None) classmethod

Node Image Info

Parameters:

Name	Type	Description	Default
image	Image	socket 'Image' (id: Image)	None
frame	Integer	socket 'Frame' (id: Frame)	None

Returns:

Type	Description
Integer	peer sockets: height_ (Integer), has_alpha_ (Boolean), frame_count_ (Integer), fps_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def image_info(cls, image: Image = None, frame: Integer = None):
    """ > Node Image Info

    Parameters
    ----------
    image : Image, optional
        socket 'Image' (id: Image)

    frame : Integer, optional
        socket 'Frame' (id: Frame)


    Returns
    -------
    Integer
        peer sockets: height_ (Integer), has_alpha_ (Boolean), frame_count_ (Integer), fps_ (Float)

    """
    node = Node('Image Info', {'Image': image, 'Frame': frame})
    return node._out

image_texture(image=None, vector=None, frame=None, extension='REPEAT', interpolation='Linear') classmethod

Node Image Texture

Parameters:

Name	Type	Description	Default
image	Image	socket 'Image' (id: Image)	None
vector	Vector	socket 'Vector' (id: Vector)	None
frame	Integer	socket 'Frame' (id: Frame)	None
extension	Literal['Repeat', 'Extend', 'Clip', 'Mirror']	parameter extension	'REPEAT'
interpolation	Literal['Linear', 'Closest', 'Cubic']	parameter interpolation	'Linear'

Returns:

Type	Description
Color	peer sockets: alpha_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def image_texture(cls,
                image: Image = None,
                vector: Vector = None,
                frame: Integer = None,
                extension: Literal['REPEAT', 'EXTEND', 'CLIP', 'MIRROR'] = 'REPEAT',
                interpolation: Literal['Linear', 'Closest', 'Cubic'] = 'Linear'):
    """ > Node Image Texture

    Parameters
    ----------
    image : Image, optional
        socket 'Image' (id: Image)

    vector : Vector, optional
        socket 'Vector' (id: Vector)

    frame : Integer, optional
        socket 'Frame' (id: Frame)

    extension : Literal['Repeat', 'Extend', 'Clip', 'Mirror']
        parameter `extension`

    interpolation : Literal['Linear', 'Closest', 'Cubic']
        parameter `interpolation`


    Returns
    -------
    Color
        peer sockets: alpha_ (Float)

    """
    utils.check_enum_arg('Image Texture', 'extension', extension, 'image_texture', ('REPEAT', 'EXTEND', 'CLIP', 'MIRROR'))
    utils.check_enum_arg('Image Texture', 'interpolation', interpolation, 'image_texture', ('Linear', 'Closest', 'Cubic'))
    node = Node('Image Texture', {'Image': image, 'Vector': vector, 'Frame': frame}, extension=extension, interpolation=interpolation)
    return node._out

import_csv(path=None, delimiter=None) classmethod

Node Import CSV

Parameters:

Name	Type	Description	Default
path	String	socket 'Path' (id: Path)	None
delimiter	String	socket 'Delimiter' (id: Delimiter)	None

Returns:

Type	Description
Cloud

Source code in core/generated/static_nd.py

@classmethod
def import_csv(cls, path: String = None, delimiter: String = None):
    """ > Node Import CSV

    Parameters
    ----------
    path : String, optional
        socket 'Path' (id: Path)

    delimiter : String, optional
        socket 'Delimiter' (id: Delimiter)


    Returns
    -------
    Cloud
    """
    node = Node('Import CSV', {'Path': path, 'Delimiter': delimiter})
    return node._out

import_obj(path=None) classmethod

Node Import OBJ

Parameters:

Name	Type	Description	Default
path	String	socket 'Path' (id: Path)	None

Returns:

Type	Description
Instances

Source code in core/generated/static_nd.py

@classmethod
def import_obj(cls, path: String = None):
    """ > Node Import OBJ

    Parameters
    ----------
    path : String, optional
        socket 'Path' (id: Path)


    Returns
    -------
    Instances
    """
    node = Node('Import OBJ', {'Path': path})
    return node._out

import_ply(path=None) classmethod

Node Import PLY

Parameters:

Name	Type	Description	Default
path	String	socket 'Path' (id: Path)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def import_ply(cls, path: String = None):
    """ > Node Import PLY

    Parameters
    ----------
    path : String, optional
        socket 'Path' (id: Path)


    Returns
    -------
    Mesh
    """
    node = Node('Import PLY', {'Path': path})
    return node._out

import_stl(path=None) classmethod

Node Import STL

Parameters:

Name	Type	Description	Default
path	String	socket 'Path' (id: Path)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def import_stl(cls, path: String = None):
    """ > Node Import STL

    Parameters
    ----------
    path : String, optional
        socket 'Path' (id: Path)


    Returns
    -------
    Mesh
    """
    node = Node('Import STL', {'Path': path})
    return node._out

import_text(path=None) classmethod

Node Import Text

Parameters:

Name	Type	Description	Default
path	String	socket 'Path' (id: Path)	None

Returns:

Type	Description
String

Source code in core/generated/static_nd.py

@classmethod
def import_text(cls, path: String = None):
    """ > Node Import Text

    Parameters
    ----------
    path : String, optional
        socket 'Path' (id: Path)


    Returns
    -------
    String
    """
    node = Node('Import Text', {'Path': path})
    return node._out

import_vdb(path=None) classmethod

Node Import VDB

Parameters:

Name	Type	Description	Default
path	String	socket 'Path' (id: Path)	None

Returns:

Type	Description
Volume

Source code in core/generated/static_nd.py

@classmethod
def import_vdb(cls, path: String = None):
    """ > Node Import VDB

    Parameters
    ----------
    path : String, optional
        socket 'Path' (id: Path)


    Returns
    -------
    Volume
    """
    node = Node('Import VDB', {'Path': path})
    return node._out

index()

Node Index

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@utils.classproperty
def index(self):
    """ > Node Index

    Returns
    -------
    Integer
    """
    node = Node('Index', )
    return node._out

index_of_nearest(position=None, group_id=None) classmethod

Node Index of Nearest

Parameters:

Name	Type	Description	Default
position	Vector	socket 'Position' (id: Position)	None
group_id	Integer	socket 'Group ID' (id: Group ID)	None

Returns:

Type	Description
Integer	peer sockets: has_neighbor_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def index_of_nearest(cls, position: Vector = None, group_id: Integer = None):
    """ > Node Index of Nearest

    Parameters
    ----------
    position : Vector, optional
        socket 'Position' (id: Position)

    group_id : Integer, optional
        socket 'Group ID' (id: Group ID)


    Returns
    -------
    Integer
        peer sockets: has_neighbor_ (Boolean)

    """
    node = Node('Index of Nearest', {'Position': position, 'Group ID': group_id})
    return node._out

index_switch(named_sockets={}, index=None, _0=None, _1=None, data_type='FLOAT', **sockets) classmethod

Node Index Switch

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
index	Integer	socket 'Index' (id: Index)	None
_0	Float	socket '0' (id: Item_0)	None
_1	Float	socket '1' (id: Item_1)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']	parameter data_type	'FLOAT'
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def index_switch(cls,
                named_sockets: dict = {},
                index: Integer = None,
                _0: Float = None,
                _1: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
                **sockets):
    """ > Node Index Switch

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    index : Integer, optional
        socket 'Index' (id: Index)

    _0 : Float, optional
        socket '0' (id: Item_0)

    _1 : Float, optional
        socket '1' (id: Item_1)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
        parameter `data_type`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    Float
    """
    node = Node('Index Switch', {'Index': index, 'Item_0': _0, 'Item_1': _1, **named_sockets}, data_type=data_type, **sockets)
    return node._out

instance_bounds(use_radius=None) classmethod

Node Instance Bounds

Parameters:

Name	Type	Description	Default
use_radius	Boolean	socket 'Use Radius' (id: Use Radius)	None

Returns:

Type	Description
Vector	peer sockets: max_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def instance_bounds(cls, use_radius: Boolean = None):
    """ > Node Instance Bounds

    Parameters
    ----------
    use_radius : Boolean, optional
        socket 'Use Radius' (id: Use Radius)


    Returns
    -------
    Vector
        peer sockets: max_ (Vector)

    """
    node = Node('Instance Bounds', {'Use Radius': use_radius})
    return node._out

instance_on_points(points=None, selection=None, instance=None, pick_instance=None, instance_index=None, rotation=None, scale=None) classmethod

Node Instance on Points

Parameters:

Name	Type	Description	Default
points	Cloud	socket 'Points' (id: Points)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
instance	Instances	socket 'Instance' (id: Instance)	None
pick_instance	Boolean	socket 'Pick Instance' (id: Pick Instance)	None
instance_index	Integer	socket 'Instance Index' (id: Instance Index)	None
rotation	Rotation	socket 'Rotation' (id: Rotation)	None
scale	Vector	socket 'Scale' (id: Scale)	None

Returns:

Type	Description
Instances

Source code in core/generated/static_nd.py

@classmethod
def instance_on_points(cls,
                points: Cloud = None,
                selection: Boolean = None,
                instance: Instances = None,
                pick_instance: Boolean = None,
                instance_index: Integer = None,
                rotation: Rotation = None,
                scale: Vector = None):
    """ > Node Instance on Points

    Parameters
    ----------
    points : Cloud, optional
        socket 'Points' (id: Points)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    instance : Instances, optional
        socket 'Instance' (id: Instance)

    pick_instance : Boolean, optional
        socket 'Pick Instance' (id: Pick Instance)

    instance_index : Integer, optional
        socket 'Instance Index' (id: Instance Index)

    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)

    scale : Vector, optional
        socket 'Scale' (id: Scale)


    Returns
    -------
    Instances
    """
    node = Node('Instance on Points', {'Points': points, 'Selection': selection, 'Instance': instance, 'Pick Instance': pick_instance, 'Instance Index': instance_index, 'Rotation': rotation, 'Scale': scale})
    return node._out

instance_rotation()

Node Instance Rotation

Returns:

Type	Description
Rotation

Source code in core/generated/static_nd.py

@utils.classproperty
def instance_rotation(self):
    """ > Node Instance Rotation

    Returns
    -------
    Rotation
    """
    node = Node('Instance Rotation', )
    return node._out

instance_scale()

Node Instance Scale

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@utils.classproperty
def instance_scale(self):
    """ > Node Instance Scale

    Returns
    -------
    Vector
    """
    node = Node('Instance Scale', )
    return node._out

instance_transform()

Node Instance Transform

Returns:

Type	Description
Matrix

Source code in core/generated/static_nd.py

@utils.classproperty
def instance_transform(self):
    """ > Node Instance Transform

    Returns
    -------
    Matrix
    """
    node = Node('Instance Transform', )
    return node._out

instances_to_points(instances=None, selection=None, position=None, radius=None) classmethod

Node Instances to Points

Parameters:

Name	Type	Description	Default
instances	Instances	socket 'Instances' (id: Instances)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
position	Vector	socket 'Position' (id: Position)	None
radius	Float	socket 'Radius' (id: Radius)	None

Returns:

Type	Description
Cloud

Source code in core/generated/static_nd.py

@classmethod
def instances_to_points(cls,
                instances: Instances = None,
                selection: Boolean = None,
                position: Vector = None,
                radius: Float = None):
    """ > Node Instances to Points

    Parameters
    ----------
    instances : Instances, optional
        socket 'Instances' (id: Instances)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    position : Vector, optional
        socket 'Position' (id: Position)

    radius : Float, optional
        socket 'Radius' (id: Radius)


    Returns
    -------
    Cloud
    """
    node = Node('Instances to Points', {'Instances': instances, 'Selection': selection, 'Position': position, 'Radius': radius})
    return node._out

integer(integer=0) classmethod

Node Integer

Parameters:

Name	Type	Description	Default
integer	int	parameter integer	0

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def integer(cls, integer = 0):
    """ > Node Integer

    Parameters
    ----------
    integer : int
        parameter `integer`


    Returns
    -------
    Integer
    """
    node = Node('Integer', integer=integer)
    return node._out

integer_math(value=None, value_1=None, value_2=None, operation='ADD') classmethod

Node Integer Math

Parameters:

Name	Type	Description	Default
value	Integer	socket 'Value' (id: Value)	None
value_1	Integer	socket 'Value' (id: Value_001)	None
value_2	Integer	socket 'Value' (id: Value_002)	None
operation	Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Absolute', 'Negate', 'Power', 'Minimum', 'Maximum', 'Sign', 'Divide Round', 'Divide Floor', 'Divide Ceiling', 'Floored Modulo', 'Modulo', 'Greatest Common Divisor', 'Least Common Multiple']	parameter operation	'ADD'

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def integer_math(cls,
                value: Integer = None,
                value_1: Integer = None,
                value_2: Integer = None,
                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'):
    """ > Node Integer Math

    Parameters
    ----------
    value : Integer, optional
        socket 'Value' (id: Value)

    value_1 : Integer, optional
        socket 'Value' (id: Value_001)

    value_2 : Integer, optional
        socket 'Value' (id: Value_002)

    operation : Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Absolute', 'Negate', 'Power', 'Minimum', 'Maximum', 'Sign', 'Divide Round', 'Divide Floor', 'Divide Ceiling', 'Floored Modulo', 'Modulo', 'Greatest Common Divisor', 'Least Common Multiple']
        parameter `operation`


    Returns
    -------
    Integer
    """
    utils.check_enum_arg('Integer Math', 'operation', operation, 'integer_math', ('ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'ABSOLUTE', 'NEGATE', 'POWER', 'MINIMUM', 'MAXIMUM', 'SIGN', 'DIVIDE_ROUND', 'DIVIDE_FLOOR', 'DIVIDE_CEIL', 'FLOORED_MODULO', 'MODULO', 'GCD', 'LCM'))
    node = Node('Integer Math', {'Value': value, 'Value_001': value_1, 'Value_002': value_2}, operation=operation)
    return node._out

interpolate_curves(guide_curves=None, guide_up=None, guide_group_id=None, points=None, point_up=None, point_group_id=None, max_neighbors=None) classmethod

Node Interpolate Curves

Parameters:

Name	Type	Description	Default
guide_curves	Curve	socket 'Guide Curves' (id: Guide Curves)	None
guide_up	Vector	socket 'Guide Up' (id: Guide Up)	None
guide_group_id	Integer	socket 'Guide Group ID' (id: Guide Group ID)	None
points	Cloud	socket 'Points' (id: Points)	None
point_up	Vector	socket 'Point Up' (id: Point Up)	None
point_group_id	Integer	socket 'Point Group ID' (id: Point Group ID)	None
max_neighbors	Integer	socket 'Max Neighbors' (id: Max Neighbors)	None

Returns:

Type	Description
Curve	peer sockets: closest_index_ (Integer), closest_weight_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def interpolate_curves(cls,
                guide_curves: Curve = None,
                guide_up: Vector = None,
                guide_group_id: Integer = None,
                points: Cloud = None,
                point_up: Vector = None,
                point_group_id: Integer = None,
                max_neighbors: Integer = None):
    """ > Node Interpolate Curves

    Parameters
    ----------
    guide_curves : Curve, optional
        socket 'Guide Curves' (id: Guide Curves)

    guide_up : Vector, optional
        socket 'Guide Up' (id: Guide Up)

    guide_group_id : Integer, optional
        socket 'Guide Group ID' (id: Guide Group ID)

    points : Cloud, optional
        socket 'Points' (id: Points)

    point_up : Vector, optional
        socket 'Point Up' (id: Point Up)

    point_group_id : Integer, optional
        socket 'Point Group ID' (id: Point Group ID)

    max_neighbors : Integer, optional
        socket 'Max Neighbors' (id: Max Neighbors)


    Returns
    -------
    Curve
        peer sockets: closest_index_ (Integer), closest_weight_ (Float)

    """
    node = Node('Interpolate Curves', {'Guide Curves': guide_curves, 'Guide Up': guide_up, 'Guide Group ID': guide_group_id, 'Points': points, 'Point Up': point_up, 'Point Group ID': point_group_id, 'Max Neighbors': max_neighbors})
    return node._out

invert_matrix(matrix=None) classmethod

Node Invert Matrix

Parameters:

Name	Type	Description	Default
matrix	Matrix	socket 'Matrix' (id: Matrix)	None

Returns:

Type	Description
Matrix	peer sockets: invertible_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def invert_matrix(cls, matrix: Matrix = None):
    """ > Node Invert Matrix

    Parameters
    ----------
    matrix : Matrix, optional
        socket 'Matrix' (id: Matrix)


    Returns
    -------
    Matrix
        peer sockets: invertible_ (Boolean)

    """
    node = Node('Invert Matrix', {'Matrix': matrix})
    return node._out

invert_rotation(rotation=None) classmethod

Node Invert Rotation

Parameters:

Name	Type	Description	Default
rotation	Rotation	socket 'Rotation' (id: Rotation)	None

Returns:

Type	Description
Rotation

Source code in core/generated/static_nd.py

@classmethod
def invert_rotation(cls, rotation: Rotation = None):
    """ > Node Invert Rotation

    Parameters
    ----------
    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)


    Returns
    -------
    Rotation
    """
    node = Node('Invert Rotation', {'Rotation': rotation})
    return node._out

is_edge_smooth()

Node Is Edge Smooth

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@utils.classproperty
def is_edge_smooth(self):
    """ > Node Is Edge Smooth

    Returns
    -------
    Boolean
    """
    node = Node('Is Edge Smooth', )
    return node._out

is_face_planar(threshold=None) classmethod

Node Is Face Planar

Parameters:

Name	Type	Description	Default
threshold	Float	socket 'Threshold' (id: Threshold)	None

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def is_face_planar(cls, threshold: Float = None):
    """ > Node Is Face Planar

    Parameters
    ----------
    threshold : Float, optional
        socket 'Threshold' (id: Threshold)


    Returns
    -------
    Boolean
    """
    node = Node('Is Face Planar', {'Threshold': threshold})
    return node._out

is_face_smooth()

Node Is Face Smooth

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@utils.classproperty
def is_face_smooth(self):
    """ > Node Is Face Smooth

    Returns
    -------
    Boolean
    """
    node = Node('Is Face Smooth', )
    return node._out

is_spline_cyclic()

Node Is Spline Cyclic

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@utils.classproperty
def is_spline_cyclic(self):
    """ > Node Is Spline Cyclic

    Returns
    -------
    Boolean
    """
    node = Node('Is Spline Cyclic', )
    return node._out

is_viewport()

Node Is Viewport

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@utils.classproperty
def is_viewport(self):
    """ > Node Is Viewport

    Returns
    -------
    Boolean
    """
    node = Node('Is Viewport', )
    return node._out

join_bundle(*bundle) classmethod

Node Join Bundle

Parameters:

Name	Type	Description	Default
bundle	Bundle	socket 'Bundle' (id: Bundle)	()

Returns:

Type	Description
Bundle

Source code in core/generated/static_nd.py

@classmethod
def join_bundle(cls, *bundle: Bundle):
    """ > Node Join Bundle

    Parameters
    ----------
    bundle : Bundle, optional
        socket 'Bundle' (id: Bundle)


    Returns
    -------
    Bundle
    """
    node = Node('Join Bundle', {'Bundle': list(bundle)})
    return node._out

join_geometry(*geometry) classmethod

Node Join Geometry

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	()

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def join_geometry(cls, *geometry: Geometry):
    """ > Node Join Geometry

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)


    Returns
    -------
    Geometry
    """
    node = Node('Join Geometry', {'Geometry': list(geometry)})
    return node._out

join_strings(*strings, delimiter=None) classmethod

Node Join Strings

Parameters:

Name	Type	Description	Default
delimiter	String	socket 'Delimiter' (id: Delimiter)	None
strings	String	socket 'Strings' (id: Strings)	()

Returns:

Type	Description
String

Source code in core/generated/static_nd.py

@classmethod
def join_strings(cls, *strings: String, delimiter: String = None):
    """ > Node Join Strings

    Parameters
    ----------
    delimiter : String, optional
        socket 'Delimiter' (id: Delimiter)

    strings : String, optional
        socket 'Strings' (id: Strings)


    Returns
    -------
    String
    """
    node = Node('Join Strings', {'Delimiter': delimiter, 'Strings': list(strings)})
    return node._out

linear_gizmo(*value, position=None, direction=None, color_id='PRIMARY', draw_style='ARROW') classmethod

Node Linear Gizmo

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	()
position	Vector	socket 'Position' (id: Position)	None
direction	Vector	socket 'Direction' (id: Direction)	None
color_id	Literal['Primary', 'Secondary', 'X', 'Y', 'Z']	parameter color_id	'PRIMARY'
draw_style	Literal['Arrow', 'Cross', 'Box']	parameter draw_style	'ARROW'

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def linear_gizmo(cls,
                *value: Float,
                position: Vector = None,
                direction: Vector = None,
                color_id: Literal['PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'] = 'PRIMARY',
                draw_style: Literal['ARROW', 'CROSS', 'BOX'] = 'ARROW'):
    """ > Node Linear Gizmo

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    position : Vector, optional
        socket 'Position' (id: Position)

    direction : Vector, optional
        socket 'Direction' (id: Direction)

    color_id : Literal['Primary', 'Secondary', 'X', 'Y', 'Z']
        parameter `color_id`

    draw_style : Literal['Arrow', 'Cross', 'Box']
        parameter `draw_style`


    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('Linear Gizmo', 'color_id', color_id, 'linear_gizmo', ('PRIMARY', 'SECONDARY', 'X', 'Y', 'Z'))
    utils.check_enum_arg('Linear Gizmo', 'draw_style', draw_style, 'linear_gizmo', ('ARROW', 'CROSS', 'BOX'))
    node = Node('Linear Gizmo', {'Value': list(value), 'Position': position, 'Direction': direction}, color_id=color_id, draw_style=draw_style)
    return node._out

list_length(list=None, data_type='FLOAT') classmethod

Node List Length

Parameters:

Name	Type	Description	Default
list	Float	socket 'List' (id: List)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']	parameter data_type	'FLOAT'

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def list_length(cls,
                list: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT'):
    """ > Node List Length

    Parameters
    ----------
    list : Float, optional
        socket 'List' (id: List)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
        parameter `data_type`


    Returns
    -------
    Integer
    """
    node = Node('List Length', {'List': list}, data_type=data_type)
    return node._out

magic_texture(vector=None, scale=None, distortion=None, turbulence_depth=2) classmethod

Node Magic Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
scale	Float	socket 'Scale' (id: Scale)	None
distortion	Float	socket 'Distortion' (id: Distortion)	None
turbulence_depth	int	parameter turbulence_depth	2

Returns:

Type	Description
Color	peer sockets: factor_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def magic_texture(cls,
                vector: Vector = None,
                scale: Float = None,
                distortion: Float = None,
                turbulence_depth = 2):
    """ > Node Magic Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    distortion : Float, optional
        socket 'Distortion' (id: Distortion)

    turbulence_depth : int
        parameter `turbulence_depth`


    Returns
    -------
    Color
        peer sockets: factor_ (Float)

    """
    node = Node('Magic Texture', {'Vector': vector, 'Scale': scale, 'Distortion': distortion}, turbulence_depth=turbulence_depth)
    return node._out

map_range(value=None, from_min=None, from_max=None, to_min=None, to_max=None, steps=None, vector=None, from_min_1=None, from_max_1=None, to_min_1=None, to_max_1=None, steps_1=None, clamp=True, data_type='FLOAT', interpolation_type='LINEAR') classmethod

Node Map Range

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
from_min	Float	socket 'From Min' (id: From Min)	None
from_max	Float	socket 'From Max' (id: From Max)	None
to_min	Float	socket 'To Min' (id: To Min)	None
to_max	Float	socket 'To Max' (id: To Max)	None
steps	Float	socket 'Steps' (id: Steps)	None
vector	Vector	socket 'Vector' (id: Vector)	None
from_min_1	Vector	socket 'From Min' (id: From_Min_FLOAT3)	None
from_max_1	Vector	socket 'From Max' (id: From_Max_FLOAT3)	None
to_min_1	Vector	socket 'To Min' (id: To_Min_FLOAT3)	None
to_max_1	Vector	socket 'To Max' (id: To_Max_FLOAT3)	None
steps_1	Vector	socket 'Steps' (id: Steps_FLOAT3)	None
clamp	bool	parameter clamp	True
data_type	Literal['Float', 'Vector']	parameter data_type	'FLOAT'
interpolation_type	Literal['Linear', 'Stepped Linear', 'Smooth Step', 'Smoother Step']	parameter interpolation_type	'LINEAR'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def map_range(cls,
                value: Float = None,
                from_min: Float = None,
                from_max: Float = None,
                to_min: Float = None,
                to_max: Float = None,
                steps: Float = None,
                vector: Vector = None,
                from_min_1: Vector = None,
                from_max_1: Vector = None,
                to_min_1: Vector = None,
                to_max_1: Vector = None,
                steps_1: Vector = None,
                clamp = True,
                data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
                interpolation_type: Literal['LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'] = 'LINEAR'):
    """ > Node Map Range

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    from_min : Float, optional
        socket 'From Min' (id: From Min)

    from_max : Float, optional
        socket 'From Max' (id: From Max)

    to_min : Float, optional
        socket 'To Min' (id: To Min)

    to_max : Float, optional
        socket 'To Max' (id: To Max)

    steps : Float, optional
        socket 'Steps' (id: Steps)

    vector : Vector, optional
        socket 'Vector' (id: Vector)

    from_min_1 : Vector, optional
        socket 'From Min' (id: From_Min_FLOAT3)

    from_max_1 : Vector, optional
        socket 'From Max' (id: From_Max_FLOAT3)

    to_min_1 : Vector, optional
        socket 'To Min' (id: To_Min_FLOAT3)

    to_max_1 : Vector, optional
        socket 'To Max' (id: To_Max_FLOAT3)

    steps_1 : Vector, optional
        socket 'Steps' (id: Steps_FLOAT3)

    clamp : bool
        parameter `clamp`

    data_type : Literal['Float', 'Vector']
        parameter `data_type`

    interpolation_type : Literal['Linear', 'Stepped Linear', 'Smooth Step', 'Smoother Step']
        parameter `interpolation_type`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Map Range', 'interpolation_type', interpolation_type, 'map_range', ('LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'))
    node = Node('Map Range', {'Value': value, 'From Min': from_min, 'From Max': from_max, 'To Min': to_min, 'To Max': to_max, 'Steps': steps, 'Vector': vector, 'From_Min_FLOAT3': from_min_1, 'From_Max_FLOAT3': from_max_1, 'To_Min_FLOAT3': to_min_1, 'To_Max_FLOAT3': to_max_1, 'Steps_FLOAT3': steps_1}, clamp=clamp, data_type=data_type, interpolation_type=interpolation_type)
    return node._out

match_string(string=None, operation=None, key=None) classmethod

Node Match String

Parameters:

Name	Type	Description	Default
string	String	socket 'String' (id: String)	None
operation	menu='Starts With'	('Starts With', 'Ends With', 'Contains')	None
key	String	socket 'Key' (id: Key)	None

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def match_string(cls,
                string: String = None,
                operation: Literal['Starts With', 'Ends With', 'Contains'] = None,
                key: String = None):
    """ > Node Match String

    Parameters
    ----------
    string : String, optional
        socket 'String' (id: String)

    operation : menu='Starts With', optional
        ('Starts With', 'Ends With', 'Contains')

    key : String, optional
        socket 'Key' (id: Key)


    Returns
    -------
    Boolean
    """
    node = Node('Match String', {'String': string, 'Operation': operation, 'Key': key})
    return node._out

material(material=None) classmethod

Node Material

Parameters:

Name	Type	Description	Default
material	NoneType	parameter material	None

Returns:

Type	Description
Material

Source code in core/generated/static_nd.py

@classmethod
def material(cls, material = None):
    """ > Node Material

    Parameters
    ----------
    material : NoneType
        parameter `material`


    Returns
    -------
    Material
    """
    node = Node('Material', material=material)
    return node._out

material_index()

Node Material Index

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@utils.classproperty
def material_index(self):
    """ > Node Material Index

    Returns
    -------
    Integer
    """
    node = Node('Material Index', )
    return node._out

material_selection(material=None) classmethod

Node Material Selection

Parameters:

Name	Type	Description	Default
material	Material	socket 'Material' (id: Material)	None

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def material_selection(cls, material: Material = None):
    """ > Node Material Selection

    Parameters
    ----------
    material : Material, optional
        socket 'Material' (id: Material)


    Returns
    -------
    Boolean
    """
    node = Node('Material Selection', {'Material': material})
    return node._out

math(value=None, value_1=None, value_2=None, operation='ADD', use_clamp=False) classmethod

Node Math

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
value_1	Float	socket 'Value' (id: Value_001)	None
value_2	Float	socket 'Value' (id: Value_002)	None
operation	Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Power', 'Logarithm', 'Square Root', 'Inverse Square Root', 'Absolute', 'Exponent', 'Minimum', 'Maximum', 'Less Than', 'Greater Than', 'Sign', 'Compare', 'Smooth Minimum', 'Smooth Maximum', 'Round', 'Floor', 'Ceil', 'Truncate', 'Fraction', 'Truncated Modulo', 'Floored Modulo', 'Wrap', 'Snap', 'Ping-Pong', 'Sine', 'Cosine', 'Tangent', 'Arcsine', 'Arccosine', 'Arctangent', 'Arctan2', 'Hyperbolic Sine', 'Hyperbolic Cosine', 'Hyperbolic Tangent', 'To Radians', 'To Degrees']	parameter operation	'ADD'
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def math(cls,
                value: Float = None,
                value_1: Float = None,
                value_2: Float = None,
                operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'POWER', 'LOGARITHM', 'SQRT', 'INVERSE_SQRT', 'ABSOLUTE', 'EXPONENT', 'MINIMUM', 'MAXIMUM', 'LESS_THAN', 'GREATER_THAN', 'SIGN', 'COMPARE', 'SMOOTH_MIN', 'SMOOTH_MAX', 'ROUND', 'FLOOR', 'CEIL', 'TRUNC', 'FRACT', 'MODULO', 'FLOORED_MODULO', 'WRAP', 'SNAP', 'PINGPONG', 'SINE', 'COSINE', 'TANGENT', 'ARCSINE', 'ARCCOSINE', 'ARCTANGENT', 'ARCTAN2', 'SINH', 'COSH', 'TANH', 'RADIANS', 'DEGREES'] = 'ADD',
                use_clamp = False):
    """ > Node Math

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    value_1 : Float, optional
        socket 'Value' (id: Value_001)

    value_2 : Float, optional
        socket 'Value' (id: Value_002)

    operation : Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Power', 'Logarithm', 'Square Root', 'Inverse Square Root', 'Absolute', 'Exponent', 'Minimum', 'Maximum', 'Less Than', 'Greater Than', 'Sign', 'Compare', 'Smooth Minimum', 'Smooth Maximum', 'Round', 'Floor', 'Ceil', 'Truncate', 'Fraction', 'Truncated Modulo', 'Floored Modulo', 'Wrap', 'Snap', 'Ping-Pong', 'Sine', 'Cosine', 'Tangent', 'Arcsine', 'Arccosine', 'Arctangent', 'Arctan2', 'Hyperbolic Sine', 'Hyperbolic Cosine', 'Hyperbolic Tangent', 'To Radians', 'To Degrees']
        parameter `operation`

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Math', 'operation', operation, 'math', ('ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'POWER', 'LOGARITHM', 'SQRT', 'INVERSE_SQRT', 'ABSOLUTE', 'EXPONENT', 'MINIMUM', 'MAXIMUM', 'LESS_THAN', 'GREATER_THAN', 'SIGN', 'COMPARE', 'SMOOTH_MIN', 'SMOOTH_MAX', 'ROUND', 'FLOOR', 'CEIL', 'TRUNC', 'FRACT', 'MODULO', 'FLOORED_MODULO', 'WRAP', 'SNAP', 'PINGPONG', 'SINE', 'COSINE', 'TANGENT', 'ARCSINE', 'ARCCOSINE', 'ARCTANGENT', 'ARCTAN2', 'SINH', 'COSH', 'TANH', 'RADIANS', 'DEGREES'))
    node = Node('Math', {'Value': value, 'Value_001': value_1, 'Value_002': value_2}, operation=operation, use_clamp=use_clamp)
    return node._out

matrix_determinant(matrix=None) classmethod

Node Matrix Determinant

Parameters:

Name	Type	Description	Default
matrix	Matrix	socket 'Matrix' (id: Matrix)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def matrix_determinant(cls, matrix: Matrix = None):
    """ > Node Matrix Determinant

    Parameters
    ----------
    matrix : Matrix, optional
        socket 'Matrix' (id: Matrix)


    Returns
    -------
    Float
    """
    node = Node('Matrix Determinant', {'Matrix': matrix})
    return node._out

matrix_svd(matrix=None) classmethod

Node Matrix SVD

Parameters:

Name	Type	Description	Default
matrix	Matrix	socket 'Matrix' (id: Matrix)	None

Returns:

Type	Description
Matrix	peer sockets: s_ (Vector), v_ (Matrix)

Source code in core/generated/static_nd.py

@classmethod
def matrix_svd(cls, matrix: Matrix = None):
    """ > Node Matrix SVD

    Parameters
    ----------
    matrix : Matrix, optional
        socket 'Matrix' (id: Matrix)


    Returns
    -------
    Matrix
        peer sockets: s_ (Vector), v_ (Matrix)

    """
    node = Node('Matrix SVD', {'Matrix': matrix})
    return node._out

menu_switch(named_sockets={}, menu=None, data_type='GEOMETRY', **sockets) classmethod

Node Menu Switch

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
menu	Menu	Menu selection	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']	parameter data_type	'GEOMETRY'
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
Geometry	peer sockets: a_ (Boolean), b_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def menu_switch(cls,
                named_sockets: dict = {},
                menu = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'GEOMETRY',
                **sockets):
    """ > Node Menu Switch

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    menu : Menu, optional
        Menu selection

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
        parameter `data_type`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    Geometry
        peer sockets: a_ (Boolean), b_ (Boolean)

    """
    node = Node('Menu Switch', {'Menu': menu, **named_sockets}, data_type=data_type, **sockets)
    return node._out

merge_by_distance(geometry=None, selection=None, mode=None, distance=None) classmethod

Node Merge by Distance

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
mode	menu='All'	('All', 'Connected')	None
distance	Float	socket 'Distance' (id: Distance)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def merge_by_distance(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                mode: Literal['All', 'Connected'] = None,
                distance: Float = None):
    """ > Node Merge by Distance

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    mode : menu='All', optional
        ('All', 'Connected')

    distance : Float, optional
        socket 'Distance' (id: Distance)


    Returns
    -------
    Geometry
    """
    node = Node('Merge by Distance', {'Geometry': geometry, 'Selection': selection, 'Mode': mode, 'Distance': distance})
    return node._out

merge_layers(grease_pencil=None, selection=None, group_id=None, mode='MERGE_BY_NAME') classmethod

Node Merge Layers

Parameters:

Name	Type	Description	Default
grease_pencil	GreasePencil	socket 'Grease Pencil' (id: Grease Pencil)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
group_id	Integer	socket 'Group ID' (id: Group ID)	None
mode	Literal['By Name', 'By Group ID']	parameter mode	'MERGE_BY_NAME'

Returns:

Type	Description
GreasePencil

Source code in core/generated/static_nd.py

@classmethod
def merge_layers(cls,
                grease_pencil: GreasePencil = None,
                selection: Boolean = None,
                group_id: Integer = None,
                mode: Literal['MERGE_BY_NAME', 'MERGE_BY_ID'] = 'MERGE_BY_NAME'):
    """ > Node Merge Layers

    Parameters
    ----------
    grease_pencil : GreasePencil, optional
        socket 'Grease Pencil' (id: Grease Pencil)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    group_id : Integer, optional
        socket 'Group ID' (id: Group ID)

    mode : Literal['By Name', 'By Group ID']
        parameter `mode`


    Returns
    -------
    GreasePencil
    """
    utils.check_enum_arg('Merge Layers', 'mode', mode, 'merge_layers', ('MERGE_BY_NAME', 'MERGE_BY_ID'))
    node = Node('Merge Layers', {'Grease Pencil': grease_pencil, 'Selection': selection, 'Group ID': group_id}, mode=mode)
    return node._out

mesh_boolean(*mesh_2, mesh_1=None, self_intersection=None, hole_tolerant=None, operation='DIFFERENCE', solver='FLOAT') classmethod

Node Mesh Boolean

Parameters:

Name	Type	Description	Default
mesh_1	Mesh	socket 'Mesh 1' (id: Mesh 1)	None
mesh_2	Mesh	socket 'Mesh 2' (id: Mesh 2)	()
self_intersection	Boolean	socket 'Self Intersection' (id: Self Intersection)	None
hole_tolerant	Boolean	socket 'Hole Tolerant' (id: Hole Tolerant)	None
operation	Literal['Intersect', 'Union', 'Difference']	parameter operation	'DIFFERENCE'
solver	Literal['Exact', 'Float', 'Manifold']	parameter solver	'FLOAT'

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def mesh_boolean(cls,
                *mesh_2: Mesh,
                mesh_1: Mesh = None,
                self_intersection: Boolean = None,
                hole_tolerant: Boolean = None,
                operation: Literal['INTERSECT', 'UNION', 'DIFFERENCE'] = 'DIFFERENCE',
                solver: Literal['EXACT', 'FLOAT', 'MANIFOLD'] = 'FLOAT'):
    """ > Node Mesh Boolean

    Parameters
    ----------
    mesh_1 : Mesh, optional
        socket 'Mesh 1' (id: Mesh 1)

    mesh_2 : Mesh, optional
        socket 'Mesh 2' (id: Mesh 2)

    self_intersection : Boolean, optional
        socket 'Self Intersection' (id: Self Intersection)

    hole_tolerant : Boolean, optional
        socket 'Hole Tolerant' (id: Hole Tolerant)

    operation : Literal['Intersect', 'Union', 'Difference']
        parameter `operation`

    solver : Literal['Exact', 'Float', 'Manifold']
        parameter `solver`


    Returns
    -------
    Mesh
    """
    utils.check_enum_arg('Mesh Boolean', 'operation', operation, 'mesh_boolean', ('INTERSECT', 'UNION', 'DIFFERENCE'))
    utils.check_enum_arg('Mesh Boolean', 'solver', solver, 'mesh_boolean', ('EXACT', 'FLOAT', 'MANIFOLD'))
    node = Node('Mesh Boolean', {'Mesh 1': mesh_1, 'Mesh 2': list(mesh_2), 'Self Intersection': self_intersection, 'Hole Tolerant': hole_tolerant}, operation=operation, solver=solver)
    return node._out

mesh_circle(vertices=None, radius=None, fill_type='NONE') classmethod

Node Mesh Circle

Parameters:

Name	Type	Description	Default
vertices	Integer	socket 'Vertices' (id: Vertices)	None
radius	Float	socket 'Radius' (id: Radius)	None
fill_type	Literal['None', 'N-Gon', 'Triangles']	parameter fill_type	'NONE'

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def mesh_circle(cls,
                vertices: Integer = None,
                radius: Float = None,
                fill_type: Literal['NONE', 'NGON', 'TRIANGLE_FAN'] = 'NONE'):
    """ > Node Mesh Circle

    Parameters
    ----------
    vertices : Integer, optional
        socket 'Vertices' (id: Vertices)

    radius : Float, optional
        socket 'Radius' (id: Radius)

    fill_type : Literal['None', 'N-Gon', 'Triangles']
        parameter `fill_type`


    Returns
    -------
    Mesh
    """
    utils.check_enum_arg('Mesh Circle', 'fill_type', fill_type, 'mesh_circle', ('NONE', 'NGON', 'TRIANGLE_FAN'))
    node = Node('Mesh Circle', {'Vertices': vertices, 'Radius': radius}, fill_type=fill_type)
    return node._out

mesh_island() classmethod

Node Mesh Island

Returns:

Type	Description
Integer	peer sockets: island_count_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def mesh_island(cls):
    """ > Node Mesh Island

    Returns
    -------
    Integer
        peer sockets: island_count_ (Integer)

    """
    node = Node('Mesh Island', )
    return node

mesh_line(count=None, resolution=None, start_location=None, offset=None, count_mode='TOTAL', mode='OFFSET') classmethod

Node Mesh Line

Parameters:

Name	Type	Description	Default
count	Integer	socket 'Count' (id: Count)	None
resolution	Float	socket 'Resolution' (id: Resolution)	None
start_location	Vector	socket 'Start Location' (id: Start Location)	None
offset	Vector	socket 'Offset' (id: Offset)	None
count_mode	Literal['Count', 'Resolution']	parameter count_mode	'TOTAL'
mode	Literal['Offset', 'End Points']	parameter mode	'OFFSET'

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def mesh_line(cls,
                count: Integer = None,
                resolution: Float = None,
                start_location: Vector = None,
                offset: Vector = None,
                count_mode: Literal['TOTAL', 'RESOLUTION'] = 'TOTAL',
                mode: Literal['OFFSET', 'END_POINTS'] = 'OFFSET'):
    """ > Node Mesh Line

    Parameters
    ----------
    count : Integer, optional
        socket 'Count' (id: Count)

    resolution : Float, optional
        socket 'Resolution' (id: Resolution)

    start_location : Vector, optional
        socket 'Start Location' (id: Start Location)

    offset : Vector, optional
        socket 'Offset' (id: Offset)

    count_mode : Literal['Count', 'Resolution']
        parameter `count_mode`

    mode : Literal['Offset', 'End Points']
        parameter `mode`


    Returns
    -------
    Mesh
    """
    utils.check_enum_arg('Mesh Line', 'count_mode', count_mode, 'mesh_line', ('TOTAL', 'RESOLUTION'))
    utils.check_enum_arg('Mesh Line', 'mode', mode, 'mesh_line', ('OFFSET', 'END_POINTS'))
    node = Node('Mesh Line', {'Count': count, 'Resolution': resolution, 'Start Location': start_location, 'Offset': offset}, count_mode=count_mode, mode=mode)
    return node._out

mesh_to_curve(mesh=None, selection=None, mode='EDGES') classmethod

Node Mesh to Curve

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
mode	Literal['Edges', 'Faces']	parameter mode	'EDGES'

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def mesh_to_curve(cls,
                mesh: Mesh = None,
                selection: Boolean = None,
                mode: Literal['EDGES', 'FACES'] = 'EDGES'):
    """ > Node Mesh to Curve

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    mode : Literal['Edges', 'Faces']
        parameter `mode`


    Returns
    -------
    Curve
    """
    utils.check_enum_arg('Mesh to Curve', 'mode', mode, 'mesh_to_curve', ('EDGES', 'FACES'))
    node = Node('Mesh to Curve', {'Mesh': mesh, 'Selection': selection}, mode=mode)
    return node._out

mesh_to_density_grid(mesh=None, density=None, voxel_size=None, gradient_width=None) classmethod

Node Mesh to Density Grid

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
density	Float	socket 'Density' (id: Density)	None
voxel_size	Float	socket 'Voxel Size' (id: Voxel Size)	None
gradient_width	Float	socket 'Gradient Width' (id: Gradient Width)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def mesh_to_density_grid(cls,
                mesh: Mesh = None,
                density: Float = None,
                voxel_size: Float = None,
                gradient_width: Float = None):
    """ > Node Mesh to Density Grid

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    density : Float, optional
        socket 'Density' (id: Density)

    voxel_size : Float, optional
        socket 'Voxel Size' (id: Voxel Size)

    gradient_width : Float, optional
        socket 'Gradient Width' (id: Gradient Width)


    Returns
    -------
    Float
    """
    node = Node('Mesh to Density Grid', {'Mesh': mesh, 'Density': density, 'Voxel Size': voxel_size, 'Gradient Width': gradient_width})
    return node._out

mesh_to_points(mesh=None, selection=None, position=None, radius=None, mode='VERTICES') classmethod

Node Mesh to Points

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
position	Vector	socket 'Position' (id: Position)	None
radius	Float	socket 'Radius' (id: Radius)	None
mode	Literal['Vertices', 'Edges', 'Faces', 'Corners']	parameter mode	'VERTICES'

Returns:

Type	Description
Cloud

Source code in core/generated/static_nd.py

@classmethod
def mesh_to_points(cls,
                mesh: Mesh = None,
                selection: Boolean = None,
                position: Vector = None,
                radius: Float = None,
                mode: Literal['VERTICES', 'EDGES', 'FACES', 'CORNERS'] = 'VERTICES'):
    """ > Node Mesh to Points

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    position : Vector, optional
        socket 'Position' (id: Position)

    radius : Float, optional
        socket 'Radius' (id: Radius)

    mode : Literal['Vertices', 'Edges', 'Faces', 'Corners']
        parameter `mode`


    Returns
    -------
    Cloud
    """
    utils.check_enum_arg('Mesh to Points', 'mode', mode, 'mesh_to_points', ('VERTICES', 'EDGES', 'FACES', 'CORNERS'))
    node = Node('Mesh to Points', {'Mesh': mesh, 'Selection': selection, 'Position': position, 'Radius': radius}, mode=mode)
    return node._out

mesh_to_sdf_grid(mesh=None, voxel_size=None, band_width=None) classmethod

Node Mesh to SDF Grid

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
voxel_size	Float	socket 'Voxel Size' (id: Voxel Size)	None
band_width	Integer	socket 'Band Width' (id: Band Width)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def mesh_to_sdf_grid(cls, mesh: Mesh = None, voxel_size: Float = None, band_width: Integer = None):
    """ > Node Mesh to SDF Grid

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    voxel_size : Float, optional
        socket 'Voxel Size' (id: Voxel Size)

    band_width : Integer, optional
        socket 'Band Width' (id: Band Width)


    Returns
    -------
    Float
    """
    node = Node('Mesh to SDF Grid', {'Mesh': mesh, 'Voxel Size': voxel_size, 'Band Width': band_width})
    return node._out

mesh_to_volume(mesh=None, density=None, resolution_mode=None, voxel_size=None, voxel_amount=None, interior_band_width=None) classmethod

Node Mesh to Volume

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
density	Float	socket 'Density' (id: Density)	None
resolution_mode	menu='Amount'	('Amount', 'Size')	None
voxel_size	Float	socket 'Voxel Size' (id: Voxel Size)	None
voxel_amount	Float	socket 'Voxel Amount' (id: Voxel Amount)	None
interior_band_width	Float	socket 'Interior Band Width' (id: Interior Band Width)	None

Returns:

Type	Description
Volume

Source code in core/generated/static_nd.py

@classmethod
def mesh_to_volume(cls,
                mesh: Mesh = None,
                density: Float = None,
                resolution_mode: Literal['Amount', 'Size'] = None,
                voxel_size: Float = None,
                voxel_amount: Float = None,
                interior_band_width: Float = None):
    """ > Node Mesh to Volume

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    density : Float, optional
        socket 'Density' (id: Density)

    resolution_mode : menu='Amount', optional
        ('Amount', 'Size')

    voxel_size : Float, optional
        socket 'Voxel Size' (id: Voxel Size)

    voxel_amount : Float, optional
        socket 'Voxel Amount' (id: Voxel Amount)

    interior_band_width : Float, optional
        socket 'Interior Band Width' (id: Interior Band Width)


    Returns
    -------
    Volume
    """
    node = Node('Mesh to Volume', {'Mesh': mesh, 'Density': density, 'Resolution Mode': resolution_mode, 'Voxel Size': voxel_size, 'Voxel Amount': voxel_amount, 'Interior Band Width': interior_band_width})
    return node._out

mix(a=None, b=None, a_1=None, b_1=None, a_2=None, b_2=None, a_3=None, b_3=None, factor=None, blend_type='MIX', clamp_factor=True, clamp_result=False, data_type='FLOAT', factor_mode='UNIFORM') classmethod

Node Mix

Parameters:

Name	Type	Description	Default
a	Float	socket 'A' (id: A_Float)	None
b	Float	socket 'B' (id: B_Float)	None
a_1	Vector	socket 'A' (id: A_Vector)	None
b_1	Vector	socket 'B' (id: B_Vector)	None
a_2	Color	socket 'A' (id: A_Color)	None
b_2	Color	socket 'B' (id: B_Color)	None
a_3	Rotation	socket 'A' (id: A_Rotation)	None
b_3	Rotation	socket 'B' (id: B_Rotation)	None
factor	Vector	socket 'Factor' (id: Factor_Vector)	None
blend_type	Literal['Mix', 'Darken', 'Multiply', 'Color Burn', 'Lighten', 'Screen', 'Color Dodge', 'Add', 'Overlay', 'Soft Light', 'Linear Light', 'Difference', 'Exclusion', 'Subtract', 'Divide', 'Hue', 'Saturation', 'Color', 'Value']	parameter blend_type	'MIX'
clamp_factor	bool	parameter clamp_factor	True
clamp_result	bool	parameter clamp_result	False
data_type	Literal['Float', 'Vector', 'Color', 'Rotation']	parameter data_type	'FLOAT'
factor_mode	Literal['Uniform', 'Non-Uniform']	parameter factor_mode	'UNIFORM'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def mix(cls,
                a: Float = None,
                b: Float = None,
                a_1: Vector = None,
                b_1: Vector = None,
                a_2: Color = None,
                b_2: Color = None,
                a_3: Rotation = None,
                b_3: Rotation = None,
                factor: Vector = None,
                blend_type: Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'] = 'MIX',
                clamp_factor = True,
                clamp_result = False,
                data_type: Literal['FLOAT', 'VECTOR', 'RGBA', 'ROTATION'] = 'FLOAT',
                factor_mode: Literal['UNIFORM', 'NON_UNIFORM'] = 'UNIFORM'):
    """ > Node Mix

    Parameters
    ----------
    a : Float, optional
        socket 'A' (id: A_Float)

    b : Float, optional
        socket 'B' (id: B_Float)

    a_1 : Vector, optional
        socket 'A' (id: A_Vector)

    b_1 : Vector, optional
        socket 'B' (id: B_Vector)

    a_2 : Color, optional
        socket 'A' (id: A_Color)

    b_2 : Color, optional
        socket 'B' (id: B_Color)

    a_3 : Rotation, optional
        socket 'A' (id: A_Rotation)

    b_3 : Rotation, optional
        socket 'B' (id: B_Rotation)

    factor : Vector, optional
        socket 'Factor' (id: Factor_Vector)

    blend_type : Literal['Mix', 'Darken', 'Multiply', 'Color Burn', 'Lighten', 'Screen', 'Color Dodge', 'Add', 'Overlay', 'Soft Light', 'Linear Light', 'Difference', 'Exclusion', 'Subtract', 'Divide', 'Hue', 'Saturation', 'Color', 'Value']
        parameter `blend_type`

    clamp_factor : bool
        parameter `clamp_factor`

    clamp_result : bool
        parameter `clamp_result`

    data_type : Literal['Float', 'Vector', 'Color', 'Rotation']
        parameter `data_type`

    factor_mode : Literal['Uniform', 'Non-Uniform']
        parameter `factor_mode`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Mix', 'blend_type', blend_type, 'mix', ('MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'))
    utils.check_enum_arg('Mix', 'factor_mode', factor_mode, 'mix', ('UNIFORM', 'NON_UNIFORM'))
    node = Node('Mix', {'A_Float': a, 'B_Float': b, 'A_Vector': a_1, 'B_Vector': b_1, 'A_Color': a_2, 'B_Color': b_2, 'A_Rotation': a_3, 'B_Rotation': b_3, 'Factor_Vector': factor}, blend_type=blend_type, clamp_factor=clamp_factor, clamp_result=clamp_result, data_type=data_type, factor_mode=factor_mode)
    return node._out

mouse_position() classmethod

Node Mouse Position

Returns:

Type	Description
Integer	peer sockets: mouse_y_ (Integer), region_width_ (Integer), region_height_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def mouse_position(cls):
    """ > Node Mouse Position

    Returns
    -------
    Integer
        peer sockets: mouse_y_ (Integer), region_width_ (Integer), region_height_ (Integer)

    """
    node = Node('Mouse Position', )
    return node

multiply_matrices(matrix=None, matrix_1=None) classmethod

Node Multiply Matrices

Parameters:

Name	Type	Description	Default
matrix	Matrix	socket 'Matrix' (id: Matrix)	None
matrix_1	Matrix	socket 'Matrix' (id: Matrix_001)	None

Returns:

Type	Description
Matrix

Source code in core/generated/static_nd.py

@classmethod
def multiply_matrices(cls, matrix: Matrix = None, matrix_1: Matrix = None):
    """ > Node Multiply Matrices

    Parameters
    ----------
    matrix : Matrix, optional
        socket 'Matrix' (id: Matrix)

    matrix_1 : Matrix, optional
        socket 'Matrix' (id: Matrix_001)


    Returns
    -------
    Matrix
    """
    node = Node('Multiply Matrices', {'Matrix': matrix, 'Matrix_001': matrix_1})
    return node._out

named_attribute(name=None, data_type='FLOAT') classmethod

Node Named Attribute

Parameters:

Name	Type	Description	Default
name	String	socket 'Name' (id: Name)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float	peer sockets: exists_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def named_attribute(cls,
                name: String = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT'):
    """ > Node Named Attribute

    Parameters
    ----------
    name : String, optional
        socket 'Name' (id: Name)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
        parameter `data_type`


    Returns
    -------
    Float
        peer sockets: exists_ (Boolean)

    """
    node = Node('Named Attribute', {'Name': name}, data_type=data_type)
    return node._out

named_layer_selection(name=None) classmethod

Node Named Layer Selection

Parameters:

Name	Type	Description	Default
name	String	socket 'Name' (id: Name)	None

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def named_layer_selection(cls, name: String = None):
    """ > Node Named Layer Selection

    Parameters
    ----------
    name : String, optional
        socket 'Name' (id: Name)


    Returns
    -------
    Boolean
    """
    node = Node('Named Layer Selection', {'Name': name})
    return node._out

noise_texture(vector=None, w=None, scale=None, detail=None, roughness=None, lacunarity=None, offset=None, gain=None, distortion=None, noise_dimensions='3D', noise_type='FBM', normalize=True) classmethod

Node Noise Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
w	Float	socket 'W' (id: W)	None
scale	Float	socket 'Scale' (id: Scale)	None
detail	Float	socket 'Detail' (id: Detail)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
lacunarity	Float	socket 'Lacunarity' (id: Lacunarity)	None
offset	Float	socket 'Offset' (id: Offset)	None
gain	Float	socket 'Gain' (id: Gain)	None
distortion	Float	socket 'Distortion' (id: Distortion)	None
noise_dimensions	Literal['1D', '2D', '3D', '4D']	parameter noise_dimensions	'3D'
noise_type	Literal['Multifractal', 'Ridged Multifractal', 'Hybrid Multifractal', 'fBM', 'Hetero Terrain']	parameter noise_type	'FBM'
normalize	bool	parameter normalize	True

Returns:

Type	Description
Float	peer sockets: color_ (Color)

Source code in core/generated/static_nd.py

@classmethod
def noise_texture(cls,
                vector: Vector = None,
                w: Float = None,
                scale: Float = None,
                detail: Float = None,
                roughness: Float = None,
                lacunarity: Float = None,
                offset: Float = None,
                gain: Float = None,
                distortion: Float = None,
                noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D',
                noise_type: Literal['MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'] = 'FBM',
                normalize = True):
    """ > Node Noise Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    w : Float, optional
        socket 'W' (id: W)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    detail : Float, optional
        socket 'Detail' (id: Detail)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    lacunarity : Float, optional
        socket 'Lacunarity' (id: Lacunarity)

    offset : Float, optional
        socket 'Offset' (id: Offset)

    gain : Float, optional
        socket 'Gain' (id: Gain)

    distortion : Float, optional
        socket 'Distortion' (id: Distortion)

    noise_dimensions : Literal['1D', '2D', '3D', '4D']
        parameter `noise_dimensions`

    noise_type : Literal['Multifractal', 'Ridged Multifractal', 'Hybrid Multifractal', 'fBM', 'Hetero Terrain']
        parameter `noise_type`

    normalize : bool
        parameter `normalize`


    Returns
    -------
    Float
        peer sockets: color_ (Color)

    """
    utils.check_enum_arg('Noise Texture', 'noise_dimensions', noise_dimensions, 'noise_texture', ('1D', '2D', '3D', '4D'))
    utils.check_enum_arg('Noise Texture', 'noise_type', noise_type, 'noise_texture', ('MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'))
    node = Node('Noise Texture', {'Vector': vector, 'W': w, 'Scale': scale, 'Detail': detail, 'Roughness': roughness, 'Lacunarity': lacunarity, 'Offset': offset, 'Gain': gain, 'Distortion': distortion}, noise_dimensions=noise_dimensions, noise_type=noise_type, normalize=normalize)
    return node._out

normal()

Node Normal

Returns:

Type	Description
Vector	peer sockets: true_normal_ (Vector)

Source code in core/generated/static_nd.py

@utils.classproperty
def normal(self):
    """ > Node Normal

    Returns
    -------
    Vector
        peer sockets: true_normal_ (Vector)

    """
    node = Node('Normal', )
    return node._out

object(object=None) classmethod

Node Object

Parameters:

Name	Type	Description	Default
object	NoneType	parameter object	None

Returns:

Type	Description
Object

Source code in core/generated/static_nd.py

@classmethod
def object(cls, object = None):
    """ > Node Object

    Parameters
    ----------
    object : NoneType
        parameter `object`


    Returns
    -------
    Object
    """
    node = Node('Object', object=object)
    return node._out

object_info(object=None, as_instance=None, transform_space='ORIGINAL') classmethod

Node Object Info

Parameters:

Name	Type	Description	Default
object	Object	socket 'Object' (id: Object)	None
as_instance	Boolean	socket 'As Instance' (id: As Instance)	None
transform_space	Literal['Original', 'Relative']	parameter transform_space	'ORIGINAL'

Returns:

Type	Description
Matrix	peer sockets: location_ (Vector), rotation_ (Rotation), scale_ (Vector), geometry_ (Geometry)

Source code in core/generated/static_nd.py

@classmethod
def object_info(cls,
                object: Object = None,
                as_instance: Boolean = None,
                transform_space: Literal['ORIGINAL', 'RELATIVE'] = 'ORIGINAL'):
    """ > Node Object Info

    Parameters
    ----------
    object : Object, optional
        socket 'Object' (id: Object)

    as_instance : Boolean, optional
        socket 'As Instance' (id: As Instance)

    transform_space : Literal['Original', 'Relative']
        parameter `transform_space`


    Returns
    -------
    Matrix
        peer sockets: location_ (Vector), rotation_ (Rotation), scale_ (Vector), geometry_ (Geometry)

    """
    utils.check_enum_arg('Object Info', 'transform_space', transform_space, 'object_info', ('ORIGINAL', 'RELATIVE'))
    node = Node('Object Info', {'Object': object, 'As Instance': as_instance}, transform_space=transform_space)
    return node._out

offset_corner_in_face(corner_index=None, offset=None) classmethod

Node Offset Corner in Face

Parameters:

Name	Type	Description	Default
corner_index	Integer	socket 'Corner Index' (id: Corner Index)	None
offset	Integer	socket 'Offset' (id: Offset)	None

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def offset_corner_in_face(cls, corner_index: Integer = None, offset: Integer = None):
    """ > Node Offset Corner in Face

    Parameters
    ----------
    corner_index : Integer, optional
        socket 'Corner Index' (id: Corner Index)

    offset : Integer, optional
        socket 'Offset' (id: Offset)


    Returns
    -------
    Integer
    """
    node = Node('Offset Corner in Face', {'Corner Index': corner_index, 'Offset': offset})
    return node._out

offset_point_in_curve(point_index=None, offset=None) classmethod

Node Offset Point in Curve

Parameters:

Name	Type	Description	Default
point_index	Integer	socket 'Point Index' (id: Point Index)	None
offset	Integer	socket 'Offset' (id: Offset)	None

Returns:

Type	Description
Boolean	peer sockets: point_index_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def offset_point_in_curve(cls, point_index: Integer = None, offset: Integer = None):
    """ > Node Offset Point in Curve

    Parameters
    ----------
    point_index : Integer, optional
        socket 'Point Index' (id: Point Index)

    offset : Integer, optional
        socket 'Offset' (id: Offset)


    Returns
    -------
    Boolean
        peer sockets: point_index_ (Integer)

    """
    node = Node('Offset Point in Curve', {'Point Index': point_index, 'Offset': offset})
    return node._out

pack_uv_islands(uv=None, selection=None, margin=None, rotate=None, method=None, bottom_left=None, top_right=None) classmethod

Node Pack UV Islands

Parameters:

Name	Type	Description	Default
uv	Vector	socket 'UV' (id: UV)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
margin	Float	socket 'Margin' (id: Margin)	None
rotate	Boolean	socket 'Rotate' (id: Rotate)	None
method	menu='Bounding Box'	('Bounding Box', 'Convex Hull', 'Exact Shape')	None
bottom_left	Vector	socket 'Bottom Left' (id: Bottom Left)	None
top_right	Vector	socket 'Top Right' (id: Top Right)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def pack_uv_islands(cls,
                uv: Vector = None,
                selection: Boolean = None,
                margin: Float = None,
                rotate: Boolean = None,
                method: Literal['Bounding Box', 'Convex Hull', 'Exact Shape'] = None,
                bottom_left: Vector = None,
                top_right: Vector = None):
    """ > Node Pack UV Islands

    Parameters
    ----------
    uv : Vector, optional
        socket 'UV' (id: UV)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    margin : Float, optional
        socket 'Margin' (id: Margin)

    rotate : Boolean, optional
        socket 'Rotate' (id: Rotate)

    method : menu='Bounding Box', optional
        ('Bounding Box', 'Convex Hull', 'Exact Shape')

    bottom_left : Vector, optional
        socket 'Bottom Left' (id: Bottom Left)

    top_right : Vector, optional
        socket 'Top Right' (id: Top Right)


    Returns
    -------
    Vector
    """
    node = Node('Pack UV Islands', {'UV': uv, 'Selection': selection, 'Margin': margin, 'Rotate': rotate, 'Method': method, 'Bottom Left': bottom_left, 'Top Right': top_right})
    return node._out

points(count=None, position=None, radius=None) classmethod

Node Points

Parameters:

Name	Type	Description	Default
count	Integer	socket 'Count' (id: Count)	None
position	Vector	socket 'Position' (id: Position)	None
radius	Float	socket 'Radius' (id: Radius)	None

Returns:

Type	Description
Cloud

Source code in core/generated/static_nd.py

@classmethod
def points(cls, count: Integer = None, position: Vector = None, radius: Float = None):
    """ > Node Points

    Parameters
    ----------
    count : Integer, optional
        socket 'Count' (id: Count)

    position : Vector, optional
        socket 'Position' (id: Position)

    radius : Float, optional
        socket 'Radius' (id: Radius)


    Returns
    -------
    Cloud
    """
    node = Node('Points', {'Count': count, 'Position': position, 'Radius': radius})
    return node._out

points_of_curve(curve_index=None, weights=None, sort_index=None) classmethod

Node Points of Curve

Parameters:

Name	Type	Description	Default
curve_index	Integer	socket 'Curve Index' (id: Curve Index)	None
weights	Float	socket 'Weights' (id: Weights)	None
sort_index	Integer	socket 'Sort Index' (id: Sort Index)	None

Returns:

Type	Description
Integer	peer sockets: total_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def points_of_curve(cls,
                curve_index: Integer = None,
                weights: Float = None,
                sort_index: Integer = None):
    """ > Node Points of Curve

    Parameters
    ----------
    curve_index : Integer, optional
        socket 'Curve Index' (id: Curve Index)

    weights : Float, optional
        socket 'Weights' (id: Weights)

    sort_index : Integer, optional
        socket 'Sort Index' (id: Sort Index)


    Returns
    -------
    Integer
        peer sockets: total_ (Integer)

    """
    node = Node('Points of Curve', {'Curve Index': curve_index, 'Weights': weights, 'Sort Index': sort_index})
    return node._out

points_to_curves(points=None, curve_group_id=None, weight=None) classmethod

Node Points to Curves

Parameters:

Name	Type	Description	Default
points	Cloud	socket 'Points' (id: Points)	None
curve_group_id	Integer	socket 'Curve Group ID' (id: Curve Group ID)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def points_to_curves(cls,
                points: Cloud = None,
                curve_group_id: Integer = None,
                weight: Float = None):
    """ > Node Points to Curves

    Parameters
    ----------
    points : Cloud, optional
        socket 'Points' (id: Points)

    curve_group_id : Integer, optional
        socket 'Curve Group ID' (id: Curve Group ID)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    Curve
    """
    node = Node('Points to Curves', {'Points': points, 'Curve Group ID': curve_group_id, 'Weight': weight})
    return node._out

points_to_sdf_grid(points=None, radius=None, voxel_size=None) classmethod

Node Points to SDF Grid

Parameters:

Name	Type	Description	Default
points	Cloud	socket 'Points' (id: Points)	None
radius	Float	socket 'Radius' (id: Radius)	None
voxel_size	Float	socket 'Voxel Size' (id: Voxel Size)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def points_to_sdf_grid(cls, points: Cloud = None, radius: Float = None, voxel_size: Float = None):
    """ > Node Points to SDF Grid

    Parameters
    ----------
    points : Cloud, optional
        socket 'Points' (id: Points)

    radius : Float, optional
        socket 'Radius' (id: Radius)

    voxel_size : Float, optional
        socket 'Voxel Size' (id: Voxel Size)


    Returns
    -------
    Float
    """
    node = Node('Points to SDF Grid', {'Points': points, 'Radius': radius, 'Voxel Size': voxel_size})
    return node._out

points_to_vertices(points=None, selection=None) classmethod

Node Points to Vertices

Parameters:

Name	Type	Description	Default
points	Cloud	socket 'Points' (id: Points)	None
selection	Boolean	socket 'Selection' (id: Selection)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def points_to_vertices(cls, points: Cloud = None, selection: Boolean = None):
    """ > Node Points to Vertices

    Parameters
    ----------
    points : Cloud, optional
        socket 'Points' (id: Points)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)


    Returns
    -------
    Mesh
    """
    node = Node('Points to Vertices', {'Points': points, 'Selection': selection})
    return node._out

points_to_volume(points=None, density=None, resolution_mode=None, voxel_size=None, voxel_amount=None, radius=None) classmethod

Node Points to Volume

Parameters:

Name	Type	Description	Default
points	Cloud	socket 'Points' (id: Points)	None
density	Float	socket 'Density' (id: Density)	None
resolution_mode	menu='Amount'	('Amount', 'Size')	None
voxel_size	Float	socket 'Voxel Size' (id: Voxel Size)	None
voxel_amount	Float	socket 'Voxel Amount' (id: Voxel Amount)	None
radius	Float	socket 'Radius' (id: Radius)	None

Returns:

Type	Description
Volume

Source code in core/generated/static_nd.py

@classmethod
def points_to_volume(cls,
                points: Cloud = None,
                density: Float = None,
                resolution_mode: Literal['Amount', 'Size'] = None,
                voxel_size: Float = None,
                voxel_amount: Float = None,
                radius: Float = None):
    """ > Node Points to Volume

    Parameters
    ----------
    points : Cloud, optional
        socket 'Points' (id: Points)

    density : Float, optional
        socket 'Density' (id: Density)

    resolution_mode : menu='Amount', optional
        ('Amount', 'Size')

    voxel_size : Float, optional
        socket 'Voxel Size' (id: Voxel Size)

    voxel_amount : Float, optional
        socket 'Voxel Amount' (id: Voxel Amount)

    radius : Float, optional
        socket 'Radius' (id: Radius)


    Returns
    -------
    Volume
    """
    node = Node('Points to Volume', {'Points': points, 'Density': density, 'Resolution Mode': resolution_mode, 'Voxel Size': voxel_size, 'Voxel Amount': voxel_amount, 'Radius': radius})
    return node._out

position()

Node Position

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@utils.classproperty
def position(self):
    """ > Node Position

    Returns
    -------
    Vector
    """
    node = Node('Position', )
    return node._out

project_point(vector=None, transform=None) classmethod

Node Project Point

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
transform	Matrix	socket 'Transform' (id: Transform)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def project_point(cls, vector: Vector = None, transform: Matrix = None):
    """ > Node Project Point

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    transform : Matrix, optional
        socket 'Transform' (id: Transform)


    Returns
    -------
    Vector
    """
    node = Node('Project Point', {'Vector': vector, 'Transform': transform})
    return node._out

prune_grid(grid=None, mode=None, threshold=None, data_type='FLOAT') classmethod

Node Prune Grid

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
mode	menu='Threshold'	('Inactive', 'Threshold', 'SDF')	None
threshold	Float	socket 'Threshold' (id: Threshold)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def prune_grid(cls,
                grid: Float = None,
                mode: Literal['Inactive', 'Threshold', 'SDF'] = None,
                threshold: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Prune Grid

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    mode : menu='Threshold', optional
        ('Inactive', 'Threshold', 'SDF')

    threshold : Float, optional
        socket 'Threshold' (id: Threshold)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Prune Grid', {'Grid': grid, 'Mode': mode, 'Threshold': threshold}, data_type=data_type)
    return node._out

quadratic_bezier(resolution=None, start=None, middle=None, end=None) classmethod

Node Quadratic Bézier

Parameters:

Name	Type	Description	Default
resolution	Integer	socket 'Resolution' (id: Resolution)	None
start	Vector	socket 'Start' (id: Start)	None
middle	Vector	socket 'Middle' (id: Middle)	None
end	Vector	socket 'End' (id: End)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def quadratic_bezier(cls,
                resolution: Integer = None,
                start: Vector = None,
                middle: Vector = None,
                end: Vector = None):
    """ > Node Quadratic Bézier

    Parameters
    ----------
    resolution : Integer, optional
        socket 'Resolution' (id: Resolution)

    start : Vector, optional
        socket 'Start' (id: Start)

    middle : Vector, optional
        socket 'Middle' (id: Middle)

    end : Vector, optional
        socket 'End' (id: End)


    Returns
    -------
    Curve
    """
    node = Node('Quadratic Bézier', {'Resolution': resolution, 'Start': start, 'Middle': middle, 'End': end})
    return node._out

quadrilateral(width=None, height=None, bottom_width=None, top_width=None, offset=None, bottom_height=None, top_height=None, point_1=None, point_2=None, point_3=None, point_4=None, mode='RECTANGLE') classmethod

Node Quadrilateral

Parameters:

Name	Type	Description	Default
width	Float	socket 'Width' (id: Width)	None
height	Float	socket 'Height' (id: Height)	None
bottom_width	Float	socket 'Bottom Width' (id: Bottom Width)	None
top_width	Float	socket 'Top Width' (id: Top Width)	None
offset	Float	socket 'Offset' (id: Offset)	None
bottom_height	Float	socket 'Bottom Height' (id: Bottom Height)	None
top_height	Float	socket 'Top Height' (id: Top Height)	None
point_1	Vector	socket 'Point 1' (id: Point 1)	None
point_2	Vector	socket 'Point 2' (id: Point 2)	None
point_3	Vector	socket 'Point 3' (id: Point 3)	None
point_4	Vector	socket 'Point 4' (id: Point 4)	None
mode	Literal['Rectangle', 'Parallelogram', 'Trapezoid', 'Kite', 'Points']	parameter mode	'RECTANGLE'

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def quadrilateral(cls,
                width: Float = None,
                height: Float = None,
                bottom_width: Float = None,
                top_width: Float = None,
                offset: Float = None,
                bottom_height: Float = None,
                top_height: Float = None,
                point_1: Vector = None,
                point_2: Vector = None,
                point_3: Vector = None,
                point_4: Vector = None,
                mode: Literal['RECTANGLE', 'PARALLELOGRAM', 'TRAPEZOID', 'KITE', 'POINTS'] = 'RECTANGLE'):
    """ > Node Quadrilateral

    Parameters
    ----------
    width : Float, optional
        socket 'Width' (id: Width)

    height : Float, optional
        socket 'Height' (id: Height)

    bottom_width : Float, optional
        socket 'Bottom Width' (id: Bottom Width)

    top_width : Float, optional
        socket 'Top Width' (id: Top Width)

    offset : Float, optional
        socket 'Offset' (id: Offset)

    bottom_height : Float, optional
        socket 'Bottom Height' (id: Bottom Height)

    top_height : Float, optional
        socket 'Top Height' (id: Top Height)

    point_1 : Vector, optional
        socket 'Point 1' (id: Point 1)

    point_2 : Vector, optional
        socket 'Point 2' (id: Point 2)

    point_3 : Vector, optional
        socket 'Point 3' (id: Point 3)

    point_4 : Vector, optional
        socket 'Point 4' (id: Point 4)

    mode : Literal['Rectangle', 'Parallelogram', 'Trapezoid', 'Kite', 'Points']
        parameter `mode`


    Returns
    -------
    Curve
    """
    utils.check_enum_arg('Quadrilateral', 'mode', mode, 'quadrilateral', ('RECTANGLE', 'PARALLELOGRAM', 'TRAPEZOID', 'KITE', 'POINTS'))
    node = Node('Quadrilateral', {'Width': width, 'Height': height, 'Bottom Width': bottom_width, 'Top Width': top_width, 'Offset': offset, 'Bottom Height': bottom_height, 'Top Height': top_height, 'Point 1': point_1, 'Point 2': point_2, 'Point 3': point_3, 'Point 4': point_4}, mode=mode)
    return node._out

quaternion_to_rotation(w=None, x=None, y=None, z=None) classmethod

Node Quaternion to Rotation

Parameters:

Name	Type	Description	Default
w	Float	socket 'W' (id: W)	None
x	Float	socket 'X' (id: X)	None
y	Float	socket 'Y' (id: Y)	None
z	Float	socket 'Z' (id: Z)	None

Returns:

Type	Description
Rotation

Source code in core/generated/static_nd.py

@classmethod
def quaternion_to_rotation(cls, w: Float = None, x: Float = None, y: Float = None, z: Float = None):
    """ > Node Quaternion to Rotation

    Parameters
    ----------
    w : Float, optional
        socket 'W' (id: W)

    x : Float, optional
        socket 'X' (id: X)

    y : Float, optional
        socket 'Y' (id: Y)

    z : Float, optional
        socket 'Z' (id: Z)


    Returns
    -------
    Rotation
    """
    node = Node('Quaternion to Rotation', {'W': w, 'X': x, 'Y': y, 'Z': z})
    return node._out

radial_tiling(vector=None, sides=None, roundness=None, normalize=False) classmethod

Node Radial Tiling

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
sides	Float	socket 'Sides' (id: Sides)	None
roundness	Float	socket 'Roundness' (id: Roundness)	None
normalize	bool	parameter normalize	False

Returns:

Type	Description
Vector	peer sockets: segment_id_ (Float), segment_width_ (Float), segment_rotation_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def radial_tiling(cls,
                vector: Vector = None,
                sides: Float = None,
                roundness: Float = None,
                normalize = False):
    """ > Node Radial Tiling

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    sides : Float, optional
        socket 'Sides' (id: Sides)

    roundness : Float, optional
        socket 'Roundness' (id: Roundness)

    normalize : bool
        parameter `normalize`


    Returns
    -------
    Vector
        peer sockets: segment_id_ (Float), segment_width_ (Float), segment_rotation_ (Float)

    """
    node = Node('Radial Tiling', {'Vector': vector, 'Sides': sides, 'Roundness': roundness}, normalize=normalize)
    return node._out

radius()

Node Radius

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@utils.classproperty
def radius(self):
    """ > Node Radius

    Returns
    -------
    Float
    """
    node = Node('Radius', )
    return node._out

random_value(min=None, max=None, min_1=None, max_1=None, min_2=None, max_2=None, probability=None, id=None, seed=None, data_type='FLOAT') classmethod

Node Random Value

Parameters:

Name	Type	Description	Default
min	Vector	socket 'Min' (id: Min)	None
max	Vector	socket 'Max' (id: Max)	None
min_1	Float	socket 'Min' (id: Min_001)	None
max_1	Float	socket 'Max' (id: Max_001)	None
min_2	Integer	socket 'Min' (id: Min_002)	None
max_2	Integer	socket 'Max' (id: Max_002)	None
probability	Float	socket 'Probability' (id: Probability)	None
id	Integer	socket 'ID' (id: ID)	None
seed	Integer	socket 'Seed' (id: Seed)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def random_value(cls,
                min: Vector = None,
                max: Vector = None,
                min_1: Float = None,
                max_1: Float = None,
                min_2: Integer = None,
                max_2: Integer = None,
                probability: Float = None,
                id: Integer = None,
                seed: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR'] = 'FLOAT'):
    """ > Node Random Value

    Parameters
    ----------
    min : Vector, optional
        socket 'Min' (id: Min)

    max : Vector, optional
        socket 'Max' (id: Max)

    min_1 : Float, optional
        socket 'Min' (id: Min_001)

    max_1 : Float, optional
        socket 'Max' (id: Max_001)

    min_2 : Integer, optional
        socket 'Min' (id: Min_002)

    max_2 : Integer, optional
        socket 'Max' (id: Max_002)

    probability : Float, optional
        socket 'Probability' (id: Probability)

    id : Integer, optional
        socket 'ID' (id: ID)

    seed : Integer, optional
        socket 'Seed' (id: Seed)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Random Value', {'Min': min, 'Max': max, 'Min_001': min_1, 'Max_001': max_1, 'Min_002': min_2, 'Max_002': max_2, 'Probability': probability, 'ID': id, 'Seed': seed}, data_type=data_type)
    return node._out

raycast(target_geometry=None, attribute=None, interpolation=None, source_position=None, ray_direction=None, ray_length=None, data_type='FLOAT') classmethod

Node Raycast

Parameters:

Name	Type	Description	Default
target_geometry	Geometry	socket 'Target Geometry' (id: Target Geometry)	None
attribute	Float	socket 'Attribute' (id: Attribute)	None
interpolation	menu='Interpolated'	('Interpolated', 'Nearest')	None
source_position	Vector	socket 'Source Position' (id: Source Position)	None
ray_direction	Vector	socket 'Ray Direction' (id: Ray Direction)	None
ray_length	Float	socket 'Ray Length' (id: Ray Length)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']	parameter data_type	'FLOAT'

Returns:

Type	Description
Boolean	peer sockets: hit_position_ (Vector), hit_normal_ (Vector), hit_distance_ (Float), attribute_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def raycast(cls,
                target_geometry: Geometry = None,
                attribute: Float = None,
                interpolation: Literal['Interpolated', 'Nearest'] = None,
                source_position: Vector = None,
                ray_direction: Vector = None,
                ray_length: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT'):
    """ > Node Raycast

    Parameters
    ----------
    target_geometry : Geometry, optional
        socket 'Target Geometry' (id: Target Geometry)

    attribute : Float, optional
        socket 'Attribute' (id: Attribute)

    interpolation : menu='Interpolated', optional
        ('Interpolated', 'Nearest')

    source_position : Vector, optional
        socket 'Source Position' (id: Source Position)

    ray_direction : Vector, optional
        socket 'Ray Direction' (id: Ray Direction)

    ray_length : Float, optional
        socket 'Ray Length' (id: Ray Length)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
        parameter `data_type`


    Returns
    -------
    Boolean
        peer sockets: hit_position_ (Vector), hit_normal_ (Vector), hit_distance_ (Float), attribute_ (Float)

    """
    node = Node('Raycast', {'Target Geometry': target_geometry, 'Attribute': attribute, 'Interpolation': interpolation, 'Source Position': source_position, 'Ray Direction': ray_direction, 'Ray Length': ray_length}, data_type=data_type)
    return node._out

realize_instances(geometry=None, selection=None, realize_all=None, depth=None, realize_to_point_domain=False) classmethod

Node Realize Instances

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
realize_all	Boolean	socket 'Realize All' (id: Realize All)	None
depth	Integer	socket 'Depth' (id: Depth)	None
realize_to_point_domain	bool	parameter realize_to_point_domain	False

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def realize_instances(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                realize_all: Boolean = None,
                depth: Integer = None,
                realize_to_point_domain = False):
    """ > Node Realize Instances

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    realize_all : Boolean, optional
        socket 'Realize All' (id: Realize All)

    depth : Integer, optional
        socket 'Depth' (id: Depth)

    realize_to_point_domain : bool
        parameter `realize_to_point_domain`


    Returns
    -------
    Geometry
    """
    node = Node('Realize Instances', {'Geometry': geometry, 'Selection': selection, 'Realize All': realize_all, 'Depth': depth}, realize_to_point_domain=realize_to_point_domain)
    return node._out

remove_named_attribute(geometry=None, pattern_mode=None, name=None) classmethod

Node Remove Named Attribute

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
pattern_mode	menu='Exact'	('Exact', 'Wildcard')	None
name	String	socket 'Name' (id: Name)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def remove_named_attribute(cls,
                geometry: Geometry = None,
                pattern_mode: Literal['Exact', 'Wildcard'] = None,
                name: String = None):
    """ > Node Remove Named Attribute

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    pattern_mode : menu='Exact', optional
        ('Exact', 'Wildcard')

    name : String, optional
        socket 'Name' (id: Name)


    Returns
    -------
    Geometry
    """
    node = Node('Remove Named Attribute', {'Geometry': geometry, 'Pattern Mode': pattern_mode, 'Name': name})
    return node._out

repeat_input(iterations=None) classmethod

Node Repeat Input

Parameters:

Name	Type	Description	Default
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def repeat_input(cls, iterations: Integer = None):
    """ > Node Repeat Input

    Parameters
    ----------
    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Integer
    """
    node = Node('Repeat Input', {'Iterations': iterations})
    return node._out

repeat_output(geometry=None, inspection_index=0) classmethod

Node Repeat Output

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Item_0)	None
inspection_index	int	parameter inspection_index	0

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def repeat_output(cls, geometry: Geometry = None, inspection_index = 0):
    """ > Node Repeat Output

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Item_0)

    inspection_index : int
        parameter `inspection_index`


    Returns
    -------
    Geometry
    """
    node = Node('Repeat Output', {'Item_0': geometry}, inspection_index=inspection_index)
    return node._out

replace_material(geometry=None, old=None, new=None) classmethod

Node Replace Material

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
old	Material	socket 'Old' (id: Old)	None
new	Material	socket 'New' (id: New)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def replace_material(cls, geometry: Geometry = None, old: Material = None, new: Material = None):
    """ > Node Replace Material

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    old : Material, optional
        socket 'Old' (id: Old)

    new : Material, optional
        socket 'New' (id: New)


    Returns
    -------
    Geometry
    """
    node = Node('Replace Material', {'Geometry': geometry, 'Old': old, 'New': new})
    return node._out

replace_string(string=None, find=None, replace=None) classmethod

Node Replace String

Parameters:

Name	Type	Description	Default
string	String	socket 'String' (id: String)	None
find	String	socket 'Find' (id: Find)	None
replace	String	socket 'Replace' (id: Replace)	None

Returns:

Type	Description
String

Source code in core/generated/static_nd.py

@classmethod
def replace_string(cls, string: String = None, find: String = None, replace: String = None):
    """ > Node Replace String

    Parameters
    ----------
    string : String, optional
        socket 'String' (id: String)

    find : String, optional
        socket 'Find' (id: Find)

    replace : String, optional
        socket 'Replace' (id: Replace)


    Returns
    -------
    String
    """
    node = Node('Replace String', {'String': string, 'Find': find, 'Replace': replace})
    return node._out

reroute(input=None, socket_idname='NodeSocketColor') classmethod

Node Reroute

Parameters:

Name	Type	Description	Default
input	Color	socket 'Input' (id: Input)	None
socket_idname	str	parameter socket_idname	'NodeSocketColor'

Returns:

Type	Description
Color

Source code in core/generated/static_nd.py

@classmethod
def reroute(cls, input: Color = None, socket_idname = 'NodeSocketColor'):
    """ > Node Reroute

    Parameters
    ----------
    input : Color, optional
        socket 'Input' (id: Input)

    socket_idname : str
        parameter `socket_idname`


    Returns
    -------
    Color
    """
    node = Node('Reroute', {'Input': input}, socket_idname=socket_idname)
    return node._out

resample_curve(curve=None, selection=None, mode=None, count=None, length=None, keep_last_segment=True) classmethod

Node Resample Curve

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
mode	menu='Count'	('Evaluated', 'Count', 'Length')	None
count	Integer	socket 'Count' (id: Count)	None
length	Float	socket 'Length' (id: Length)	None
keep_last_segment	bool	parameter keep_last_segment	True

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def resample_curve(cls,
                curve: Curve = None,
                selection: Boolean = None,
                mode: Literal['Evaluated', 'Count', 'Length'] = None,
                count: Integer = None,
                length: Float = None,
                keep_last_segment = True):
    """ > Node Resample Curve

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    mode : menu='Count', optional
        ('Evaluated', 'Count', 'Length')

    count : Integer, optional
        socket 'Count' (id: Count)

    length : Float, optional
        socket 'Length' (id: Length)

    keep_last_segment : bool
        parameter `keep_last_segment`


    Returns
    -------
    Curve
    """
    node = Node('Resample Curve', {'Curve': curve, 'Selection': selection, 'Mode': mode, 'Count': count, 'Length': length}, keep_last_segment=keep_last_segment)
    return node._out

reverse_curve(curve=None, selection=None) classmethod

Node Reverse Curve

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
selection	Boolean	socket 'Selection' (id: Selection)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def reverse_curve(cls, curve: Curve = None, selection: Boolean = None):
    """ > Node Reverse Curve

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)


    Returns
    -------
    Curve
    """
    node = Node('Reverse Curve', {'Curve': curve, 'Selection': selection})
    return node._out

rgb_curves(color=None, factor=None) classmethod

Node RGB Curves

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
factor	Float	socket 'Factor' (id: Fac)	None

Returns:

Type	Description
Color

Source code in core/generated/static_nd.py

@classmethod
def rgb_curves(cls, color: Color = None, factor: Float = None):
    """ > Node RGB Curves

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    factor : Float, optional
        socket 'Factor' (id: Fac)


    Returns
    -------
    Color
    """
    node = NodeCurves('RGB Curves', {'Color': color, 'Fac': factor})
    return node._out

rotate_instances(instances=None, selection=None, rotation=None, pivot_point=None, local_space=None) classmethod

Node Rotate Instances

Parameters:

Name	Type	Description	Default
instances	Instances	socket 'Instances' (id: Instances)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
rotation	Rotation	socket 'Rotation' (id: Rotation)	None
pivot_point	Vector	socket 'Pivot Point' (id: Pivot Point)	None
local_space	Boolean	socket 'Local Space' (id: Local Space)	None

Returns:

Type	Description
Instances

Source code in core/generated/static_nd.py

@classmethod
def rotate_instances(cls,
                instances: Instances = None,
                selection: Boolean = None,
                rotation: Rotation = None,
                pivot_point: Vector = None,
                local_space: Boolean = None):
    """ > Node Rotate Instances

    Parameters
    ----------
    instances : Instances, optional
        socket 'Instances' (id: Instances)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)

    pivot_point : Vector, optional
        socket 'Pivot Point' (id: Pivot Point)

    local_space : Boolean, optional
        socket 'Local Space' (id: Local Space)


    Returns
    -------
    Instances
    """
    node = Node('Rotate Instances', {'Instances': instances, 'Selection': selection, 'Rotation': rotation, 'Pivot Point': pivot_point, 'Local Space': local_space})
    return node._out

rotate_rotation(rotation=None, rotate_by=None, rotation_space='GLOBAL') classmethod

Node Rotate Rotation

Parameters:

Name	Type	Description	Default
rotation	Rotation	socket 'Rotation' (id: Rotation)	None
rotate_by	Rotation	socket 'Rotate By' (id: Rotate By)	None
rotation_space	Literal['Global', 'Local']	parameter rotation_space	'GLOBAL'

Returns:

Type	Description
Rotation

Source code in core/generated/static_nd.py

@classmethod
def rotate_rotation(cls,
                rotation: Rotation = None,
                rotate_by: Rotation = None,
                rotation_space: Literal['GLOBAL', 'LOCAL'] = 'GLOBAL'):
    """ > Node Rotate Rotation

    Parameters
    ----------
    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)

    rotate_by : Rotation, optional
        socket 'Rotate By' (id: Rotate By)

    rotation_space : Literal['Global', 'Local']
        parameter `rotation_space`


    Returns
    -------
    Rotation
    """
    utils.check_enum_arg('Rotate Rotation', 'rotation_space', rotation_space, 'rotate_rotation', ('GLOBAL', 'LOCAL'))
    node = Node('Rotate Rotation', {'Rotation': rotation, 'Rotate By': rotate_by}, rotation_space=rotation_space)
    return node._out

rotate_vector(vector=None, rotation=None) classmethod

Node Rotate Vector

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
rotation	Rotation	socket 'Rotation' (id: Rotation)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def rotate_vector(cls, vector: Vector = None, rotation: Rotation = None):
    """ > Node Rotate Vector

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)


    Returns
    -------
    Vector
    """
    node = Node('Rotate Vector', {'Vector': vector, 'Rotation': rotation})
    return node._out

rotation()

Node Rotation

Returns:

Type	Description
Rotation

Source code in core/generated/static_nd.py

@utils.classproperty
def rotation(self):
    """ > Node Rotation

    Returns
    -------
    Rotation
    """
    node = Node('Rotation', )
    return node._out

rotation_to_axis_angle(rotation=None) classmethod

Node Rotation to Axis Angle

Parameters:

Name	Type	Description	Default
rotation	Rotation	socket 'Rotation' (id: Rotation)	None

Returns:

Type	Description
Vector	peer sockets: angle_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def rotation_to_axis_angle(cls, rotation: Rotation = None):
    """ > Node Rotation to Axis Angle

    Parameters
    ----------
    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)


    Returns
    -------
    Vector
        peer sockets: angle_ (Float)

    """
    node = Node('Rotation to Axis Angle', {'Rotation': rotation})
    return node._out

rotation_to_euler(rotation=None) classmethod

Node Rotation to Euler

Parameters:

Name	Type	Description	Default
rotation	Rotation	socket 'Rotation' (id: Rotation)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def rotation_to_euler(cls, rotation: Rotation = None):
    """ > Node Rotation to Euler

    Parameters
    ----------
    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)


    Returns
    -------
    Vector
    """
    node = Node('Rotation to Euler', {'Rotation': rotation})
    return node._out

rotation_to_quaternion(rotation=None) classmethod

Node Rotation to Quaternion

Parameters:

Name	Type	Description	Default
rotation	Rotation	socket 'Rotation' (id: Rotation)	None

Returns:

Type	Description
Float	peer sockets: x_ (Float), y_ (Float), z_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def rotation_to_quaternion(cls, rotation: Rotation = None):
    """ > Node Rotation to Quaternion

    Parameters
    ----------
    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)


    Returns
    -------
    Float
        peer sockets: x_ (Float), y_ (Float), z_ (Float)

    """
    node = Node('Rotation to Quaternion', {'Rotation': rotation})
    return node._out

sample_curve(curves=None, value=None, length=None, curve_index=None, factor=None, data_type='FLOAT', mode='FACTOR', use_all_curves=False) classmethod

Node Sample Curve

Parameters:

Name	Type	Description	Default
curves	Curve	socket 'Curves' (id: Curves)	None
value	Float	socket 'Value' (id: Value)	None
length	Float	socket 'Length' (id: Length)	None
curve_index	Integer	socket 'Curve Index' (id: Curve Index)	None
factor	Float	socket 'Factor' (id: Factor)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']	parameter data_type	'FLOAT'
mode	Literal['Factor', 'Length']	parameter mode	'FACTOR'
use_all_curves	bool	parameter use_all_curves	False

Returns:

Type	Description
Float	peer sockets: position_ (Vector), tangent_ (Vector), normal_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def sample_curve(cls,
                curves: Curve = None,
                value: Float = None,
                length: Float = None,
                curve_index: Integer = None,
                factor: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
                mode: Literal['FACTOR', 'LENGTH'] = 'FACTOR',
                use_all_curves = False):
    """ > Node Sample Curve

    Parameters
    ----------
    curves : Curve, optional
        socket 'Curves' (id: Curves)

    value : Float, optional
        socket 'Value' (id: Value)

    length : Float, optional
        socket 'Length' (id: Length)

    curve_index : Integer, optional
        socket 'Curve Index' (id: Curve Index)

    factor : Float, optional
        socket 'Factor' (id: Factor)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
        parameter `data_type`

    mode : Literal['Factor', 'Length']
        parameter `mode`

    use_all_curves : bool
        parameter `use_all_curves`


    Returns
    -------
    Float
        peer sockets: position_ (Vector), tangent_ (Vector), normal_ (Vector)

    """
    utils.check_enum_arg('Sample Curve', 'mode', mode, 'sample_curve', ('FACTOR', 'LENGTH'))
    node = Node('Sample Curve', {'Curves': curves, 'Value': value, 'Length': length, 'Curve Index': curve_index, 'Factor': factor}, data_type=data_type, mode=mode, use_all_curves=use_all_curves)
    return node._out

sample_grid(grid=None, position=None, interpolation=None, data_type='FLOAT') classmethod

Node Sample Grid

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
position	Vector	socket 'Position' (id: Position)	None
interpolation	menu='Trilinear'	('Nearest Neighbor', 'Trilinear', 'Triquadratic')	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def sample_grid(cls,
                grid: Float = None,
                position: Vector = None,
                interpolation: Literal['Nearest Neighbor', 'Trilinear', 'Triquadratic'] = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Sample Grid

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    position : Vector, optional
        socket 'Position' (id: Position)

    interpolation : menu='Trilinear', optional
        ('Nearest Neighbor', 'Trilinear', 'Triquadratic')

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Sample Grid', {'Grid': grid, 'Position': position, 'Interpolation': interpolation}, data_type=data_type)
    return node._out

sample_grid_index(grid=None, x=None, y=None, z=None, data_type='FLOAT') classmethod

Node Sample Grid Index

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
x	Integer	socket 'X' (id: X)	None
y	Integer	socket 'Y' (id: Y)	None
z	Integer	socket 'Z' (id: Z)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def sample_grid_index(cls,
                grid: Float = None,
                x: Integer = None,
                y: Integer = None,
                z: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Sample Grid Index

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    x : Integer, optional
        socket 'X' (id: X)

    y : Integer, optional
        socket 'Y' (id: Y)

    z : Integer, optional
        socket 'Z' (id: Z)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Sample Grid Index', {'Grid': grid, 'X': x, 'Y': y, 'Z': z}, data_type=data_type)
    return node._out

sample_index(geometry=None, value=None, index=None, clamp=False, data_type='FLOAT', domain='POINT') classmethod

Node Sample Index

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
value	Float	socket 'Value' (id: Value)	None
index	Integer	socket 'Index' (id: Index)	None
clamp	bool	parameter clamp	False
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']	parameter data_type	'FLOAT'
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def sample_index(cls,
                geometry: Geometry = None,
                value: Float = None,
                index: Integer = None,
                clamp = False,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT',
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
    """ > Node Sample Index

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    value : Float, optional
        socket 'Value' (id: Value)

    index : Integer, optional
        socket 'Index' (id: Index)

    clamp : bool
        parameter `clamp`

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
        parameter `data_type`

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Sample Index', 'domain', domain, 'sample_index', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Sample Index', {'Geometry': geometry, 'Value': value, 'Index': index}, clamp=clamp, data_type=data_type, domain=domain)
    return node._out

sample_nearest(geometry=None, sample_position=None, domain='POINT') classmethod

Node Sample Nearest

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
sample_position	Vector	socket 'Sample Position' (id: Sample Position)	None
domain	Literal['Point', 'Edge', 'Face', 'Face Corner']	parameter domain	'POINT'

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def sample_nearest(cls,
                geometry: Geometry = None,
                sample_position: Vector = None,
                domain: Literal['POINT', 'EDGE', 'FACE', 'CORNER'] = 'POINT'):
    """ > Node Sample Nearest

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    sample_position : Vector, optional
        socket 'Sample Position' (id: Sample Position)

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner']
        parameter `domain`


    Returns
    -------
    Integer
    """
    utils.check_enum_arg('Sample Nearest', 'domain', domain, 'sample_nearest', ('POINT', 'EDGE', 'FACE', 'CORNER'))
    node = Node('Sample Nearest', {'Geometry': geometry, 'Sample Position': sample_position}, domain=domain)
    return node._out

sample_nearest_surface(mesh=None, value=None, group_id=None, sample_position=None, sample_group_id=None, data_type='FLOAT') classmethod

Node Sample Nearest Surface

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
value	Float	socket 'Value' (id: Value)	None
group_id	Integer	socket 'Group ID' (id: Group ID)	None
sample_position	Vector	socket 'Sample Position' (id: Sample Position)	None
sample_group_id	Integer	socket 'Sample Group ID' (id: Sample Group ID)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float	peer sockets: is_valid_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def sample_nearest_surface(cls,
                mesh: Mesh = None,
                value: Float = None,
                group_id: Integer = None,
                sample_position: Vector = None,
                sample_group_id: Integer = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT'):
    """ > Node Sample Nearest Surface

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    value : Float, optional
        socket 'Value' (id: Value)

    group_id : Integer, optional
        socket 'Group ID' (id: Group ID)

    sample_position : Vector, optional
        socket 'Sample Position' (id: Sample Position)

    sample_group_id : Integer, optional
        socket 'Sample Group ID' (id: Sample Group ID)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
        parameter `data_type`


    Returns
    -------
    Float
        peer sockets: is_valid_ (Boolean)

    """
    node = Node('Sample Nearest Surface', {'Mesh': mesh, 'Value': value, 'Group ID': group_id, 'Sample Position': sample_position, 'Sample Group ID': sample_group_id}, data_type=data_type)
    return node._out

sample_uv_surface(mesh=None, value=None, uv_map=None, sample_uv=None, data_type='FLOAT') classmethod

Node Sample UV Surface

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
value	Float	socket 'Value' (id: Value)	None
uv_map	Vector	socket 'UV Map' (id: Source UV Map)	None
sample_uv	Vector	socket 'Sample UV' (id: Sample UV)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float	peer sockets: is_valid_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def sample_uv_surface(cls,
                mesh: Mesh = None,
                value: Float = None,
                uv_map: Vector = None,
                sample_uv: Vector = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'FLOAT_VECTOR', 'FLOAT_COLOR', 'QUATERNION', 'FLOAT4X4'] = 'FLOAT'):
    """ > Node Sample UV Surface

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    value : Float, optional
        socket 'Value' (id: Value)

    uv_map : Vector, optional
        socket 'UV Map' (id: Source UV Map)

    sample_uv : Vector, optional
        socket 'Sample UV' (id: Sample UV)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix']
        parameter `data_type`


    Returns
    -------
    Float
        peer sockets: is_valid_ (Boolean)

    """
    node = Node('Sample UV Surface', {'Mesh': mesh, 'Value': value, 'Source UV Map': uv_map, 'Sample UV': sample_uv}, data_type=data_type)
    return node._out

scale_elements(geometry=None, selection=None, scale=None, center=None, scale_mode=None, axis=None, domain='FACE') classmethod

Node Scale Elements

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
scale	Float	socket 'Scale' (id: Scale)	None
center	Vector	socket 'Center' (id: Center)	None
scale_mode	menu='Uniform'	('Uniform', 'Single Axis')	None
axis	Vector	socket 'Axis' (id: Axis)	None
domain	Literal['Face', 'Edge']	parameter domain	'FACE'

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def scale_elements(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                scale: Float = None,
                center: Vector = None,
                scale_mode: Literal['Uniform', 'Single Axis'] = None,
                axis: Vector = None,
                domain: Literal['FACE', 'EDGE'] = 'FACE'):
    """ > Node Scale Elements

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    center : Vector, optional
        socket 'Center' (id: Center)

    scale_mode : menu='Uniform', optional
        ('Uniform', 'Single Axis')

    axis : Vector, optional
        socket 'Axis' (id: Axis)

    domain : Literal['Face', 'Edge']
        parameter `domain`


    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('Scale Elements', 'domain', domain, 'scale_elements', ('FACE', 'EDGE'))
    node = Node('Scale Elements', {'Geometry': geometry, 'Selection': selection, 'Scale': scale, 'Center': center, 'Scale Mode': scale_mode, 'Axis': axis}, domain=domain)
    return node._out

scale_instances(instances=None, selection=None, scale=None, center=None, local_space=None) classmethod

Node Scale Instances

Parameters:

Name	Type	Description	Default
instances	Instances	socket 'Instances' (id: Instances)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
scale	Vector	socket 'Scale' (id: Scale)	None
center	Vector	socket 'Center' (id: Center)	None
local_space	Boolean	socket 'Local Space' (id: Local Space)	None

Returns:

Type	Description
Instances

Source code in core/generated/static_nd.py

@classmethod
def scale_instances(cls,
                instances: Instances = None,
                selection: Boolean = None,
                scale: Vector = None,
                center: Vector = None,
                local_space: Boolean = None):
    """ > Node Scale Instances

    Parameters
    ----------
    instances : Instances, optional
        socket 'Instances' (id: Instances)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    scale : Vector, optional
        socket 'Scale' (id: Scale)

    center : Vector, optional
        socket 'Center' (id: Center)

    local_space : Boolean, optional
        socket 'Local Space' (id: Local Space)


    Returns
    -------
    Instances
    """
    node = Node('Scale Instances', {'Instances': instances, 'Selection': selection, 'Scale': scale, 'Center': center, 'Local Space': local_space})
    return node._out

scene_time() classmethod

Node Scene Time

Returns:

Type	Description
Float	peer sockets: frame_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def scene_time(cls):
    """ > Node Scene Time

    Returns
    -------
    Float
        peer sockets: frame_ (Float)

    """
    node = Node('Scene Time', )
    return node

sdf_grid_boolean(*grid_2, grid_1=None, operation='DIFFERENCE') classmethod

Node SDF Grid Boolean

Parameters:

Name	Type	Description	Default
grid_1	Float	socket 'Grid 1' (id: Grid 1)	None
grid_2	Float	socket 'Grid 2' (id: Grid 2)	()
operation	Literal['Intersect', 'Union', 'Difference']	parameter operation	'DIFFERENCE'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def sdf_grid_boolean(cls,
                *grid_2: Float,
                grid_1: Float = None,
                operation: Literal['INTERSECT', 'UNION', 'DIFFERENCE'] = 'DIFFERENCE'):
    """ > Node SDF Grid Boolean

    Parameters
    ----------
    grid_1 : Float, optional
        socket 'Grid 1' (id: Grid 1)

    grid_2 : Float, optional
        socket 'Grid 2' (id: Grid 2)

    operation : Literal['Intersect', 'Union', 'Difference']
        parameter `operation`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('SDF Grid Boolean', 'operation', operation, 'sdf_grid_boolean', ('INTERSECT', 'UNION', 'DIFFERENCE'))
    node = Node('SDF Grid Boolean', {'Grid 1': grid_1, 'Grid 2': list(grid_2)}, operation=operation)
    return node._out

sdf_grid_fillet(grid=None, iterations=None) classmethod

Node SDF Grid Fillet

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def sdf_grid_fillet(cls, grid: Float = None, iterations: Integer = None):
    """ > Node SDF Grid Fillet

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Fillet', {'Grid': grid, 'Iterations': iterations})
    return node._out

sdf_grid_laplacian(grid=None, iterations=None) classmethod

Node SDF Grid Laplacian

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def sdf_grid_laplacian(cls, grid: Float = None, iterations: Integer = None):
    """ > Node SDF Grid Laplacian

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Laplacian', {'Grid': grid, 'Iterations': iterations})
    return node._out

sdf_grid_mean(grid=None, width=None, iterations=None) classmethod

Node SDF Grid Mean

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
width	Integer	socket 'Width' (id: Width)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def sdf_grid_mean(cls, grid: Float = None, width: Integer = None, iterations: Integer = None):
    """ > Node SDF Grid Mean

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    width : Integer, optional
        socket 'Width' (id: Width)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Mean', {'Grid': grid, 'Width': width, 'Iterations': iterations})
    return node._out

sdf_grid_mean_curvature(grid=None, iterations=None) classmethod

Node SDF Grid Mean Curvature

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def sdf_grid_mean_curvature(cls, grid: Float = None, iterations: Integer = None):
    """ > Node SDF Grid Mean Curvature

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Mean Curvature', {'Grid': grid, 'Iterations': iterations})
    return node._out

sdf_grid_median(grid=None, width=None, iterations=None) classmethod

Node SDF Grid Median

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
width	Integer	socket 'Width' (id: Width)	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def sdf_grid_median(cls, grid: Float = None, width: Integer = None, iterations: Integer = None):
    """ > Node SDF Grid Median

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    width : Integer, optional
        socket 'Width' (id: Width)

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Median', {'Grid': grid, 'Width': width, 'Iterations': iterations})
    return node._out

sdf_grid_offset(grid=None, distance=None) classmethod

Node SDF Grid Offset

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
distance	Float	socket 'Distance' (id: Distance)	None

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def sdf_grid_offset(cls, grid: Float = None, distance: Float = None):
    """ > Node SDF Grid Offset

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    distance : Float, optional
        socket 'Distance' (id: Distance)


    Returns
    -------
    Float
    """
    node = Node('SDF Grid Offset', {'Grid': grid, 'Distance': distance})
    return node._out

selection() classmethod

Node Selection

Returns:

Type	Description
Boolean	peer sockets: float_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def selection(cls):
    """ > Node Selection

    Returns
    -------
    Boolean
        peer sockets: float_ (Float)

    """
    node = Node('Selection', )
    return node

self_object()

Node Self Object

Returns:

Type	Description
Object

Source code in core/generated/static_nd.py

@utils.classproperty
def self_object(self):
    """ > Node Self Object

    Returns
    -------
    Object
    """
    node = Node('Self Object', )
    return node._out

separate_bundle(named_sockets={}, bundle=None, define_signature=False, **sockets) classmethod

Node Separate Bundle

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
bundle	Bundle	socket 'Bundle' (id: Bundle)	None
define_signature	bool	parameter define_signature	False
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@classmethod
def separate_bundle(cls,
                named_sockets: dict = {},
                bundle: Bundle = None,
                define_signature = False,
                **sockets):
    """ > Node Separate Bundle

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    bundle : Bundle, optional
        socket 'Bundle' (id: Bundle)

    define_signature : bool
        parameter `define_signature`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    None
    """
    node = Node('Separate Bundle', {'Bundle': bundle, **named_sockets}, define_signature=define_signature, **sockets)
    return node

separate_color(color=None, mode='RGB') classmethod

Node Separate Color

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
mode	Literal['RGB', 'HSV', 'HSL']	parameter mode	'RGB'

Returns:

Type	Description
Float	peer sockets: green_ (Float), blue_ (Float), alpha_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def separate_color(cls, color: Color = None, mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB'):
    """ > Node Separate Color

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    mode : Literal['RGB', 'HSV', 'HSL']
        parameter `mode`


    Returns
    -------
    Float
        peer sockets: green_ (Float), blue_ (Float), alpha_ (Float)

    """
    utils.check_enum_arg('Separate Color', 'mode', mode, 'separate_color', ('RGB', 'HSV', 'HSL'))
    node = Node('Separate Color', {'Color': color}, mode=mode)
    return node

separate_components(geometry=None) classmethod

Node Separate Components

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None

Returns:

Type	Description
Mesh	peer sockets: curve_ (Curve), grease_pencil_ (GreasePencil), point_cloud_ (Cloud), volume_ (Volume), instances_ (Instances)

Source code in core/generated/static_nd.py

@classmethod
def separate_components(cls, geometry: Geometry = None):
    """ > Node Separate Components

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)


    Returns
    -------
    Mesh
        peer sockets: curve_ (Curve), grease_pencil_ (GreasePencil), point_cloud_ (Cloud), volume_ (Volume), instances_ (Instances)

    """
    node = Node('Separate Components', {'Geometry': geometry})
    return node

separate_geometry(geometry=None, selection=None, domain='POINT') classmethod

Node Separate Geometry

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
domain	Literal['Point', 'Edge', 'Face', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Geometry	peer sockets: inverted_ (Geometry)

Source code in core/generated/static_nd.py

@classmethod
def separate_geometry(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
    """ > Node Separate Geometry

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    domain : Literal['Point', 'Edge', 'Face', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Geometry
        peer sockets: inverted_ (Geometry)

    """
    utils.check_enum_arg('Separate Geometry', 'domain', domain, 'separate_geometry', ('POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Separate Geometry', {'Geometry': geometry, 'Selection': selection}, domain=domain)
    return node

separate_matrix(matrix=None) classmethod

Node Separate Matrix

Parameters:

Name	Type	Description	Default
matrix	Matrix	socket 'Matrix' (id: Matrix)	None

Returns:

Type	Description
Float	peer sockets: column_1_row_2_ (Float), column_1_row_3_ (Float), column_1_row_4_ (Float), column_2_row_1_ (Float), column_2_row_2_ (Float), column_2_row_3_ (Float), column_2_row_4_ (Float), column_3_row_1_ (Float), column_3_row_2_ (Float), column_3_row_3_ (Float), column_3_row_4_ (Float), column_4_row_1_ (Float), column_4_row_2_ (Float), column_4_row_3_ (Float), column_4_row_4_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def separate_matrix(cls, matrix: Matrix = None):
    """ > Node Separate Matrix

    Parameters
    ----------
    matrix : Matrix, optional
        socket 'Matrix' (id: Matrix)


    Returns
    -------
    Float
        peer sockets: column_1_row_2_ (Float), column_1_row_3_ (Float), column_1_row_4_ (Float), column_2_row_1_ (Float), column_2_row_2_ (Float), column_2_row_3_ (Float), column_2_row_4_ (Float), column_3_row_1_ (Float), column_3_row_2_ (Float), column_3_row_3_ (Float), column_3_row_4_ (Float), column_4_row_1_ (Float), column_4_row_2_ (Float), column_4_row_3_ (Float), column_4_row_4_ (Float)

    """
    node = Node('Separate Matrix', {'Matrix': matrix})
    return node

separate_transform(transform=None) classmethod

Node Separate Transform

Parameters:

Name	Type	Description	Default
transform	Matrix	socket 'Transform' (id: Transform)	None

Returns:

Type	Description
Vector	peer sockets: rotation_ (Rotation), scale_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def separate_transform(cls, transform: Matrix = None):
    """ > Node Separate Transform

    Parameters
    ----------
    transform : Matrix, optional
        socket 'Transform' (id: Transform)


    Returns
    -------
    Vector
        peer sockets: rotation_ (Rotation), scale_ (Vector)

    """
    node = Node('Separate Transform', {'Transform': transform})
    return node

separate_xyz(vector=None) classmethod

Node Separate XYZ

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None

Returns:

Type	Description
Float	peer sockets: y_ (Float), z_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def separate_xyz(cls, vector: Vector = None):
    """ > Node Separate XYZ

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)


    Returns
    -------
    Float
        peer sockets: y_ (Float), z_ (Float)

    """
    node = Node('Separate XYZ', {'Vector': vector})
    return node

set_curve_normal(curve=None, selection=None, mode=None, normal=None) classmethod

Node Set Curve Normal

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
mode	menu='Minimum Twist'	('Minimum Twist', 'Z Up', 'Free')	None
normal	Vector	socket 'Normal' (id: Normal)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def set_curve_normal(cls,
                curve: Curve = None,
                selection: Boolean = None,
                mode: Literal['Minimum Twist', 'Z Up', 'Free'] = None,
                normal: Vector = None):
    """ > Node Set Curve Normal

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    mode : menu='Minimum Twist', optional
        ('Minimum Twist', 'Z Up', 'Free')

    normal : Vector, optional
        socket 'Normal' (id: Normal)


    Returns
    -------
    Curve
    """
    node = Node('Set Curve Normal', {'Curve': curve, 'Selection': selection, 'Mode': mode, 'Normal': normal})
    return node._out

set_curve_radius(curve=None, selection=None, radius=None) classmethod

Node Set Curve Radius

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
radius	Float	socket 'Radius' (id: Radius)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def set_curve_radius(cls, curve: Curve = None, selection: Boolean = None, radius: Float = None):
    """ > Node Set Curve Radius

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    radius : Float, optional
        socket 'Radius' (id: Radius)


    Returns
    -------
    Curve
    """
    node = Node('Set Curve Radius', {'Curve': curve, 'Selection': selection, 'Radius': radius})
    return node._out

set_curve_tilt(curve=None, selection=None, tilt=None) classmethod

Node Set Curve Tilt

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
tilt	Float	socket 'Tilt' (id: Tilt)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def set_curve_tilt(cls, curve: Curve = None, selection: Boolean = None, tilt: Float = None):
    """ > Node Set Curve Tilt

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    tilt : Float, optional
        socket 'Tilt' (id: Tilt)


    Returns
    -------
    Curve
    """
    node = Node('Set Curve Tilt', {'Curve': curve, 'Selection': selection, 'Tilt': tilt})
    return node._out

set_face_set(mesh=None, selection=None, face_set=None) classmethod

Node Set Face Set

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
face_set	Integer	socket 'Face Set' (id: Face Set)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def set_face_set(cls, mesh: Mesh = None, selection: Boolean = None, face_set: Integer = None):
    """ > Node Set Face Set

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    face_set : Integer, optional
        socket 'Face Set' (id: Face Set)


    Returns
    -------
    Mesh
    """
    node = Node('Set Face Set', {'Mesh': mesh, 'Selection': selection, 'Face Set': face_set})
    return node._out

set_geometry_bundle(geometry=None, bundle=None) classmethod

Node Set Geometry Bundle

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
bundle	Bundle	socket 'Bundle' (id: Bundle)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def set_geometry_bundle(cls, geometry: Geometry = None, bundle: Bundle = None):
    """ > Node Set Geometry Bundle

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    bundle : Bundle, optional
        socket 'Bundle' (id: Bundle)


    Returns
    -------
    Geometry
    """
    node = Node('Set Geometry Bundle', {'Geometry': geometry, 'Bundle': bundle})
    return node._out

set_geometry_name(geometry=None, name=None) classmethod

Node Set Geometry Name

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
name	String	socket 'Name' (id: Name)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def set_geometry_name(cls, geometry: Geometry = None, name: String = None):
    """ > Node Set Geometry Name

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    name : String, optional
        socket 'Name' (id: Name)


    Returns
    -------
    Geometry
    """
    node = Node('Set Geometry Name', {'Geometry': geometry, 'Name': name})
    return node._out

set_grease_pencil_color(grease_pencil=None, selection=None, color=None, opacity=None, mode='STROKE') classmethod

Node Set Grease Pencil Color

Parameters:

Name	Type	Description	Default
grease_pencil	GreasePencil	socket 'Grease Pencil' (id: Grease Pencil)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
color	Color	socket 'Color' (id: Color)	None
opacity	Float	socket 'Opacity' (id: Opacity)	None
mode	Literal['Stroke', 'Fill']	parameter mode	'STROKE'

Returns:

Type	Description
GreasePencil

Source code in core/generated/static_nd.py

@classmethod
def set_grease_pencil_color(cls,
                grease_pencil: GreasePencil = None,
                selection: Boolean = None,
                color: Color = None,
                opacity: Float = None,
                mode: Literal['STROKE', 'FILL'] = 'STROKE'):
    """ > Node Set Grease Pencil Color

    Parameters
    ----------
    grease_pencil : GreasePencil, optional
        socket 'Grease Pencil' (id: Grease Pencil)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    color : Color, optional
        socket 'Color' (id: Color)

    opacity : Float, optional
        socket 'Opacity' (id: Opacity)

    mode : Literal['Stroke', 'Fill']
        parameter `mode`


    Returns
    -------
    GreasePencil
    """
    utils.check_enum_arg('Set Grease Pencil Color', 'mode', mode, 'set_grease_pencil_color', ('STROKE', 'FILL'))
    node = Node('Set Grease Pencil Color', {'Grease Pencil': grease_pencil, 'Selection': selection, 'Color': color, 'Opacity': opacity}, mode=mode)
    return node._out

set_grease_pencil_depth(grease_pencil=None, depth_order='2D') classmethod

Node Set Grease Pencil Depth

Parameters:

Name	Type	Description	Default
grease_pencil	GreasePencil	socket 'Grease Pencil' (id: Grease Pencil)	None
depth_order	Literal['2D Layers', '3D Location']	parameter depth_order	'2D'

Returns:

Type	Description
GreasePencil

Source code in core/generated/static_nd.py

@classmethod
def set_grease_pencil_depth(cls,
                grease_pencil: GreasePencil = None,
                depth_order: Literal['2D', '3D'] = '2D'):
    """ > Node Set Grease Pencil Depth

    Parameters
    ----------
    grease_pencil : GreasePencil, optional
        socket 'Grease Pencil' (id: Grease Pencil)

    depth_order : Literal['2D Layers', '3D Location']
        parameter `depth_order`


    Returns
    -------
    GreasePencil
    """
    utils.check_enum_arg('Set Grease Pencil Depth', 'depth_order', depth_order, 'set_grease_pencil_depth', ('2D', '3D'))
    node = Node('Set Grease Pencil Depth', {'Grease Pencil': grease_pencil}, depth_order=depth_order)
    return node._out

set_grease_pencil_softness(grease_pencil=None, selection=None, softness=None) classmethod

Node Set Grease Pencil Softness

Parameters:

Name	Type	Description	Default
grease_pencil	GreasePencil	socket 'Grease Pencil' (id: Grease Pencil)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
softness	Float	socket 'Softness' (id: Softness)	None

Returns:

Type	Description
GreasePencil

Source code in core/generated/static_nd.py

@classmethod
def set_grease_pencil_softness(cls,
                grease_pencil: GreasePencil = None,
                selection: Boolean = None,
                softness: Float = None):
    """ > Node Set Grease Pencil Softness

    Parameters
    ----------
    grease_pencil : GreasePencil, optional
        socket 'Grease Pencil' (id: Grease Pencil)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    softness : Float, optional
        socket 'Softness' (id: Softness)


    Returns
    -------
    GreasePencil
    """
    node = Node('Set Grease Pencil Softness', {'Grease Pencil': grease_pencil, 'Selection': selection, 'Softness': softness})
    return node._out

set_grid_background(grid=None, background=None, update_inactive=None, data_type='FLOAT') classmethod

Node Set Grid Background

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
background	Float	socket 'Background' (id: Background)	None
update_inactive	Boolean	socket 'Update Inactive' (id: Update Inactive)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def set_grid_background(cls,
                grid: Float = None,
                background: Float = None,
                update_inactive: Boolean = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Set Grid Background

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    background : Float, optional
        socket 'Background' (id: Background)

    update_inactive : Boolean, optional
        socket 'Update Inactive' (id: Update Inactive)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Set Grid Background', {'Grid': grid, 'Background': background, 'Update Inactive': update_inactive}, data_type=data_type)
    return node._out

set_grid_transform(grid=None, transform=None, data_type='FLOAT') classmethod

Node Set Grid Transform

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
transform	Matrix	socket 'Transform' (id: Transform)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Boolean	peer sockets: grid_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def set_grid_transform(cls,
                grid: Float = None,
                transform: Matrix = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Set Grid Transform

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    transform : Matrix, optional
        socket 'Transform' (id: Transform)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Boolean
        peer sockets: grid_ (Float)

    """
    node = Node('Set Grid Transform', {'Grid': grid, 'Transform': transform}, data_type=data_type)
    return node._out

set_handle_positions(curve=None, selection=None, position=None, offset=None, mode='LEFT') classmethod

Node Set Handle Positions

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
position	Vector	socket 'Position' (id: Position)	None
offset	Vector	socket 'Offset' (id: Offset)	None
mode	Literal['Left', 'Right']	parameter mode	'LEFT'

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def set_handle_positions(cls,
                curve: Curve = None,
                selection: Boolean = None,
                position: Vector = None,
                offset: Vector = None,
                mode: Literal['LEFT', 'RIGHT'] = 'LEFT'):
    """ > Node Set Handle Positions

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    position : Vector, optional
        socket 'Position' (id: Position)

    offset : Vector, optional
        socket 'Offset' (id: Offset)

    mode : Literal['Left', 'Right']
        parameter `mode`


    Returns
    -------
    Curve
    """
    utils.check_enum_arg('Set Handle Positions', 'mode', mode, 'set_handle_positions', ('LEFT', 'RIGHT'))
    node = Node('Set Handle Positions', {'Curve': curve, 'Selection': selection, 'Position': position, 'Offset': offset}, mode=mode)
    return node._out

set_handle_type(curve=None, selection=None, handle_type='AUTO', mode={'LEFT', 'RIGHT'}) classmethod

Node Set Handle Type

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
handle_type	Literal['Free', 'Auto', 'Vector', 'Align']	parameter handle_type	'AUTO'
mode	set	parameter mode	{'LEFT', 'RIGHT'}

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def set_handle_type(cls,
                curve: Curve = None,
                selection: Boolean = None,
                handle_type: Literal['FREE', 'AUTO', 'VECTOR', 'ALIGN'] = 'AUTO',
                mode = {'LEFT', 'RIGHT'}):
    """ > Node Set Handle Type

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    handle_type : Literal['Free', 'Auto', 'Vector', 'Align']
        parameter `handle_type`

    mode : set
        parameter `mode`


    Returns
    -------
    Curve
    """
    utils.check_enum_arg('Set Handle Type', 'handle_type', handle_type, 'set_handle_type', ('FREE', 'AUTO', 'VECTOR', 'ALIGN'))
    node = Node('Set Handle Type', {'Curve': curve, 'Selection': selection}, handle_type=handle_type, mode=mode)
    return node._out

set_id(geometry=None, selection=None, id=None) classmethod

Node Set ID

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
id	Integer	socket 'ID' (id: ID)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def set_id(cls, geometry: Geometry = None, selection: Boolean = None, id: Integer = None):
    """ > Node Set ID

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    id : Integer, optional
        socket 'ID' (id: ID)


    Returns
    -------
    Geometry
    """
    node = Node('Set ID', {'Geometry': geometry, 'Selection': selection, 'ID': id})
    return node._out

set_instance_transform(instances=None, selection=None, transform=None) classmethod

Node Set Instance Transform

Parameters:

Name	Type	Description	Default
instances	Instances	socket 'Instances' (id: Instances)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
transform	Matrix	socket 'Transform' (id: Transform)	None

Returns:

Type	Description
Instances

Source code in core/generated/static_nd.py

@classmethod
def set_instance_transform(cls,
                instances: Instances = None,
                selection: Boolean = None,
                transform: Matrix = None):
    """ > Node Set Instance Transform

    Parameters
    ----------
    instances : Instances, optional
        socket 'Instances' (id: Instances)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    transform : Matrix, optional
        socket 'Transform' (id: Transform)


    Returns
    -------
    Instances
    """
    node = Node('Set Instance Transform', {'Instances': instances, 'Selection': selection, 'Transform': transform})
    return node._out

set_material(geometry=None, selection=None, material=None) classmethod

Node Set Material

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
material	Material	socket 'Material' (id: Material)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def set_material(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                material: Material = None):
    """ > Node Set Material

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    material : Material, optional
        socket 'Material' (id: Material)


    Returns
    -------
    Geometry
    """
    node = Node('Set Material', {'Geometry': geometry, 'Selection': selection, 'Material': material})
    return node._out

set_material_index(geometry=None, selection=None, material_index=None) classmethod

Node Set Material Index

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
material_index	Integer	socket 'Material Index' (id: Material Index)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def set_material_index(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                material_index: Integer = None):
    """ > Node Set Material Index

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    material_index : Integer, optional
        socket 'Material Index' (id: Material Index)


    Returns
    -------
    Geometry
    """
    node = Node('Set Material Index', {'Geometry': geometry, 'Selection': selection, 'Material Index': material_index})
    return node._out

set_mesh_normal(mesh=None, remove_custom=None, edge_sharpness=None, face_sharpness=None, domain='POINT', mode='SHARPNESS') classmethod

Node Set Mesh Normal

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
remove_custom	Boolean	socket 'Remove Custom' (id: Remove Custom)	None
edge_sharpness	Boolean	socket 'Edge Sharpness' (id: Edge Sharpness)	None
face_sharpness	Boolean	socket 'Face Sharpness' (id: Face Sharpness)	None
domain	Literal['Point', 'Face', 'Face Corner']	parameter domain	'POINT'
mode	Literal['Sharpness', 'Free', 'Tangent Space']	parameter mode	'SHARPNESS'

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def set_mesh_normal(cls,
                mesh: Mesh = None,
                remove_custom: Boolean = None,
                edge_sharpness: Boolean = None,
                face_sharpness: Boolean = None,
                domain: Literal['POINT', 'FACE', 'CORNER'] = 'POINT',
                mode: Literal['SHARPNESS', 'FREE', 'TANGENT_SPACE'] = 'SHARPNESS'):
    """ > Node Set Mesh Normal

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    remove_custom : Boolean, optional
        socket 'Remove Custom' (id: Remove Custom)

    edge_sharpness : Boolean, optional
        socket 'Edge Sharpness' (id: Edge Sharpness)

    face_sharpness : Boolean, optional
        socket 'Face Sharpness' (id: Face Sharpness)

    domain : Literal['Point', 'Face', 'Face Corner']
        parameter `domain`

    mode : Literal['Sharpness', 'Free', 'Tangent Space']
        parameter `mode`


    Returns
    -------
    Mesh
    """
    utils.check_enum_arg('Set Mesh Normal', 'domain', domain, 'set_mesh_normal', ('POINT', 'FACE', 'CORNER'))
    utils.check_enum_arg('Set Mesh Normal', 'mode', mode, 'set_mesh_normal', ('SHARPNESS', 'FREE', 'TANGENT_SPACE'))
    node = Node('Set Mesh Normal', {'Mesh': mesh, 'Remove Custom': remove_custom, 'Edge Sharpness': edge_sharpness, 'Face Sharpness': face_sharpness}, domain=domain, mode=mode)
    return node._out

set_point_radius(points=None, selection=None, radius=None) classmethod

Node Set Point Radius

Parameters:

Name	Type	Description	Default
points	Cloud	socket 'Points' (id: Points)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
radius	Float	socket 'Radius' (id: Radius)	None

Returns:

Type	Description
Cloud

Source code in core/generated/static_nd.py

@classmethod
def set_point_radius(cls, points: Cloud = None, selection: Boolean = None, radius: Float = None):
    """ > Node Set Point Radius

    Parameters
    ----------
    points : Cloud, optional
        socket 'Points' (id: Points)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    radius : Float, optional
        socket 'Radius' (id: Radius)


    Returns
    -------
    Cloud
    """
    node = Node('Set Point Radius', {'Points': points, 'Selection': selection, 'Radius': radius})
    return node._out

set_position(geometry=None, selection=None, position=None, offset=None) classmethod

Node Set Position

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
position	Vector	socket 'Position' (id: Position)	None
offset	Vector	socket 'Offset' (id: Offset)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def set_position(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                position: Vector = None,
                offset: Vector = None):
    """ > Node Set Position

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    position : Vector, optional
        socket 'Position' (id: Position)

    offset : Vector, optional
        socket 'Offset' (id: Offset)


    Returns
    -------
    Geometry
    """
    node = Node('Set Position', {'Geometry': geometry, 'Selection': selection, 'Position': position, 'Offset': offset})
    return node._out

set_selection(geometry=None, selection=None, domain='POINT', selection_type='BOOLEAN') classmethod

Node Set Selection

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
domain	Literal['Point', 'Edge', 'Face', 'Spline']	parameter domain	'POINT'
selection_type	Literal['Boolean', 'Float']	parameter selection_type	'BOOLEAN'

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def set_selection(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE'] = 'POINT',
                selection_type: Literal['BOOLEAN', 'FLOAT'] = 'BOOLEAN'):
    """ > Node Set Selection

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    domain : Literal['Point', 'Edge', 'Face', 'Spline']
        parameter `domain`

    selection_type : Literal['Boolean', 'Float']
        parameter `selection_type`


    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('Set Selection', 'domain', domain, 'set_selection', ('POINT', 'EDGE', 'FACE', 'CURVE'))
    utils.check_enum_arg('Set Selection', 'selection_type', selection_type, 'set_selection', ('BOOLEAN', 'FLOAT'))
    node = Node('Set Selection', {'Geometry': geometry, 'Selection': selection}, domain=domain, selection_type=selection_type)
    return node._out

set_shade_smooth(mesh=None, selection=None, shade_smooth=None, domain='FACE') classmethod

Node Set Shade Smooth

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
shade_smooth	Boolean	socket 'Shade Smooth' (id: Shade Smooth)	None
domain	Literal['Edge', 'Face']	parameter domain	'FACE'

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def set_shade_smooth(cls,
                mesh: Mesh = None,
                selection: Boolean = None,
                shade_smooth: Boolean = None,
                domain: Literal['EDGE', 'FACE'] = 'FACE'):
    """ > Node Set Shade Smooth

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    shade_smooth : Boolean, optional
        socket 'Shade Smooth' (id: Shade Smooth)

    domain : Literal['Edge', 'Face']
        parameter `domain`


    Returns
    -------
    Mesh
    """
    utils.check_enum_arg('Set Shade Smooth', 'domain', domain, 'set_shade_smooth', ('EDGE', 'FACE'))
    node = Node('Set Shade Smooth', {'Geometry': mesh, 'Selection': selection, 'Shade Smooth': shade_smooth}, domain=domain)
    return node._out

set_spline_cyclic(curve=None, selection=None, cyclic=None) classmethod

Node Set Spline Cyclic

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
cyclic	Boolean	socket 'Cyclic' (id: Cyclic)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def set_spline_cyclic(cls, curve: Curve = None, selection: Boolean = None, cyclic: Boolean = None):
    """ > Node Set Spline Cyclic

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    cyclic : Boolean, optional
        socket 'Cyclic' (id: Cyclic)


    Returns
    -------
    Curve
    """
    node = Node('Set Spline Cyclic', {'Geometry': curve, 'Selection': selection, 'Cyclic': cyclic})
    return node._out

set_spline_resolution(curve=None, selection=None, resolution=None) classmethod

Node Set Spline Resolution

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
resolution	Integer	socket 'Resolution' (id: Resolution)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def set_spline_resolution(cls,
                curve: Curve = None,
                selection: Boolean = None,
                resolution: Integer = None):
    """ > Node Set Spline Resolution

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    resolution : Integer, optional
        socket 'Resolution' (id: Resolution)


    Returns
    -------
    Curve
    """
    node = Node('Set Spline Resolution', {'Geometry': curve, 'Selection': selection, 'Resolution': resolution})
    return node._out

set_spline_type(curve=None, selection=None, spline_type='POLY') classmethod

Node Set Spline Type

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
spline_type	Literal['Catmull Rom', 'Poly', 'Bézier', 'NURBS']	parameter spline_type	'POLY'

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def set_spline_type(cls,
                curve: Curve = None,
                selection: Boolean = None,
                spline_type: Literal['CATMULL_ROM', 'POLY', 'BEZIER', 'NURBS'] = 'POLY'):
    """ > Node Set Spline Type

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    spline_type : Literal['Catmull Rom', 'Poly', 'Bézier', 'NURBS']
        parameter `spline_type`


    Returns
    -------
    Curve
    """
    utils.check_enum_arg('Set Spline Type', 'spline_type', spline_type, 'set_spline_type', ('CATMULL_ROM', 'POLY', 'BEZIER', 'NURBS'))
    node = Node('Set Spline Type', {'Curve': curve, 'Selection': selection}, spline_type=spline_type)
    return node._out

shortest_edge_paths(end_vertex=None, edge_cost=None) classmethod

Node Shortest Edge Paths

Parameters:

Name	Type	Description	Default
end_vertex	Boolean	socket 'End Vertex' (id: End Vertex)	None
edge_cost	Float	socket 'Edge Cost' (id: Edge Cost)	None

Returns:

Type	Description
Integer	peer sockets: total_cost_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def shortest_edge_paths(cls, end_vertex: Boolean = None, edge_cost: Float = None):
    """ > Node Shortest Edge Paths

    Parameters
    ----------
    end_vertex : Boolean, optional
        socket 'End Vertex' (id: End Vertex)

    edge_cost : Float, optional
        socket 'Edge Cost' (id: Edge Cost)


    Returns
    -------
    Integer
        peer sockets: total_cost_ (Float)

    """
    node = Node('Shortest Edge Paths', {'End Vertex': end_vertex, 'Edge Cost': edge_cost})
    return node._out

simulation_input()

Node Simulation Input

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@utils.classproperty
def simulation_input(self):
    """ > Node Simulation Input

    Returns
    -------
    Float
    """
    node = Node('Simulation Input', )
    return node._out

simulation_output(skip=None, geometry=None) classmethod

Node Simulation Output

Parameters:

Name	Type	Description	Default
skip	Boolean	socket 'Skip' (id: Skip)	None
geometry	Geometry	socket 'Geometry' (id: Item_0)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def simulation_output(cls, skip: Boolean = None, geometry: Geometry = None):
    """ > Node Simulation Output

    Parameters
    ----------
    skip : Boolean, optional
        socket 'Skip' (id: Skip)

    geometry : Geometry, optional
        socket 'Geometry' (id: Item_0)


    Returns
    -------
    Geometry
    """
    node = Node('Simulation Output', {'Skip': skip, 'Item_0': geometry})
    return node._out

slice_string(string=None, position=None, length=None) classmethod

Node Slice String

Parameters:

Name	Type	Description	Default
string	String	socket 'String' (id: String)	None
position	Integer	socket 'Position' (id: Position)	None
length	Integer	socket 'Length' (id: Length)	None

Returns:

Type	Description
String

Source code in core/generated/static_nd.py

@classmethod
def slice_string(cls, string: String = None, position: Integer = None, length: Integer = None):
    """ > Node Slice String

    Parameters
    ----------
    string : String, optional
        socket 'String' (id: String)

    position : Integer, optional
        socket 'Position' (id: Position)

    length : Integer, optional
        socket 'Length' (id: Length)


    Returns
    -------
    String
    """
    node = Node('Slice String', {'String': string, 'Position': position, 'Length': length})
    return node._out

sort_elements(geometry=None, selection=None, group_id=None, sort_weight=None, domain='POINT') classmethod

Node Sort Elements

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
group_id	Integer	socket 'Group ID' (id: Group ID)	None
sort_weight	Float	socket 'Sort Weight' (id: Sort Weight)	None
domain	Literal['Point', 'Edge', 'Face', 'Spline', 'Instance']	parameter domain	'POINT'

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def sort_elements(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                group_id: Integer = None,
                sort_weight: Float = None,
                domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE'] = 'POINT'):
    """ > Node Sort Elements

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    group_id : Integer, optional
        socket 'Group ID' (id: Group ID)

    sort_weight : Float, optional
        socket 'Sort Weight' (id: Sort Weight)

    domain : Literal['Point', 'Edge', 'Face', 'Spline', 'Instance']
        parameter `domain`


    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('Sort Elements', 'domain', domain, 'sort_elements', ('POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE'))
    node = Node('Sort Elements', {'Geometry': geometry, 'Selection': selection, 'Group ID': group_id, 'Sort Weight': sort_weight}, domain=domain)
    return node._out

special_characters() classmethod

Node Special Characters

Returns:

Type	Description
String	peer sockets: tab_ (String)

Source code in core/generated/static_nd.py

@classmethod
def special_characters(cls):
    """ > Node Special Characters

    Returns
    -------
    String
        peer sockets: tab_ (String)

    """
    node = Node('Special Characters', )
    return node

spiral(resolution=None, rotations=None, start_radius=None, end_radius=None, height=None, reverse=None) classmethod

Node Spiral

Parameters:

Name	Type	Description	Default
resolution	Integer	socket 'Resolution' (id: Resolution)	None
rotations	Float	socket 'Rotations' (id: Rotations)	None
start_radius	Float	socket 'Start Radius' (id: Start Radius)	None
end_radius	Float	socket 'End Radius' (id: End Radius)	None
height	Float	socket 'Height' (id: Height)	None
reverse	Boolean	socket 'Reverse' (id: Reverse)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def spiral(cls,
                resolution: Integer = None,
                rotations: Float = None,
                start_radius: Float = None,
                end_radius: Float = None,
                height: Float = None,
                reverse: Boolean = None):
    """ > Node Spiral

    Parameters
    ----------
    resolution : Integer, optional
        socket 'Resolution' (id: Resolution)

    rotations : Float, optional
        socket 'Rotations' (id: Rotations)

    start_radius : Float, optional
        socket 'Start Radius' (id: Start Radius)

    end_radius : Float, optional
        socket 'End Radius' (id: End Radius)

    height : Float, optional
        socket 'Height' (id: Height)

    reverse : Boolean, optional
        socket 'Reverse' (id: Reverse)


    Returns
    -------
    Curve
    """
    node = Node('Spiral', {'Resolution': resolution, 'Rotations': rotations, 'Start Radius': start_radius, 'End Radius': end_radius, 'Height': height, 'Reverse': reverse})
    return node._out

spline_length() classmethod

Node Spline Length

Returns:

Type	Description
Float	peer sockets: point_count_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def spline_length(cls):
    """ > Node Spline Length

    Returns
    -------
    Float
        peer sockets: point_count_ (Integer)

    """
    node = Node('Spline Length', )
    return node

spline_parameter() classmethod

Node Spline Parameter

Returns:

Type	Description
Float	peer sockets: length_ (Float), index_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def spline_parameter(cls):
    """ > Node Spline Parameter

    Returns
    -------
    Float
        peer sockets: length_ (Float), index_ (Integer)

    """
    node = Node('Spline Parameter', )
    return node

spline_resolution()

Node Spline Resolution

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@utils.classproperty
def spline_resolution(self):
    """ > Node Spline Resolution

    Returns
    -------
    Integer
    """
    node = Node('Spline Resolution', )
    return node._out

split_edges(mesh=None, selection=None) classmethod

Node Split Edges

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
selection	Boolean	socket 'Selection' (id: Selection)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def split_edges(cls, mesh: Mesh = None, selection: Boolean = None):
    """ > Node Split Edges

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)


    Returns
    -------
    Mesh
    """
    node = Node('Split Edges', {'Mesh': mesh, 'Selection': selection})
    return node._out

split_to_instances(geometry=None, selection=None, group_id=None, domain='POINT') classmethod

Node Split to Instances

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
group_id	Integer	socket 'Group ID' (id: Group ID)	None
domain	Literal['Point', 'Edge', 'Face', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Instances	peer sockets: group_id_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def split_to_instances(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                group_id: Integer = None,
                domain: Literal['POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'] = 'POINT'):
    """ > Node Split to Instances

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    group_id : Integer, optional
        socket 'Group ID' (id: Group ID)

    domain : Literal['Point', 'Edge', 'Face', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Instances
        peer sockets: group_id_ (Integer)

    """
    utils.check_enum_arg('Split to Instances', 'domain', domain, 'split_to_instances', ('POINT', 'EDGE', 'FACE', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Split to Instances', {'Geometry': geometry, 'Selection': selection, 'Group ID': group_id}, domain=domain)
    return node._out

star(points=None, inner_radius=None, outer_radius=None, twist=None) classmethod

Node Star

Parameters:

Name	Type	Description	Default
points	Integer	socket 'Points' (id: Points)	None
inner_radius	Float	socket 'Inner Radius' (id: Inner Radius)	None
outer_radius	Float	socket 'Outer Radius' (id: Outer Radius)	None
twist	Float	socket 'Twist' (id: Twist)	None

Returns:

Type	Description
Curve	peer sockets: outer_points_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def star(cls,
                points: Integer = None,
                inner_radius: Float = None,
                outer_radius: Float = None,
                twist: Float = None):
    """ > Node Star

    Parameters
    ----------
    points : Integer, optional
        socket 'Points' (id: Points)

    inner_radius : Float, optional
        socket 'Inner Radius' (id: Inner Radius)

    outer_radius : Float, optional
        socket 'Outer Radius' (id: Outer Radius)

    twist : Float, optional
        socket 'Twist' (id: Twist)


    Returns
    -------
    Curve
        peer sockets: outer_points_ (Boolean)

    """
    node = Node('Star', {'Points': points, 'Inner Radius': inner_radius, 'Outer Radius': outer_radius, 'Twist': twist})
    return node._out

store_bundle_item(bundle=None, path=None, item=None, socket_type='FLOAT', structure_type='AUTO') classmethod

Node Store Bundle Item

Parameters:

Name	Type	Description	Default
bundle	Bundle	socket 'Bundle' (id: Bundle)	None
path	String	socket 'Path' (id: Path)	None
item	Float	socket 'Item' (id: Item)	None
socket_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']	parameter socket_type	'FLOAT'
structure_type	Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']	parameter structure_type	'AUTO'

Returns:

Type	Description
Bundle

Source code in core/generated/static_nd.py

@classmethod
def store_bundle_item(cls,
                bundle: Bundle = None,
                path: String = None,
                item: Float = None,
                socket_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT',
                structure_type: Literal['AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'] = 'AUTO'):
    """ > Node Store Bundle Item

    Parameters
    ----------
    bundle : Bundle, optional
        socket 'Bundle' (id: Bundle)

    path : String, optional
        socket 'Path' (id: Path)

    item : Float, optional
        socket 'Item' (id: Item)

    socket_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
        parameter `socket_type`

    structure_type : Literal['Auto', 'Dynamic', 'Field', 'Grid', 'List', 'Single']
        parameter `structure_type`


    Returns
    -------
    Bundle
    """
    utils.check_enum_arg('Store Bundle Item', 'socket_type', socket_type, 'store_bundle_item', ('FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'))
    utils.check_enum_arg('Store Bundle Item', 'structure_type', structure_type, 'store_bundle_item', ('AUTO', 'DYNAMIC', 'FIELD', 'GRID', 'LIST', 'SINGLE'))
    node = Node('Store Bundle Item', {'Bundle': bundle, 'Path': path, 'Item': item}, socket_type=socket_type, structure_type=structure_type)
    return node._out

store_named_attribute(geometry=None, selection=None, name=None, value=None, data_type='FLOAT', domain='POINT') classmethod

Node Store Named Attribute

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
name	String	socket 'Name' (id: Name)	None
value	Float	socket 'Value' (id: Value)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix', '8-Bit Integer', '2D Vector', 'Byte Color']	parameter data_type	'FLOAT'
domain	Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'POINT'

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def store_named_attribute(cls,
                geometry: Geometry = None,
                selection: Boolean = None,
                name: String = None,
                value: Float = None,
                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'):
    """ > Node Store Named Attribute

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    name : String, optional
        socket 'Name' (id: Name)

    value : Float, optional
        socket 'Value' (id: Value)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Quaternion', '4x4 Matrix', '8-Bit Integer', '2D Vector', 'Byte Color']
        parameter `data_type`

    domain : Literal['Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`


    Returns
    -------
    Geometry
    """
    utils.check_enum_arg('Store Named Attribute', 'domain', domain, 'store_named_attribute', ('POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Store Named Attribute', {'Geometry': geometry, 'Selection': selection, 'Name': name, 'Value': value}, data_type=data_type, domain=domain)
    return node._out

store_named_grid(volume=None, name=None, grid=None, data_type='FLOAT') classmethod

Node Store Named Grid

Parameters:

Name	Type	Description	Default
volume	Volume	socket 'Volume' (id: Volume)	None
name	String	socket 'Name' (id: Name)	None
grid	Float	socket 'Grid' (id: Grid)	None
data_type	Literal['Boolean', 'Float', 'Integer', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Volume

Source code in core/generated/static_nd.py

@classmethod
def store_named_grid(cls,
                volume: Volume = None,
                name: String = None,
                grid: Float = None,
                data_type: Literal['BOOLEAN', 'FLOAT', 'INT', 'VECTOR_FLOAT'] = 'FLOAT'):
    """ > Node Store Named Grid

    Parameters
    ----------
    volume : Volume, optional
        socket 'Volume' (id: Volume)

    name : String, optional
        socket 'Name' (id: Name)

    grid : Float, optional
        socket 'Grid' (id: Grid)

    data_type : Literal['Boolean', 'Float', 'Integer', 'Vector']
        parameter `data_type`


    Returns
    -------
    Volume
    """
    node = Node('Store Named Grid', {'Volume': volume, 'Name': name, 'Grid': grid}, data_type=data_type)
    return node._out

string(string='') classmethod

Node String

Parameters:

Name	Type	Description	Default
string	str	parameter string	''

Returns:

Type	Description
String

Source code in core/generated/static_nd.py

@classmethod
def string(cls, string = ''):
    """ > Node String

    Parameters
    ----------
    string : str
        parameter `string`


    Returns
    -------
    String
    """
    node = Node('String', string=string)
    return node._out

string_length(string=None) classmethod

Node String Length

Parameters:

Name	Type	Description	Default
string	String	socket 'String' (id: String)	None

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def string_length(cls, string: String = None):
    """ > Node String Length

    Parameters
    ----------
    string : String, optional
        socket 'String' (id: String)


    Returns
    -------
    Integer
    """
    node = Node('String Length', {'String': string})
    return node._out

string_to_curves(string=None, size=None, font=None, align_x=None, align_y=None, pivot_point=None, character_spacing=None, word_spacing=None, line_spacing=None, overflow=None, text_box_width=None, text_box_height=None) classmethod

Node String to Curves

Parameters:

Name	Type	Description	Default
string	String	socket 'String' (id: String)	None
size	Float	socket 'Size' (id: Size)	None
font	Font	socket 'Font' (id: Font)	None
align_x	menu='Left'	('Left', 'Center', 'Right', 'Justify', 'Flush')	None
align_y	menu='Top Baseline'	('Top', 'Top Baseline', 'Middle', 'Bottom Baseline', 'Bottom')	None
pivot_point	menu='Midpoint'	('Midpoint', 'Top Left', 'Top Center', 'Top Right', 'Bottom Left', 'Bottom Center', 'Bottom Right')	None
character_spacing	Float	socket 'Character Spacing' (id: Character Spacing)	None
word_spacing	Float	socket 'Word Spacing' (id: Word Spacing)	None
line_spacing	Float	socket 'Line Spacing' (id: Line Spacing)	None
overflow	menu='Overflow'	('Overflow', 'Scale To Fit', 'Truncate')	None
text_box_width	Float	socket 'Text Box Width' (id: Text Box Width)	None
text_box_height	Float	socket 'Text Box Height' (id: Text Box Height)	None

Returns:

Type	Description
Instances	peer sockets: remainder_ (String), line_ (Integer), word_ (Integer), pivot_point_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def string_to_curves(cls,
                string: String = None,
                size: Float = None,
                font: Font = None,
                align_x: Literal['Left', 'Center', 'Right', 'Justify', 'Flush'] = None,
                align_y: Literal['Top', 'Top Baseline', 'Middle', 'Bottom Baseline', 'Bottom'] = None,
                pivot_point: Literal['Midpoint', 'Top Left', 'Top Center', 'Top Right', 'Bottom Left', 'Bottom Center', 'Bottom Right'] = None,
                character_spacing: Float = None,
                word_spacing: Float = None,
                line_spacing: Float = None,
                overflow: Literal['Overflow', 'Scale To Fit', 'Truncate'] = None,
                text_box_width: Float = None,
                text_box_height: Float = None):
    """ > Node String to Curves

    Parameters
    ----------
    string : String, optional
        socket 'String' (id: String)

    size : Float, optional
        socket 'Size' (id: Size)

    font : Font, optional
        socket 'Font' (id: Font)

    align_x : menu='Left', optional
        ('Left', 'Center', 'Right', 'Justify', 'Flush')

    align_y : menu='Top Baseline', optional
        ('Top', 'Top Baseline', 'Middle', 'Bottom Baseline', 'Bottom')

    pivot_point : menu='Midpoint', optional
        ('Midpoint', 'Top Left', 'Top Center', 'Top Right', 'Bottom Left', 'Bottom Center', 'Bottom Right')

    character_spacing : Float, optional
        socket 'Character Spacing' (id: Character Spacing)

    word_spacing : Float, optional
        socket 'Word Spacing' (id: Word Spacing)

    line_spacing : Float, optional
        socket 'Line Spacing' (id: Line Spacing)

    overflow : menu='Overflow', optional
        ('Overflow', 'Scale To Fit', 'Truncate')

    text_box_width : Float, optional
        socket 'Text Box Width' (id: Text Box Width)

    text_box_height : Float, optional
        socket 'Text Box Height' (id: Text Box Height)


    Returns
    -------
    Instances
        peer sockets: remainder_ (String), line_ (Integer), word_ (Integer), pivot_point_ (Vector)

    """
    node = Node('String to Curves', {'String': string, 'Size': size, 'Font': font, 'Align X': align_x, 'Align Y': align_y, 'Pivot Point': pivot_point, 'Character Spacing': character_spacing, 'Word Spacing': word_spacing, 'Line Spacing': line_spacing, 'Overflow': overflow, 'Text Box Width': text_box_width, 'Text Box Height': text_box_height})
    return node._out

string_to_value(string=None, data_type='FLOAT') classmethod

Node String to Value

Parameters:

Name	Type	Description	Default
string	String	socket 'String' (id: String)	None
data_type	Literal['Float', 'Integer']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float	peer sockets: length_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def string_to_value(cls, string: String = None, data_type: Literal['FLOAT', 'INT'] = 'FLOAT'):
    """ > Node String to Value

    Parameters
    ----------
    string : String, optional
        socket 'String' (id: String)

    data_type : Literal['Float', 'Integer']
        parameter `data_type`


    Returns
    -------
    Float
        peer sockets: length_ (Integer)

    """
    node = Node('String to Value', {'String': string}, data_type=data_type)
    return node._out

subdivide_curve(curve=None, cuts=None) classmethod

Node Subdivide Curve

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
cuts	Integer	socket 'Cuts' (id: Cuts)	None

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def subdivide_curve(cls, curve: Curve = None, cuts: Integer = None):
    """ > Node Subdivide Curve

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    cuts : Integer, optional
        socket 'Cuts' (id: Cuts)


    Returns
    -------
    Curve
    """
    node = Node('Subdivide Curve', {'Curve': curve, 'Cuts': cuts})
    return node._out

subdivide_mesh(mesh=None, level=None) classmethod

Node Subdivide Mesh

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
level	Integer	socket 'Level' (id: Level)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def subdivide_mesh(cls, mesh: Mesh = None, level: Integer = None):
    """ > Node Subdivide Mesh

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    level : Integer, optional
        socket 'Level' (id: Level)


    Returns
    -------
    Mesh
    """
    node = Node('Subdivide Mesh', {'Mesh': mesh, 'Level': level})
    return node._out

subdivision_surface(mesh=None, level=None, edge_crease=None, vertex_crease=None, limit_surface=None, uv_smooth=None, boundary_smooth=None) classmethod

Node Subdivision Surface

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
level	Integer	socket 'Level' (id: Level)	None
edge_crease	Float	socket 'Edge Crease' (id: Edge Crease)	None
vertex_crease	Float	socket 'Vertex Crease' (id: Vertex Crease)	None
limit_surface	Boolean	socket 'Limit Surface' (id: Limit Surface)	None
uv_smooth	menu='Keep Boundaries'	('None', 'Keep Corners', 'Keep Corners, Junctions', 'Keep Corners, Junctions, Concave', 'Keep Boundaries', 'All')	None
boundary_smooth	menu='All'	('Keep Corners', 'All')	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def subdivision_surface(cls,
                mesh: Mesh = None,
                level: Integer = None,
                edge_crease: Float = None,
                vertex_crease: Float = None,
                limit_surface: Boolean = None,
                uv_smooth: Literal['None', 'Keep Corners', 'Keep Corners, Junctions', 'Keep Corners, Junctions, Concave', 'Keep Boundaries', 'All'] = None,
                boundary_smooth: Literal['Keep Corners', 'All'] = None):
    """ > Node Subdivision Surface

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    level : Integer, optional
        socket 'Level' (id: Level)

    edge_crease : Float, optional
        socket 'Edge Crease' (id: Edge Crease)

    vertex_crease : Float, optional
        socket 'Vertex Crease' (id: Vertex Crease)

    limit_surface : Boolean, optional
        socket 'Limit Surface' (id: Limit Surface)

    uv_smooth : menu='Keep Boundaries', optional
        ('None', 'Keep Corners', 'Keep Corners, Junctions', 'Keep Corners, Junctions, Concave', 'Keep Boundaries', 'All')

    boundary_smooth : menu='All', optional
        ('Keep Corners', 'All')


    Returns
    -------
    Mesh
    """
    node = Node('Subdivision Surface', {'Mesh': mesh, 'Level': level, 'Edge Crease': edge_crease, 'Vertex Crease': vertex_crease, 'Limit Surface': limit_surface, 'UV Smooth': uv_smooth, 'Boundary Smooth': boundary_smooth})
    return node._out

switch(switch=None, false=None, true=None, input_type='FLOAT') classmethod

Node Switch

Parameters:

Name	Type	Description	Default
switch	Boolean	socket 'Switch' (id: Switch)	None
false	Float	socket 'False' (id: False)	None
true	Float	socket 'True' (id: True)	None
input_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']	parameter input_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def switch(cls,
                switch: Boolean = None,
                false: Float = None,
                true: Float = None,
                input_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'] = 'FLOAT'):
    """ > Node Switch

    Parameters
    ----------
    switch : Boolean, optional
        socket 'Switch' (id: Switch)

    false : Float, optional
        socket 'False' (id: False)

    true : Float, optional
        socket 'True' (id: True)

    input_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Rotation', 'Matrix', 'String', 'Menu', 'Object', 'Image', 'Geometry', 'Collection', 'Material', 'Bundle', 'Closure', 'Font']
        parameter `input_type`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Switch', 'input_type', input_type, 'switch', ('FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'ROTATION', 'MATRIX', 'STRING', 'MENU', 'OBJECT', 'IMAGE', 'GEOMETRY', 'COLLECTION', 'MATERIAL', 'BUNDLE', 'CLOSURE', 'FONT'))
    node = Node('Switch', {'Switch': switch, 'False': false, 'True': true}, input_type=input_type)
    return node._out

transform_direction(direction=None, transform=None) classmethod

Node Transform Direction

Parameters:

Name	Type	Description	Default
direction	Vector	socket 'Direction' (id: Direction)	None
transform	Matrix	socket 'Transform' (id: Transform)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def transform_direction(cls, direction: Vector = None, transform: Matrix = None):
    """ > Node Transform Direction

    Parameters
    ----------
    direction : Vector, optional
        socket 'Direction' (id: Direction)

    transform : Matrix, optional
        socket 'Transform' (id: Transform)


    Returns
    -------
    Vector
    """
    node = Node('Transform Direction', {'Direction': direction, 'Transform': transform})
    return node._out

transform_geometry(geometry=None, mode=None, translation=None, rotation=None, scale=None, transform=None) classmethod

Node Transform Geometry

Parameters:

Name	Type	Description	Default
geometry	Geometry	socket 'Geometry' (id: Geometry)	None
mode	menu='Components'	('Components', 'Matrix')	None
translation	Vector	socket 'Translation' (id: Translation)	None
rotation	Rotation	socket 'Rotation' (id: Rotation)	None
scale	Vector	socket 'Scale' (id: Scale)	None
transform	Matrix	socket 'Transform' (id: Transform)	None

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def transform_geometry(cls,
                geometry: Geometry = None,
                mode: Literal['Components', 'Matrix'] = None,
                translation: Vector = None,
                rotation: Rotation = None,
                scale: Vector = None,
                transform: Matrix = None):
    """ > Node Transform Geometry

    Parameters
    ----------
    geometry : Geometry, optional
        socket 'Geometry' (id: Geometry)

    mode : menu='Components', optional
        ('Components', 'Matrix')

    translation : Vector, optional
        socket 'Translation' (id: Translation)

    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)

    scale : Vector, optional
        socket 'Scale' (id: Scale)

    transform : Matrix, optional
        socket 'Transform' (id: Transform)


    Returns
    -------
    Geometry
    """
    node = Node('Transform Geometry', {'Geometry': geometry, 'Mode': mode, 'Translation': translation, 'Rotation': rotation, 'Scale': scale, 'Transform': transform})
    return node._out

transform_gizmo(*value, position=None, rotation=None, use_rotation_x=True, use_rotation_y=True, use_rotation_z=True, use_scale_x=True, use_scale_y=True, use_scale_z=True, use_translation_x=True, use_translation_y=True, use_translation_z=True) classmethod

Node Transform Gizmo

Parameters:

Name	Type	Description	Default
value	Matrix	socket 'Value' (id: Value)	()
position	Vector	socket 'Position' (id: Position)	None
rotation	Rotation	socket 'Rotation' (id: Rotation)	None
use_rotation_x	bool	parameter use_rotation_x	True
use_rotation_y	bool	parameter use_rotation_y	True
use_rotation_z	bool	parameter use_rotation_z	True
use_scale_x	bool	parameter use_scale_x	True
use_scale_y	bool	parameter use_scale_y	True
use_scale_z	bool	parameter use_scale_z	True
use_translation_x	bool	parameter use_translation_x	True
use_translation_y	bool	parameter use_translation_y	True
use_translation_z	bool	parameter use_translation_z	True

Returns:

Type	Description
Geometry

Source code in core/generated/static_nd.py

@classmethod
def transform_gizmo(cls,
                *value: Matrix,
                position: Vector = None,
                rotation: Rotation = None,
                use_rotation_x = True,
                use_rotation_y = True,
                use_rotation_z = True,
                use_scale_x = True,
                use_scale_y = True,
                use_scale_z = True,
                use_translation_x = True,
                use_translation_y = True,
                use_translation_z = True):
    """ > Node Transform Gizmo

    Parameters
    ----------
    value : Matrix, optional
        socket 'Value' (id: Value)

    position : Vector, optional
        socket 'Position' (id: Position)

    rotation : Rotation, optional
        socket 'Rotation' (id: Rotation)

    use_rotation_x : bool
        parameter `use_rotation_x`

    use_rotation_y : bool
        parameter `use_rotation_y`

    use_rotation_z : bool
        parameter `use_rotation_z`

    use_scale_x : bool
        parameter `use_scale_x`

    use_scale_y : bool
        parameter `use_scale_y`

    use_scale_z : bool
        parameter `use_scale_z`

    use_translation_x : bool
        parameter `use_translation_x`

    use_translation_y : bool
        parameter `use_translation_y`

    use_translation_z : bool
        parameter `use_translation_z`


    Returns
    -------
    Geometry
    """
    node = Node('Transform Gizmo', {'Value': list(value), 'Position': position, 'Rotation': rotation}, use_rotation_x=use_rotation_x, use_rotation_y=use_rotation_y, use_rotation_z=use_rotation_z, use_scale_x=use_scale_x, use_scale_y=use_scale_y, use_scale_z=use_scale_z, use_translation_x=use_translation_x, use_translation_y=use_translation_y, use_translation_z=use_translation_z)
    return node._out

transform_point(vector=None, transform=None) classmethod

Node Transform Point

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
transform	Matrix	socket 'Transform' (id: Transform)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def transform_point(cls, vector: Vector = None, transform: Matrix = None):
    """ > Node Transform Point

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    transform : Matrix, optional
        socket 'Transform' (id: Transform)


    Returns
    -------
    Vector
    """
    node = Node('Transform Point', {'Vector': vector, 'Transform': transform})
    return node._out

translate_instances(instances=None, selection=None, translation=None, local_space=None) classmethod

Node Translate Instances

Parameters:

Name	Type	Description	Default
instances	Instances	socket 'Instances' (id: Instances)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
translation	Vector	socket 'Translation' (id: Translation)	None
local_space	Boolean	socket 'Local Space' (id: Local Space)	None

Returns:

Type	Description
Instances

Source code in core/generated/static_nd.py

@classmethod
def translate_instances(cls,
                instances: Instances = None,
                selection: Boolean = None,
                translation: Vector = None,
                local_space: Boolean = None):
    """ > Node Translate Instances

    Parameters
    ----------
    instances : Instances, optional
        socket 'Instances' (id: Instances)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    translation : Vector, optional
        socket 'Translation' (id: Translation)

    local_space : Boolean, optional
        socket 'Local Space' (id: Local Space)


    Returns
    -------
    Instances
    """
    node = Node('Translate Instances', {'Instances': instances, 'Selection': selection, 'Translation': translation, 'Local Space': local_space})
    return node._out

transpose_matrix(matrix=None) classmethod

Node Transpose Matrix

Parameters:

Name	Type	Description	Default
matrix	Matrix	socket 'Matrix' (id: Matrix)	None

Returns:

Type	Description
Matrix

Source code in core/generated/static_nd.py

@classmethod
def transpose_matrix(cls, matrix: Matrix = None):
    """ > Node Transpose Matrix

    Parameters
    ----------
    matrix : Matrix, optional
        socket 'Matrix' (id: Matrix)


    Returns
    -------
    Matrix
    """
    node = Node('Transpose Matrix', {'Matrix': matrix})
    return node._out

triangulate(mesh=None, selection=None, quad_method=None, n_gon_method=None) classmethod

Node Triangulate

Parameters:

Name	Type	Description	Default
mesh	Mesh	socket 'Mesh' (id: Mesh)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
quad_method	menu='Shortest Diagonal'	('Beauty', 'Fixed', 'Fixed Alternate', 'Shortest Diagonal', 'Longest Diagonal')	None
n_gon_method	menu='Beauty'	('Beauty', 'Clip')	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def triangulate(cls,
                mesh: Mesh = None,
                selection: Boolean = None,
                quad_method: Literal['Beauty', 'Fixed', 'Fixed Alternate', 'Shortest Diagonal', 'Longest Diagonal'] = None,
                n_gon_method: Literal['Beauty', 'Clip'] = None):
    """ > Node Triangulate

    Parameters
    ----------
    mesh : Mesh, optional
        socket 'Mesh' (id: Mesh)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    quad_method : menu='Shortest Diagonal', optional
        ('Beauty', 'Fixed', 'Fixed Alternate', 'Shortest Diagonal', 'Longest Diagonal')

    n_gon_method : menu='Beauty', optional
        ('Beauty', 'Clip')


    Returns
    -------
    Mesh
    """
    node = Node('Triangulate', {'Mesh': mesh, 'Selection': selection, 'Quad Method': quad_method, 'N-gon Method': n_gon_method})
    return node._out

trim_curve(curve=None, selection=None, start=None, end=None, start_1=None, end_1=None, mode='FACTOR') classmethod

Node Trim Curve

Parameters:

Name	Type	Description	Default
curve	Curve	socket 'Curve' (id: Curve)	None
selection	Boolean	socket 'Selection' (id: Selection)	None
start	Float	socket 'Start' (id: Start)	None
end	Float	socket 'End' (id: End)	None
start_1	Float	socket 'Start' (id: Start_001)	None
end_1	Float	socket 'End' (id: End_001)	None
mode	Literal['Factor', 'Length']	parameter mode	'FACTOR'

Returns:

Type	Description
Curve

Source code in core/generated/static_nd.py

@classmethod
def trim_curve(cls,
                curve: Curve = None,
                selection: Boolean = None,
                start: Float = None,
                end: Float = None,
                start_1: Float = None,
                end_1: Float = None,
                mode: Literal['FACTOR', 'LENGTH'] = 'FACTOR'):
    """ > Node Trim Curve

    Parameters
    ----------
    curve : Curve, optional
        socket 'Curve' (id: Curve)

    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    start : Float, optional
        socket 'Start' (id: Start)

    end : Float, optional
        socket 'End' (id: End)

    start_1 : Float, optional
        socket 'Start' (id: Start_001)

    end_1 : Float, optional
        socket 'End' (id: End_001)

    mode : Literal['Factor', 'Length']
        parameter `mode`


    Returns
    -------
    Curve
    """
    utils.check_enum_arg('Trim Curve', 'mode', mode, 'trim_curve', ('FACTOR', 'LENGTH'))
    node = Node('Trim Curve', {'Curve': curve, 'Selection': selection, 'Start': start, 'End': end, 'Start_001': start_1, 'End_001': end_1}, mode=mode)
    return node._out

uv_sphere(segments=None, rings=None, radius=None) classmethod

Node UV Sphere

Parameters:

Name	Type	Description	Default
segments	Integer	socket 'Segments' (id: Segments)	None
rings	Integer	socket 'Rings' (id: Rings)	None
radius	Float	socket 'Radius' (id: Radius)	None

Returns:

Type	Description
Mesh	peer sockets: uv_map_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def uv_sphere(cls, segments: Integer = None, rings: Integer = None, radius: Float = None):
    """ > Node UV Sphere

    Parameters
    ----------
    segments : Integer, optional
        socket 'Segments' (id: Segments)

    rings : Integer, optional
        socket 'Rings' (id: Rings)

    radius : Float, optional
        socket 'Radius' (id: Radius)


    Returns
    -------
    Mesh
        peer sockets: uv_map_ (Vector)

    """
    node = Node('UV Sphere', {'Segments': segments, 'Rings': rings, 'Radius': radius})
    return node._out

uv_tangent(method=None, uv=None) classmethod

Node UV Tangent

Parameters:

Name	Type	Description	Default
method	menu='Exact'	('Exact', 'Fast')	None
uv	Vector	socket 'UV' (id: UV)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def uv_tangent(cls, method: Literal['Exact', 'Fast'] = None, uv: Vector = None):
    """ > Node UV Tangent

    Parameters
    ----------
    method : menu='Exact', optional
        ('Exact', 'Fast')

    uv : Vector, optional
        socket 'UV' (id: UV)


    Returns
    -------
    Vector
    """
    node = Node('UV Tangent', {'Method': method, 'UV': uv})
    return node._out

uv_unwrap(selection=None, seam=None, margin=None, fill_holes=None, method=None, iterations=None, no_flip=None) classmethod

Node UV Unwrap

Parameters:

Name	Type	Description	Default
selection	Boolean	socket 'Selection' (id: Selection)	None
seam	Boolean	socket 'Seam' (id: Seam)	None
margin	Float	socket 'Margin' (id: Margin)	None
fill_holes	Boolean	socket 'Fill Holes' (id: Fill Holes)	None
method	menu='Angle Based'	('Angle Based', 'Conformal', 'Minimum Stretch')	None
iterations	Integer	socket 'Iterations' (id: Iterations)	None
no_flip	Boolean	socket 'No Flip' (id: No Flip)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def uv_unwrap(cls,
                selection: Boolean = None,
                seam: Boolean = None,
                margin: Float = None,
                fill_holes: Boolean = None,
                method: Literal['Angle Based', 'Conformal', 'Minimum Stretch'] = None,
                iterations: Integer = None,
                no_flip: Boolean = None):
    """ > Node UV Unwrap

    Parameters
    ----------
    selection : Boolean, optional
        socket 'Selection' (id: Selection)

    seam : Boolean, optional
        socket 'Seam' (id: Seam)

    margin : Float, optional
        socket 'Margin' (id: Margin)

    fill_holes : Boolean, optional
        socket 'Fill Holes' (id: Fill Holes)

    method : menu='Angle Based', optional
        ('Angle Based', 'Conformal', 'Minimum Stretch')

    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)

    no_flip : Boolean, optional
        socket 'No Flip' (id: No Flip)


    Returns
    -------
    Vector
    """
    node = Node('UV Unwrap', {'Selection': selection, 'Seam': seam, 'Margin': margin, 'Fill Holes': fill_holes, 'Method': method, 'Iterations': iterations, 'No Flip': no_flip})
    return node._out

value()

Node Value

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@utils.classproperty
def value(self):
    """ > Node Value

    Returns
    -------
    Float
    """
    node = Node('Value', )
    return node._out

value_to_string(value=None, decimals=None, data_type='FLOAT') classmethod

Node Value to String

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
decimals	Integer	socket 'Decimals' (id: Decimals)	None
data_type	Literal['Float', 'Integer']	parameter data_type	'FLOAT'

Returns:

Type	Description
String

Source code in core/generated/static_nd.py

@classmethod
def value_to_string(cls,
                value: Float = None,
                decimals: Integer = None,
                data_type: Literal['FLOAT', 'INT'] = 'FLOAT'):
    """ > Node Value to String

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    decimals : Integer, optional
        socket 'Decimals' (id: Decimals)

    data_type : Literal['Float', 'Integer']
        parameter `data_type`


    Returns
    -------
    String
    """
    node = Node('Value to String', {'Value': value, 'Decimals': decimals}, data_type=data_type)
    return node._out

vector()

Node Vector

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@utils.classproperty
def vector(self):
    """ > Node Vector

    Returns
    -------
    Vector
    """
    node = Node('Vector', )
    return node._out

vector_curves(vector=None, factor=None) classmethod

Node Vector Curves

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
factor	Float	socket 'Factor' (id: Fac)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def vector_curves(cls, vector: Vector = None, factor: Float = None):
    """ > Node Vector Curves

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    factor : Float, optional
        socket 'Factor' (id: Fac)


    Returns
    -------
    Vector
    """
    node = NodeCurves('Vector Curves', {'Vector': vector, 'Fac': factor})
    return node._out

vector_math(vector=None, vector_1=None, vector_2=None, scale=None, operation='ADD') classmethod

Node Vector Math

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
vector_1	Vector	socket 'Vector' (id: Vector_001)	None
vector_2	Vector	socket 'Vector' (id: Vector_002)	None
scale	Float	socket 'Scale' (id: Scale)	None
operation	Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Cross Product', 'Project', 'Reflect', 'Refract', 'Faceforward', 'Dot Product', 'Distance', 'Length', 'Scale', 'Normalize', 'Absolute', 'Power', 'Sign', 'Minimum', 'Maximum', 'Round', 'Floor', 'Ceil', 'Fraction', 'Modulo', 'Wrap', 'Snap', 'Sine', 'Cosine', 'Tangent']	parameter operation	'ADD'

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def vector_math(cls,
                vector: Vector = None,
                vector_1: Vector = None,
                vector_2: Vector = None,
                scale: Float = None,
                operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'CROSS_PRODUCT', 'PROJECT', 'REFLECT', 'REFRACT', 'FACEFORWARD', 'DOT_PRODUCT', 'DISTANCE', 'LENGTH', 'SCALE', 'NORMALIZE', 'ABSOLUTE', 'POWER', 'SIGN', 'MINIMUM', 'MAXIMUM', 'ROUND', 'FLOOR', 'CEIL', 'FRACTION', 'MODULO', 'WRAP', 'SNAP', 'SINE', 'COSINE', 'TANGENT'] = 'ADD'):
    """ > Node Vector Math

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    vector_1 : Vector, optional
        socket 'Vector' (id: Vector_001)

    vector_2 : Vector, optional
        socket 'Vector' (id: Vector_002)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    operation : Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Cross Product', 'Project', 'Reflect', 'Refract', 'Faceforward', 'Dot Product', 'Distance', 'Length', 'Scale', 'Normalize', 'Absolute', 'Power', 'Sign', 'Minimum', 'Maximum', 'Round', 'Floor', 'Ceil', 'Fraction', 'Modulo', 'Wrap', 'Snap', 'Sine', 'Cosine', 'Tangent']
        parameter `operation`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Vector Math', 'operation', operation, 'vector_math', ('ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'CROSS_PRODUCT', 'PROJECT', 'REFLECT', 'REFRACT', 'FACEFORWARD', 'DOT_PRODUCT', 'DISTANCE', 'LENGTH', 'SCALE', 'NORMALIZE', 'ABSOLUTE', 'POWER', 'SIGN', 'MINIMUM', 'MAXIMUM', 'ROUND', 'FLOOR', 'CEIL', 'FRACTION', 'MODULO', 'WRAP', 'SNAP', 'SINE', 'COSINE', 'TANGENT'))
    node = Node('Vector Math', {'Vector': vector, 'Vector_001': vector_1, 'Vector_002': vector_2, 'Scale': scale}, operation=operation)
    return node._out

vector_rotate(vector=None, center=None, axis=None, angle=None, rotation=None, invert=False, rotation_type='AXIS_ANGLE') classmethod

Node Vector Rotate

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
center	Vector	socket 'Center' (id: Center)	None
axis	Vector	socket 'Axis' (id: Axis)	None
angle	Float	socket 'Angle' (id: Angle)	None
rotation	Vector	socket 'Rotation' (id: Rotation)	None
invert	bool	parameter invert	False
rotation_type	Literal['Axis Angle', 'X Axis', 'Y Axis', 'Z Axis', 'Euler']	parameter rotation_type	'AXIS_ANGLE'

Returns:

Type	Description
Vector

Source code in core/generated/static_nd.py

@classmethod
def vector_rotate(cls,
                vector: Vector = None,
                center: Vector = None,
                axis: Vector = None,
                angle: Float = None,
                rotation: Vector = None,
                invert = False,
                rotation_type: Literal['AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'] = 'AXIS_ANGLE'):
    """ > Node Vector Rotate

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    center : Vector, optional
        socket 'Center' (id: Center)

    axis : Vector, optional
        socket 'Axis' (id: Axis)

    angle : Float, optional
        socket 'Angle' (id: Angle)

    rotation : Vector, optional
        socket 'Rotation' (id: Rotation)

    invert : bool
        parameter `invert`

    rotation_type : Literal['Axis Angle', 'X Axis', 'Y Axis', 'Z Axis', 'Euler']
        parameter `rotation_type`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Vector Rotate', 'rotation_type', rotation_type, 'vector_rotate', ('AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'))
    node = Node('Vector Rotate', {'Vector': vector, 'Center': center, 'Axis': axis, 'Angle': angle, 'Rotation': rotation}, invert=invert, rotation_type=rotation_type)
    return node._out

vertex_neighbors() classmethod

Node Vertex Neighbors

Returns:

Type	Description
Integer	peer sockets: face_count_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def vertex_neighbors(cls):
    """ > Node Vertex Neighbors

    Returns
    -------
    Integer
        peer sockets: face_count_ (Integer)

    """
    node = Node('Vertex Neighbors', )
    return node

vertex_of_corner(corner_index=None) classmethod

Node Vertex of Corner

Parameters:

Name	Type	Description	Default
corner_index	Integer	socket 'Corner Index' (id: Corner Index)	None

Returns:

Type	Description
Integer

Source code in core/generated/static_nd.py

@classmethod
def vertex_of_corner(cls, corner_index: Integer = None):
    """ > Node Vertex of Corner

    Parameters
    ----------
    corner_index : Integer, optional
        socket 'Corner Index' (id: Corner Index)


    Returns
    -------
    Integer
    """
    node = Node('Vertex of Corner', {'Corner Index': corner_index})
    return node._out

viewer(named_sockets={}, domain='AUTO', ui_shortcut=0, **sockets) classmethod

Node Viewer

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
domain	Literal['Auto', 'Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']	parameter domain	'AUTO'
ui_shortcut	int	parameter ui_shortcut	0
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
None

Source code in core/generated/static_nd.py

@classmethod
def viewer(cls,
                named_sockets: dict = {},
                domain: Literal['AUTO', 'POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'] = 'AUTO',
                ui_shortcut = 0,
                **sockets):
    """ > Node Viewer

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    domain : Literal['Auto', 'Point', 'Edge', 'Face', 'Face Corner', 'Spline', 'Instance', 'Layer']
        parameter `domain`

    ui_shortcut : int
        parameter `ui_shortcut`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    None
    """
    utils.check_enum_arg('Viewer', 'domain', domain, 'viewer', ('AUTO', 'POINT', 'EDGE', 'FACE', 'CORNER', 'CURVE', 'INSTANCE', 'LAYER'))
    node = Node('Viewer', named_sockets, domain=domain, ui_shortcut=ui_shortcut, **sockets)
    return node._out

viewport_transform() classmethod

Node Viewport Transform

Returns:

Type	Description
Matrix	peer sockets: view_ (Matrix), is_orthographic_ (Boolean)

Source code in core/generated/static_nd.py

@classmethod
def viewport_transform(cls):
    """ > Node Viewport Transform

    Returns
    -------
    Matrix
        peer sockets: view_ (Matrix), is_orthographic_ (Boolean)

    """
    node = Node('Viewport Transform', )
    return node

volume_cube(density=None, background=None, min=None, max=None, resolution_x=None, resolution_y=None, resolution_z=None) classmethod

Node Volume Cube

Parameters:

Name	Type	Description	Default
density	Float	socket 'Density' (id: Density)	None
background	Float	socket 'Background' (id: Background)	None
min	Vector	socket 'Min' (id: Min)	None
max	Vector	socket 'Max' (id: Max)	None
resolution_x	Integer	socket 'Resolution X' (id: Resolution X)	None
resolution_y	Integer	socket 'Resolution Y' (id: Resolution Y)	None
resolution_z	Integer	socket 'Resolution Z' (id: Resolution Z)	None

Returns:

Type	Description
Volume

Source code in core/generated/static_nd.py

@classmethod
def volume_cube(cls,
                density: Float = None,
                background: Float = None,
                min: Vector = None,
                max: Vector = None,
                resolution_x: Integer = None,
                resolution_y: Integer = None,
                resolution_z: Integer = None):
    """ > Node Volume Cube

    Parameters
    ----------
    density : Float, optional
        socket 'Density' (id: Density)

    background : Float, optional
        socket 'Background' (id: Background)

    min : Vector, optional
        socket 'Min' (id: Min)

    max : Vector, optional
        socket 'Max' (id: Max)

    resolution_x : Integer, optional
        socket 'Resolution X' (id: Resolution X)

    resolution_y : Integer, optional
        socket 'Resolution Y' (id: Resolution Y)

    resolution_z : Integer, optional
        socket 'Resolution Z' (id: Resolution Z)


    Returns
    -------
    Volume
    """
    node = Node('Volume Cube', {'Density': density, 'Background': background, 'Min': min, 'Max': max, 'Resolution X': resolution_x, 'Resolution Y': resolution_y, 'Resolution Z': resolution_z})
    return node._out

volume_to_mesh(volume=None, resolution_mode=None, voxel_size=None, voxel_amount=None, threshold=None, adaptivity=None) classmethod

Node Volume to Mesh

Parameters:

Name	Type	Description	Default
volume	Volume	socket 'Volume' (id: Volume)	None
resolution_mode	menu='Grid'	('Grid', 'Amount', 'Size')	None
voxel_size	Float	socket 'Voxel Size' (id: Voxel Size)	None
voxel_amount	Float	socket 'Voxel Amount' (id: Voxel Amount)	None
threshold	Float	socket 'Threshold' (id: Threshold)	None
adaptivity	Float	socket 'Adaptivity' (id: Adaptivity)	None

Returns:

Type	Description
Mesh

Source code in core/generated/static_nd.py

@classmethod
def volume_to_mesh(cls,
                volume: Volume = None,
                resolution_mode: Literal['Grid', 'Amount', 'Size'] = None,
                voxel_size: Float = None,
                voxel_amount: Float = None,
                threshold: Float = None,
                adaptivity: Float = None):
    """ > Node Volume to Mesh

    Parameters
    ----------
    volume : Volume, optional
        socket 'Volume' (id: Volume)

    resolution_mode : menu='Grid', optional
        ('Grid', 'Amount', 'Size')

    voxel_size : Float, optional
        socket 'Voxel Size' (id: Voxel Size)

    voxel_amount : Float, optional
        socket 'Voxel Amount' (id: Voxel Amount)

    threshold : Float, optional
        socket 'Threshold' (id: Threshold)

    adaptivity : Float, optional
        socket 'Adaptivity' (id: Adaptivity)


    Returns
    -------
    Mesh
    """
    node = Node('Volume to Mesh', {'Volume': volume, 'Resolution Mode': resolution_mode, 'Voxel Size': voxel_size, 'Voxel Amount': voxel_amount, 'Threshold': threshold, 'Adaptivity': adaptivity})
    return node._out

voronoi_texture(vector=None, w=None, scale=None, detail=None, roughness=None, lacunarity=None, smoothness=None, exponent=None, randomness=None, distance='EUCLIDEAN', feature='F1', normalize=False, voronoi_dimensions='3D') classmethod

Node Voronoi Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
w	Float	socket 'W' (id: W)	None
scale	Float	socket 'Scale' (id: Scale)	None
detail	Float	socket 'Detail' (id: Detail)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
lacunarity	Float	socket 'Lacunarity' (id: Lacunarity)	None
smoothness	Float	socket 'Smoothness' (id: Smoothness)	None
exponent	Float	socket 'Exponent' (id: Exponent)	None
randomness	Float	socket 'Randomness' (id: Randomness)	None
distance	Literal['Euclidean', 'Manhattan', 'Chebychev', 'Minkowski']	parameter distance	'EUCLIDEAN'
feature	Literal['F1', 'F2', 'Smooth F1', 'Distance to Edge', 'N-Sphere Radius']	parameter feature	'F1'
normalize	bool	parameter normalize	False
voronoi_dimensions	Literal['1D', '2D', '3D', '4D']	parameter voronoi_dimensions	'3D'

Returns:

Type	Description
Float	peer sockets: color_ (Color), position_ (Vector)

Source code in core/generated/static_nd.py

@classmethod
def voronoi_texture(cls,
                vector: Vector = None,
                w: Float = None,
                scale: Float = None,
                detail: Float = None,
                roughness: Float = None,
                lacunarity: Float = None,
                smoothness: Float = None,
                exponent: Float = None,
                randomness: Float = None,
                distance: Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'] = 'EUCLIDEAN',
                feature: Literal['F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'] = 'F1',
                normalize = False,
                voronoi_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D'):
    """ > Node Voronoi Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    w : Float, optional
        socket 'W' (id: W)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    detail : Float, optional
        socket 'Detail' (id: Detail)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    lacunarity : Float, optional
        socket 'Lacunarity' (id: Lacunarity)

    smoothness : Float, optional
        socket 'Smoothness' (id: Smoothness)

    exponent : Float, optional
        socket 'Exponent' (id: Exponent)

    randomness : Float, optional
        socket 'Randomness' (id: Randomness)

    distance : Literal['Euclidean', 'Manhattan', 'Chebychev', 'Minkowski']
        parameter `distance`

    feature : Literal['F1', 'F2', 'Smooth F1', 'Distance to Edge', 'N-Sphere Radius']
        parameter `feature`

    normalize : bool
        parameter `normalize`

    voronoi_dimensions : Literal['1D', '2D', '3D', '4D']
        parameter `voronoi_dimensions`


    Returns
    -------
    Float
        peer sockets: color_ (Color), position_ (Vector)

    """
    utils.check_enum_arg('Voronoi Texture', 'distance', distance, 'voronoi_texture', ('EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'))
    utils.check_enum_arg('Voronoi Texture', 'feature', feature, 'voronoi_texture', ('F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'))
    utils.check_enum_arg('Voronoi Texture', 'voronoi_dimensions', voronoi_dimensions, 'voronoi_texture', ('1D', '2D', '3D', '4D'))
    node = Node('Voronoi Texture', {'Vector': vector, 'W': w, 'Scale': scale, 'Detail': detail, 'Roughness': roughness, 'Lacunarity': lacunarity, 'Smoothness': smoothness, 'Exponent': exponent, 'Randomness': randomness}, distance=distance, feature=feature, normalize=normalize, voronoi_dimensions=voronoi_dimensions)
    return node._out

voxel_index() classmethod

Node Voxel Index

Returns:

Type	Description
Integer	peer sockets: y_ (Integer), z_ (Integer), is_tile_ (Boolean), extent_x_ (Integer), extent_y_ (Integer), extent_z_ (Integer)

Source code in core/generated/static_nd.py

@classmethod
def voxel_index(cls):
    """ > Node Voxel Index

    Returns
    -------
    Integer
        peer sockets: y_ (Integer), z_ (Integer), is_tile_ (Boolean), extent_x_ (Integer), extent_y_ (Integer), extent_z_ (Integer)

    """
    node = Node('Voxel Index', )
    return node

voxelize_grid(grid=None, data_type='FLOAT') classmethod

Node Voxelize Grid

Parameters:

Name	Type	Description	Default
grid	Float	socket 'Grid' (id: Grid)	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector']	parameter data_type	'FLOAT'

Returns:

Type	Description
Float

Source code in core/generated/static_nd.py

@classmethod
def voxelize_grid(cls,
                grid: Float = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR'] = 'FLOAT'):
    """ > Node Voxelize Grid

    Parameters
    ----------
    grid : Float, optional
        socket 'Grid' (id: Grid)

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector']
        parameter `data_type`


    Returns
    -------
    Float
    """
    node = Node('Voxelize Grid', {'Grid': grid}, data_type=data_type)
    return node._out

warning(show=None, message=None, warning_type='ERROR') classmethod

Node Warning

Parameters:

Name	Type	Description	Default
show	Boolean	socket 'Show' (id: Show)	None
message	String	socket 'Message' (id: Message)	None
warning_type	Literal['Error', 'Warning', 'Info']	parameter warning_type	'ERROR'

Returns:

Type	Description
Boolean

Source code in core/generated/static_nd.py

@classmethod
def warning(cls,
                show: Boolean = None,
                message: String = None,
                warning_type: Literal['ERROR', 'WARNING', 'INFO'] = 'ERROR'):
    """ > Node Warning

    Parameters
    ----------
    show : Boolean, optional
        socket 'Show' (id: Show)

    message : String, optional
        socket 'Message' (id: Message)

    warning_type : Literal['Error', 'Warning', 'Info']
        parameter `warning_type`


    Returns
    -------
    Boolean
    """
    utils.check_enum_arg('Warning', 'warning_type', warning_type, 'warning', ('ERROR', 'WARNING', 'INFO'))
    node = Node('Warning', {'Show': show, 'Message': message}, warning_type=warning_type)
    return node._out

wave_texture(vector=None, scale=None, distortion=None, detail=None, detail_scale=None, detail_roughness=None, phase_offset=None, bands_direction='X', rings_direction='X', wave_profile='SIN', wave_type='BANDS') classmethod

Node Wave Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
scale	Float	socket 'Scale' (id: Scale)	None
distortion	Float	socket 'Distortion' (id: Distortion)	None
detail	Float	socket 'Detail' (id: Detail)	None
detail_scale	Float	socket 'Detail Scale' (id: Detail Scale)	None
detail_roughness	Float	socket 'Detail Roughness' (id: Detail Roughness)	None
phase_offset	Float	socket 'Phase Offset' (id: Phase Offset)	None
bands_direction	Literal['X', 'Y', 'Z', 'Diagonal']	parameter bands_direction	'X'
rings_direction	Literal['X', 'Y', 'Z', 'Spherical']	parameter rings_direction	'X'
wave_profile	Literal['Sine', 'Saw', 'Triangle']	parameter wave_profile	'SIN'
wave_type	Literal['Bands', 'Rings']	parameter wave_type	'BANDS'

Returns:

Type	Description
Color	peer sockets: factor_ (Float)

Source code in core/generated/static_nd.py

@classmethod
def wave_texture(cls,
                vector: Vector = None,
                scale: Float = None,
                distortion: Float = None,
                detail: Float = None,
                detail_scale: Float = None,
                detail_roughness: Float = None,
                phase_offset: Float = None,
                bands_direction: Literal['X', 'Y', 'Z', 'DIAGONAL'] = 'X',
                rings_direction: Literal['X', 'Y', 'Z', 'SPHERICAL'] = 'X',
                wave_profile: Literal['SIN', 'SAW', 'TRI'] = 'SIN',
                wave_type: Literal['BANDS', 'RINGS'] = 'BANDS'):
    """ > Node Wave Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    distortion : Float, optional
        socket 'Distortion' (id: Distortion)

    detail : Float, optional
        socket 'Detail' (id: Detail)

    detail_scale : Float, optional
        socket 'Detail Scale' (id: Detail Scale)

    detail_roughness : Float, optional
        socket 'Detail Roughness' (id: Detail Roughness)

    phase_offset : Float, optional
        socket 'Phase Offset' (id: Phase Offset)

    bands_direction : Literal['X', 'Y', 'Z', 'Diagonal']
        parameter `bands_direction`

    rings_direction : Literal['X', 'Y', 'Z', 'Spherical']
        parameter `rings_direction`

    wave_profile : Literal['Sine', 'Saw', 'Triangle']
        parameter `wave_profile`

    wave_type : Literal['Bands', 'Rings']
        parameter `wave_type`


    Returns
    -------
    Color
        peer sockets: factor_ (Float)

    """
    utils.check_enum_arg('Wave Texture', 'bands_direction', bands_direction, 'wave_texture', ('X', 'Y', 'Z', 'DIAGONAL'))
    utils.check_enum_arg('Wave Texture', 'rings_direction', rings_direction, 'wave_texture', ('X', 'Y', 'Z', 'SPHERICAL'))
    utils.check_enum_arg('Wave Texture', 'wave_profile', wave_profile, 'wave_texture', ('SIN', 'SAW', 'TRI'))
    utils.check_enum_arg('Wave Texture', 'wave_type', wave_type, 'wave_texture', ('BANDS', 'RINGS'))
    node = Node('Wave Texture', {'Vector': vector, 'Scale': scale, 'Distortion': distortion, 'Detail': detail, 'Detail Scale': detail_scale, 'Detail Roughness': detail_roughness, 'Phase Offset': phase_offset}, bands_direction=bands_direction, rings_direction=rings_direction, wave_profile=wave_profile, wave_type=wave_type)
    return node._out

white_noise_texture(vector=None, w=None, noise_dimensions='3D') classmethod

Node White Noise Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
w	Float	socket 'W' (id: W)	None
noise_dimensions	Literal['1D', '2D', '3D', '4D']	parameter noise_dimensions	'3D'

Returns:

Type	Description
Float	peer sockets: color_ (Color)

Source code in core/generated/static_nd.py

@classmethod
def white_noise_texture(cls,
                vector: Vector = None,
                w: Float = None,
                noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D'):
    """ > Node White Noise Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    w : Float, optional
        socket 'W' (id: W)

    noise_dimensions : Literal['1D', '2D', '3D', '4D']
        parameter `noise_dimensions`


    Returns
    -------
    Float
        peer sockets: color_ (Color)

    """
    utils.check_enum_arg('White Noise Texture', 'noise_dimensions', noise_dimensions, 'white_noise_texture', ('1D', '2D', '3D', '4D'))
    node = Node('White Noise Texture', {'Vector': vector, 'W': w}, noise_dimensions=noise_dimensions)
    return node._out