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

from typing import TYPE_CHECKING, Literal

import bpy

from ...builder import BaseNode, SocketAccessor

from ...types import (
    InputColor,
    InputFloat,
    InputImage,
    InputInteger,
    InputVector,
)

from ...builder.socket import (
    ColorSocket,
    FloatSocket,
    ImageSocket,
    IntegerSocket,
    VectorSocket,
)


class BrickTexture(BaseNode):
    """
    Generate a procedural texture producing bricks

    Parameters
    ----------
    vector : InputVector
        Vector
    color1 : InputColor
        Color1
    color2 : InputColor
        Color2
    mortar : InputColor
        Mortar
    scale : InputFloat
        Scale
    mortar_size : InputFloat
        Mortar Size
    mortar_smooth : InputFloat
        Mortar Smooth
    bias : InputFloat
        Bias
    brick_width : InputFloat
        Brick Width
    row_height : InputFloat
        Row Height

    Inputs
    ------
    i.vector : VectorSocket
        Vector
    i.color1 : ColorSocket
        Color1
    i.color2 : ColorSocket
        Color2
    i.mortar : ColorSocket
        Mortar
    i.scale : FloatSocket
        Scale
    i.mortar_size : FloatSocket
        Mortar Size
    i.mortar_smooth : FloatSocket
        Mortar Smooth
    i.bias : FloatSocket
        Bias
    i.brick_width : FloatSocket
        Brick Width
    i.row_height : FloatSocket
        Row Height

    Outputs
    -------
    o.color : ColorSocket
        Color
    o.fac : FloatSocket
        Factor
    """

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

    class _Inputs(SocketAccessor):
        vector: VectorSocket
        """Vector"""
        color1: ColorSocket
        """Color1"""
        color2: ColorSocket
        """Color2"""
        mortar: ColorSocket
        """Mortar"""
        scale: FloatSocket
        """Scale"""
        mortar_size: FloatSocket
        """Mortar Size"""
        mortar_smooth: FloatSocket
        """Mortar Smooth"""
        bias: FloatSocket
        """Bias"""
        brick_width: FloatSocket
        """Brick Width"""
        row_height: FloatSocket
        """Row Height"""

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        fac: FloatSocket
        """Factor"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vector: InputVector = None,
        color1: InputColor = None,
        color2: InputColor = None,
        mortar: InputColor = None,
        scale: InputFloat = 5.0,
        mortar_size: InputFloat = 0.02,
        mortar_smooth: InputFloat = 0.1,
        bias: InputFloat = 0.0,
        brick_width: InputFloat = 0.5,
        row_height: InputFloat = 0.25,
        *,
        offset_frequency: int = 2,
        squash_frequency: int = 2,
        offset: float = 0.5,
        squash: float = 1.0,
    ):
        super().__init__()
        key_args = {
            "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,
        }
        self.offset_frequency = offset_frequency
        self.squash_frequency = squash_frequency
        self.offset = offset
        self.squash = squash
        self._establish_links(**key_args)

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

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

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

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

    @property
    def offset(self) -> float:
        return self.node.offset

    @offset.setter
    def offset(self, value: float):
        self.node.offset = value

    @property
    def squash(self) -> float:
        return self.node.squash

    @squash.setter
    def squash(self, value: float):
        self.node.squash = value


class CheckerTexture(BaseNode):
    """
    Generate a checkerboard texture

    Parameters
    ----------
    vector : InputVector
        Vector
    color1 : InputColor
        Color1
    color2 : InputColor
        Color2
    scale : InputFloat
        Scale

    Inputs
    ------
    i.vector : VectorSocket
        Vector
    i.color1 : ColorSocket
        Color1
    i.color2 : ColorSocket
        Color2
    i.scale : FloatSocket
        Scale

    Outputs
    -------
    o.color : ColorSocket
        Color
    o.fac : FloatSocket
        Factor
    """

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

    class _Inputs(SocketAccessor):
        vector: VectorSocket
        """Vector"""
        color1: ColorSocket
        """Color1"""
        color2: ColorSocket
        """Color2"""
        scale: FloatSocket
        """Scale"""

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        fac: FloatSocket
        """Factor"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vector: InputVector = None,
        color1: InputColor = None,
        color2: InputColor = None,
        scale: InputFloat = 5.0,
    ):
        super().__init__()
        key_args = {
            "Vector": vector,
            "Color1": color1,
            "Color2": color2,
            "Scale": scale,
        }

        self._establish_links(**key_args)


class GaborTexture(BaseNode):
    """
    Generate Gabor noise

    Parameters
    ----------
    vector : InputVector
        Vector
    scale : InputFloat
        Scale
    frequency : InputFloat
        Frequency
    anisotropy : InputFloat
        Anisotropy
    orientation_2d : InputFloat
        Orientation
    orientation_3d : InputVector
        Orientation

    Inputs
    ------
    i.vector : VectorSocket
        Vector
    i.scale : FloatSocket
        Scale
    i.frequency : FloatSocket
        Frequency
    i.anisotropy : FloatSocket
        Anisotropy
    i.orientation_2d : FloatSocket
        Orientation
    i.orientation_3d : VectorSocket
        Orientation

    Outputs
    -------
    o.value : FloatSocket
        Value
    o.phase : FloatSocket
        Phase
    o.intensity : FloatSocket
        Intensity
    """

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

    class _Inputs(SocketAccessor):
        vector: VectorSocket
        """Vector"""
        scale: FloatSocket
        """Scale"""
        frequency: FloatSocket
        """Frequency"""
        anisotropy: FloatSocket
        """Anisotropy"""
        orientation_2d: FloatSocket
        """Orientation"""
        orientation_3d: VectorSocket
        """Orientation"""

    class _Outputs(SocketAccessor):
        value: FloatSocket
        """Value"""
        phase: FloatSocket
        """Phase"""
        intensity: FloatSocket
        """Intensity"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        frequency: InputFloat = 2.0,
        anisotropy: InputFloat = 1.0,
        orientation_2d: InputFloat = 0.7854,
        orientation_3d: InputVector = None,
        *,
        gabor_type: Literal["2D", "3D"] = "2D",
    ):
        super().__init__()
        key_args = {
            "Vector": vector,
            "Scale": scale,
            "Frequency": frequency,
            "Anisotropy": anisotropy,
            "Orientation 2D": orientation_2d,
            "Orientation 3D": orientation_3d,
        }
        self.gabor_type = gabor_type
        self._establish_links(**key_args)

    @classmethod
    def input_2d(
        cls,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        frequency: InputFloat = 2.0,
        anisotropy: InputFloat = 1.0,
        orientation_2d: InputFloat = 0.7854,
    ) -> "GaborTexture":
        """Create Gabor Texture with operation '2D'. Use the 2D vector (X, Y) as input. The Z component is ignored."""
        return cls(
            gabor_type="2D",
            vector=vector,
            scale=scale,
            frequency=frequency,
            anisotropy=anisotropy,
            orientation_2d=orientation_2d,
        )

    @classmethod
    def input_3d(
        cls,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        frequency: InputFloat = 2.0,
        anisotropy: InputFloat = 1.0,
        orientation_3d: InputVector = None,
    ) -> "GaborTexture":
        """Create Gabor Texture with operation '3D'. Use the 3D vector (X, Y, Z) as input"""
        return cls(
            gabor_type="3D",
            vector=vector,
            scale=scale,
            frequency=frequency,
            anisotropy=anisotropy,
            orientation_3d=orientation_3d,
        )

    @property
    def gabor_type(self) -> Literal["2D", "3D"]:
        return self.node.gabor_type

    @gabor_type.setter
    def gabor_type(self, value: Literal["2D", "3D"]):
        self.node.gabor_type = value


class GradientTexture(BaseNode):
    """
    Generate interpolated color and intensity values based on the input vector

    Parameters
    ----------
    vector : InputVector
        Vector

    Inputs
    ------
    i.vector : VectorSocket
        Vector

    Outputs
    -------
    o.color : ColorSocket
        Color
    o.fac : FloatSocket
        Factor
    """

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

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

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        fac: FloatSocket
        """Factor"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vector: InputVector = None,
        *,
        gradient_type: Literal[
            "LINEAR",
            "QUADRATIC",
            "EASING",
            "DIAGONAL",
            "SPHERICAL",
            "QUADRATIC_SPHERE",
            "RADIAL",
        ] = "LINEAR",
    ):
        super().__init__()
        key_args = {"Vector": vector}
        self.gradient_type = gradient_type
        self._establish_links(**key_args)

    @classmethod
    def linear(cls, vector: InputVector = None) -> "GradientTexture":
        """Create Gradient Texture with operation 'Linear'. Create a linear progression"""
        return cls(gradient_type="LINEAR", vector=vector)

    @classmethod
    def quadratic(cls, vector: InputVector = None) -> "GradientTexture":
        """Create Gradient Texture with operation 'Quadratic'. Create a quadratic progression"""
        return cls(gradient_type="QUADRATIC", vector=vector)

    @classmethod
    def easing(cls, vector: InputVector = None) -> "GradientTexture":
        """Create Gradient Texture with operation 'Easing'. Create a progression easing from one step to the next"""
        return cls(gradient_type="EASING", vector=vector)

    @classmethod
    def diagonal(cls, vector: InputVector = None) -> "GradientTexture":
        """Create Gradient Texture with operation 'Diagonal'. Create a diagonal progression"""
        return cls(gradient_type="DIAGONAL", vector=vector)

    @classmethod
    def spherical(cls, vector: InputVector = None) -> "GradientTexture":
        """Create Gradient Texture with operation 'Spherical'. Create a spherical progression"""
        return cls(gradient_type="SPHERICAL", vector=vector)

    @classmethod
    def quadratic_sphere(cls, vector: InputVector = None) -> "GradientTexture":
        """Create Gradient Texture with operation 'Quadratic Sphere'. Create a quadratic progression in the shape of a sphere"""
        return cls(gradient_type="QUADRATIC_SPHERE", vector=vector)

    @classmethod
    def radial(cls, vector: InputVector = None) -> "GradientTexture":
        """Create Gradient Texture with operation 'Radial'. Create a radial progression"""
        return cls(gradient_type="RADIAL", vector=vector)

    @property
    def gradient_type(
        self,
    ) -> Literal[
        "LINEAR",
        "QUADRATIC",
        "EASING",
        "DIAGONAL",
        "SPHERICAL",
        "QUADRATIC_SPHERE",
        "RADIAL",
    ]:
        return self.node.gradient_type

    @gradient_type.setter
    def gradient_type(
        self,
        value: Literal[
            "LINEAR",
            "QUADRATIC",
            "EASING",
            "DIAGONAL",
            "SPHERICAL",
            "QUADRATIC_SPHERE",
            "RADIAL",
        ],
    ):
        self.node.gradient_type = value


class ImageTexture(BaseNode):
    """
    Sample values from an image texture

    Parameters
    ----------
    image : InputImage
        Image
    vector : InputVector
        Vector
    frame : InputInteger
        Frame

    Inputs
    ------
    i.image : ImageSocket
        Image
    i.vector : VectorSocket
        Vector
    i.frame : IntegerSocket
        Frame

    Outputs
    -------
    o.color : ColorSocket
        Color
    o.alpha : FloatSocket
        Alpha
    """

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

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

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        alpha: FloatSocket
        """Alpha"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputImage = None,
        vector: InputVector = None,
        frame: InputInteger = 0,
        *,
        interpolation: Literal["Linear", "Closest", "Cubic"] = "Linear",
        extension: Literal["REPEAT", "EXTEND", "CLIP", "MIRROR"] = "REPEAT",
    ):
        super().__init__()
        key_args = {"Image": image, "Vector": vector, "Frame": frame}
        self.interpolation = interpolation
        self.extension = extension
        self._establish_links(**key_args)

    @property
    def interpolation(self) -> Literal["Linear", "Closest", "Cubic"]:
        return self.node.interpolation

    @interpolation.setter
    def interpolation(self, value: Literal["Linear", "Closest", "Cubic"]):
        self.node.interpolation = value

    @property
    def extension(self) -> Literal["REPEAT", "EXTEND", "CLIP", "MIRROR"]:
        return self.node.extension

    @extension.setter
    def extension(self, value: Literal["REPEAT", "EXTEND", "CLIP", "MIRROR"]):
        self.node.extension = value


class MagicTexture(BaseNode):
    """
    Generate a psychedelic color texture

    Parameters
    ----------
    vector : InputVector
        Vector
    scale : InputFloat
        Scale
    distortion : InputFloat
        Distortion

    Inputs
    ------
    i.vector : VectorSocket
        Vector
    i.scale : FloatSocket
        Scale
    i.distortion : FloatSocket
        Distortion

    Outputs
    -------
    o.color : ColorSocket
        Color
    o.fac : FloatSocket
        Factor
    """

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

    class _Inputs(SocketAccessor):
        vector: VectorSocket
        """Vector"""
        scale: FloatSocket
        """Scale"""
        distortion: FloatSocket
        """Distortion"""

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        fac: FloatSocket
        """Factor"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        distortion: InputFloat = 1.0,
        *,
        turbulence_depth: int = 0,
    ):
        super().__init__()
        key_args = {"Vector": vector, "Scale": scale, "Distortion": distortion}
        self.turbulence_depth = turbulence_depth
        self._establish_links(**key_args)

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

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


class NoiseTexture(BaseNode):
    """
    Generate fractal Perlin noise

    Parameters
    ----------
    vector : InputVector
        Vector
    w : InputFloat
        W
    scale : InputFloat
        Scale
    detail : InputFloat
        Detail
    roughness : InputFloat
        Roughness
    lacunarity : InputFloat
        Lacunarity
    offset : InputFloat
        Offset
    gain : InputFloat
        Gain
    distortion : InputFloat
        Distortion

    Inputs
    ------
    i.vector : VectorSocket
        Vector
    i.w : FloatSocket
        W
    i.scale : FloatSocket
        Scale
    i.detail : FloatSocket
        Detail
    i.roughness : FloatSocket
        Roughness
    i.lacunarity : FloatSocket
        Lacunarity
    i.offset : FloatSocket
        Offset
    i.gain : FloatSocket
        Gain
    i.distortion : FloatSocket
        Distortion

    Outputs
    -------
    o.fac : FloatSocket
        Factor
    o.color : ColorSocket
        Color
    """

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

    class _Inputs(SocketAccessor):
        vector: VectorSocket
        """Vector"""
        w: FloatSocket
        """W"""
        scale: FloatSocket
        """Scale"""
        detail: FloatSocket
        """Detail"""
        roughness: FloatSocket
        """Roughness"""
        lacunarity: FloatSocket
        """Lacunarity"""
        offset: FloatSocket
        """Offset"""
        gain: FloatSocket
        """Gain"""
        distortion: FloatSocket
        """Distortion"""

    class _Outputs(SocketAccessor):
        fac: FloatSocket
        """Factor"""
        color: ColorSocket
        """Color"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vector: InputVector = None,
        w: InputFloat = 0.0,
        scale: InputFloat = 5.0,
        detail: InputFloat = 2.0,
        roughness: InputFloat = 0.5,
        lacunarity: InputFloat = 2.0,
        offset: InputFloat = 0.0,
        gain: InputFloat = 1.0,
        distortion: InputFloat = 0.0,
        *,
        noise_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
        noise_type: Literal[
            "MULTIFRACTAL",
            "RIDGED_MULTIFRACTAL",
            "HYBRID_MULTIFRACTAL",
            "FBM",
            "HETERO_TERRAIN",
        ] = "FBM",
        normalize: bool = False,
    ):
        super().__init__()
        key_args = {
            "Vector": vector,
            "W": w,
            "Scale": scale,
            "Detail": detail,
            "Roughness": roughness,
            "Lacunarity": lacunarity,
            "Offset": offset,
            "Gain": gain,
            "Distortion": distortion,
        }
        self.noise_dimensions = noise_dimensions
        self.noise_type = noise_type
        self.normalize = normalize
        self._establish_links(**key_args)

    @classmethod
    def multifractal(
        cls,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        detail: InputFloat = 2.0,
        roughness: InputFloat = 0.5,
        lacunarity: InputFloat = 2.0,
        distortion: InputFloat = 0.0,
    ) -> "NoiseTexture":
        """Create Noise Texture with operation 'Multifractal'. More uneven result (varies with location), more similar to a real terrain"""
        return cls(
            noise_type="MULTIFRACTAL",
            vector=vector,
            scale=scale,
            detail=detail,
            roughness=roughness,
            lacunarity=lacunarity,
            distortion=distortion,
        )

    @classmethod
    def ridged_multifractal(
        cls,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        detail: InputFloat = 2.0,
        roughness: InputFloat = 0.5,
        lacunarity: InputFloat = 2.0,
        offset: InputFloat = 0.0,
        gain: InputFloat = 1.0,
        distortion: InputFloat = 0.0,
    ) -> "NoiseTexture":
        """Create Noise Texture with operation 'Ridged Multifractal'. Create sharp peaks"""
        return cls(
            noise_type="RIDGED_MULTIFRACTAL",
            vector=vector,
            scale=scale,
            detail=detail,
            roughness=roughness,
            lacunarity=lacunarity,
            offset=offset,
            gain=gain,
            distortion=distortion,
        )

    @classmethod
    def hybrid_multifractal(
        cls,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        detail: InputFloat = 2.0,
        roughness: InputFloat = 0.5,
        lacunarity: InputFloat = 2.0,
        offset: InputFloat = 0.0,
        gain: InputFloat = 1.0,
        distortion: InputFloat = 0.0,
    ) -> "NoiseTexture":
        """Create Noise Texture with operation 'Hybrid Multifractal'. Create peaks and valleys with different roughness values"""
        return cls(
            noise_type="HYBRID_MULTIFRACTAL",
            vector=vector,
            scale=scale,
            detail=detail,
            roughness=roughness,
            lacunarity=lacunarity,
            offset=offset,
            gain=gain,
            distortion=distortion,
        )

    @classmethod
    def fbm(
        cls,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        detail: InputFloat = 2.0,
        roughness: InputFloat = 0.5,
        lacunarity: InputFloat = 2.0,
        distortion: InputFloat = 0.0,
    ) -> "NoiseTexture":
        """Create Noise Texture with operation 'fBM'. The standard fractal Perlin noise"""
        return cls(
            noise_type="FBM",
            vector=vector,
            scale=scale,
            detail=detail,
            roughness=roughness,
            lacunarity=lacunarity,
            distortion=distortion,
        )

    @classmethod
    def hetero_terrain(
        cls,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        detail: InputFloat = 2.0,
        roughness: InputFloat = 0.5,
        lacunarity: InputFloat = 2.0,
        offset: InputFloat = 0.0,
        distortion: InputFloat = 0.0,
    ) -> "NoiseTexture":
        """Create Noise Texture with operation 'Hetero Terrain'. Similar to Hybrid Multifractal creates a heterogeneous terrain, but with the likeness of river channels"""
        return cls(
            noise_type="HETERO_TERRAIN",
            vector=vector,
            scale=scale,
            detail=detail,
            roughness=roughness,
            lacunarity=lacunarity,
            offset=offset,
            distortion=distortion,
        )

    @property
    def noise_dimensions(self) -> Literal["1D", "2D", "3D", "4D"]:
        return self.node.noise_dimensions

    @noise_dimensions.setter
    def noise_dimensions(self, value: Literal["1D", "2D", "3D", "4D"]):
        self.node.noise_dimensions = value

    @property
    def noise_type(
        self,
    ) -> Literal[
        "MULTIFRACTAL",
        "RIDGED_MULTIFRACTAL",
        "HYBRID_MULTIFRACTAL",
        "FBM",
        "HETERO_TERRAIN",
    ]:
        return self.node.noise_type

    @noise_type.setter
    def noise_type(
        self,
        value: Literal[
            "MULTIFRACTAL",
            "RIDGED_MULTIFRACTAL",
            "HYBRID_MULTIFRACTAL",
            "FBM",
            "HETERO_TERRAIN",
        ],
    ):
        self.node.noise_type = value

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

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


class VoronoiTexture(BaseNode):
    """
    Generate Worley noise based on the distance to random points. Typically used to generate textures such as stones, water, or biological cells

    Parameters
    ----------
    vector : InputVector
        Vector
    w : InputFloat
        W
    scale : InputFloat
        Scale
    detail : InputFloat
        Detail
    roughness : InputFloat
        Roughness
    lacunarity : InputFloat
        Lacunarity
    smoothness : InputFloat
        Smoothness
    exponent : InputFloat
        Exponent
    randomness : InputFloat
        Randomness

    Inputs
    ------
    i.vector : VectorSocket
        Vector
    i.w : FloatSocket
        W
    i.scale : FloatSocket
        Scale
    i.detail : FloatSocket
        Detail
    i.roughness : FloatSocket
        Roughness
    i.lacunarity : FloatSocket
        Lacunarity
    i.smoothness : FloatSocket
        Smoothness
    i.exponent : FloatSocket
        Exponent
    i.randomness : FloatSocket
        Randomness

    Outputs
    -------
    o.distance : FloatSocket
        Distance
    o.color : ColorSocket
        Color
    o.position : VectorSocket
        Position
    o.w : FloatSocket
        W
    o.radius : FloatSocket
        Radius
    """

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

    class _Inputs(SocketAccessor):
        vector: VectorSocket
        """Vector"""
        w: FloatSocket
        """W"""
        scale: FloatSocket
        """Scale"""
        detail: FloatSocket
        """Detail"""
        roughness: FloatSocket
        """Roughness"""
        lacunarity: FloatSocket
        """Lacunarity"""
        smoothness: FloatSocket
        """Smoothness"""
        exponent: FloatSocket
        """Exponent"""
        randomness: FloatSocket
        """Randomness"""

    class _Outputs(SocketAccessor):
        distance: FloatSocket
        """Distance"""
        color: ColorSocket
        """Color"""
        position: VectorSocket
        """Position"""
        w: FloatSocket
        """W"""
        radius: FloatSocket
        """Radius"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vector: InputVector = None,
        w: InputFloat = 0.0,
        scale: InputFloat = 5.0,
        detail: InputFloat = 0.0,
        roughness: InputFloat = 0.5,
        lacunarity: InputFloat = 2.0,
        smoothness: InputFloat = 1.0,
        exponent: InputFloat = 0.5,
        randomness: InputFloat = 1.0,
        *,
        voronoi_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
        distance: Literal[
            "EUCLIDEAN", "MANHATTAN", "CHEBYCHEV", "MINKOWSKI"
        ] = "EUCLIDEAN",
        feature: Literal[
            "F1", "F2", "SMOOTH_F1", "DISTANCE_TO_EDGE", "N_SPHERE_RADIUS"
        ] = "F1",
        normalize: bool = False,
    ):
        super().__init__()
        key_args = {
            "Vector": vector,
            "W": w,
            "Scale": scale,
            "Detail": detail,
            "Roughness": roughness,
            "Lacunarity": lacunarity,
            "Smoothness": smoothness,
            "Exponent": exponent,
            "Randomness": randomness,
        }
        self.voronoi_dimensions = voronoi_dimensions
        self.distance = distance
        self.feature = feature
        self.normalize = normalize
        self._establish_links(**key_args)

    @property
    def voronoi_dimensions(self) -> Literal["1D", "2D", "3D", "4D"]:
        return self.node.voronoi_dimensions

    @voronoi_dimensions.setter
    def voronoi_dimensions(self, value: Literal["1D", "2D", "3D", "4D"]):
        self.node.voronoi_dimensions = value

    @property
    def distance(self) -> Literal["EUCLIDEAN", "MANHATTAN", "CHEBYCHEV", "MINKOWSKI"]:
        return self.node.distance

    @distance.setter
    def distance(
        self, value: Literal["EUCLIDEAN", "MANHATTAN", "CHEBYCHEV", "MINKOWSKI"]
    ):
        self.node.distance = value

    @property
    def feature(
        self,
    ) -> Literal["F1", "F2", "SMOOTH_F1", "DISTANCE_TO_EDGE", "N_SPHERE_RADIUS"]:
        return self.node.feature

    @feature.setter
    def feature(
        self,
        value: Literal["F1", "F2", "SMOOTH_F1", "DISTANCE_TO_EDGE", "N_SPHERE_RADIUS"],
    ):
        self.node.feature = value

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

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


class WaveTexture(BaseNode):
    """
    Generate procedural bands or rings with noise

    Parameters
    ----------
    vector : InputVector
        Vector
    scale : InputFloat
        Scale
    distortion : InputFloat
        Distortion
    detail : InputFloat
        Detail
    detail_scale : InputFloat
        Detail Scale
    detail_roughness : InputFloat
        Detail Roughness
    phase_offset : InputFloat
        Phase Offset

    Inputs
    ------
    i.vector : VectorSocket
        Vector
    i.scale : FloatSocket
        Scale
    i.distortion : FloatSocket
        Distortion
    i.detail : FloatSocket
        Detail
    i.detail_scale : FloatSocket
        Detail Scale
    i.detail_roughness : FloatSocket
        Detail Roughness
    i.phase_offset : FloatSocket
        Phase Offset

    Outputs
    -------
    o.color : ColorSocket
        Color
    o.fac : FloatSocket
        Factor
    """

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

    class _Inputs(SocketAccessor):
        vector: VectorSocket
        """Vector"""
        scale: FloatSocket
        """Scale"""
        distortion: FloatSocket
        """Distortion"""
        detail: FloatSocket
        """Detail"""
        detail_scale: FloatSocket
        """Detail Scale"""
        detail_roughness: FloatSocket
        """Detail Roughness"""
        phase_offset: FloatSocket
        """Phase Offset"""

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        fac: FloatSocket
        """Factor"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        distortion: InputFloat = 0.0,
        detail: InputFloat = 2.0,
        detail_scale: InputFloat = 1.0,
        detail_roughness: InputFloat = 0.5,
        phase_offset: InputFloat = 0.0,
        *,
        wave_type: Literal["BANDS", "RINGS"] = "BANDS",
        bands_direction: Literal["X", "Y", "Z", "DIAGONAL"] = "X",
        rings_direction: Literal["X", "Y", "Z", "SPHERICAL"] = "X",
        wave_profile: Literal["SIN", "SAW", "TRI"] = "SIN",
    ):
        super().__init__()
        key_args = {
            "Vector": vector,
            "Scale": scale,
            "Distortion": distortion,
            "Detail": detail,
            "Detail Scale": detail_scale,
            "Detail Roughness": detail_roughness,
            "Phase Offset": phase_offset,
        }
        self.wave_type = wave_type
        self.bands_direction = bands_direction
        self.rings_direction = rings_direction
        self.wave_profile = wave_profile
        self._establish_links(**key_args)

    @classmethod
    def bands(
        cls,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        distortion: InputFloat = 0.0,
        detail: InputFloat = 2.0,
        detail_scale: InputFloat = 1.0,
        detail_roughness: InputFloat = 0.5,
        phase_offset: InputFloat = 0.0,
    ) -> "WaveTexture":
        """Create Wave Texture with operation 'Bands'. Use standard wave texture in bands"""
        return cls(
            wave_type="BANDS",
            vector=vector,
            scale=scale,
            distortion=distortion,
            detail=detail,
            detail_scale=detail_scale,
            detail_roughness=detail_roughness,
            phase_offset=phase_offset,
        )

    @classmethod
    def rings(
        cls,
        vector: InputVector = None,
        scale: InputFloat = 5.0,
        distortion: InputFloat = 0.0,
        detail: InputFloat = 2.0,
        detail_scale: InputFloat = 1.0,
        detail_roughness: InputFloat = 0.5,
        phase_offset: InputFloat = 0.0,
    ) -> "WaveTexture":
        """Create Wave Texture with operation 'Rings'. Use wave texture in rings"""
        return cls(
            wave_type="RINGS",
            vector=vector,
            scale=scale,
            distortion=distortion,
            detail=detail,
            detail_scale=detail_scale,
            detail_roughness=detail_roughness,
            phase_offset=phase_offset,
        )

    @property
    def wave_type(self) -> Literal["BANDS", "RINGS"]:
        return self.node.wave_type

    @wave_type.setter
    def wave_type(self, value: Literal["BANDS", "RINGS"]):
        self.node.wave_type = value

    @property
    def bands_direction(self) -> Literal["X", "Y", "Z", "DIAGONAL"]:
        return self.node.bands_direction

    @bands_direction.setter
    def bands_direction(self, value: Literal["X", "Y", "Z", "DIAGONAL"]):
        self.node.bands_direction = value

    @property
    def rings_direction(self) -> Literal["X", "Y", "Z", "SPHERICAL"]:
        return self.node.rings_direction

    @rings_direction.setter
    def rings_direction(self, value: Literal["X", "Y", "Z", "SPHERICAL"]):
        self.node.rings_direction = value

    @property
    def wave_profile(self) -> Literal["SIN", "SAW", "TRI"]:
        return self.node.wave_profile

    @wave_profile.setter
    def wave_profile(self, value: Literal["SIN", "SAW", "TRI"]):
        self.node.wave_profile = value


class WhiteNoiseTexture(BaseNode):
    """
    Calculate a random value or color based on an input seed

    Parameters
    ----------
    vector : InputVector
        Vector
    w : InputFloat
        W

    Inputs
    ------
    i.vector : VectorSocket
        Vector
    i.w : FloatSocket
        W

    Outputs
    -------
    o.value : FloatSocket
        Value
    o.color : ColorSocket
        Color
    """

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

    class _Inputs(SocketAccessor):
        vector: VectorSocket
        """Vector"""
        w: FloatSocket
        """W"""

    class _Outputs(SocketAccessor):
        value: FloatSocket
        """Value"""
        color: ColorSocket
        """Color"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        vector: InputVector = None,
        w: InputFloat = 0.0,
        *,
        noise_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
    ):
        super().__init__()
        key_args = {"Vector": vector, "W": w}
        self.noise_dimensions = noise_dimensions
        self._establish_links(**key_args)

    @property
    def noise_dimensions(self) -> Literal["1D", "2D", "3D", "4D"]:
        return self.node.noise_dimensions

    @noise_dimensions.setter
    def noise_dimensions(self, value: Literal["1D", "2D", "3D", "4D"]):
        self.node.noise_dimensions = value
