# 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 (
    InputBoolean,
    InputColor,
    InputFloat,
    InputShader,
    InputVector,
)

from ...builder.socket import (
    BooleanSocket,
    ColorSocket,
    FloatSocket,
    ShaderSocket,
    VectorSocket,
)


class AddShader(BaseNode):
    """
    Add two Shaders together

    Parameters
    ----------
    shader : InputShader
        Shader
    shader_001 : InputShader
        Shader

    Inputs
    ------
    i.shader : ShaderSocket
        Shader
    i.shader_001 : ShaderSocket
        Shader

    Outputs
    -------
    o.shader : ShaderSocket
        Shader
    """

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

    class _Inputs(SocketAccessor):
        shader: ShaderSocket
        """Shader"""
        shader_001: ShaderSocket
        """Shader"""

    class _Outputs(SocketAccessor):
        shader: ShaderSocket
        """Shader"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        shader: InputShader = None,
        shader_001: InputShader = None,
    ):
        super().__init__()
        key_args = {"Shader": shader, "Shader_001": shader_001}

        self._establish_links(**key_args)


class Background(BaseNode):
    """
        Add background light emission.
    Note: This node should only be used for the world surface output

        Parameters
        ----------
        color : InputColor
            Color
        strength : InputFloat
            Strength
        weight : InputFloat
            Weight

        Inputs
        ------
        i.color : ColorSocket
            Color
        i.strength : FloatSocket
            Strength
        i.weight : FloatSocket
            Weight

        Outputs
        -------
        o.background : ShaderSocket
            Background
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        strength: FloatSocket
        """Strength"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        background: ShaderSocket
        """Background"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        strength: InputFloat = 1.0,
        weight: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {"Color": color, "Strength": strength, "Weight": weight}

        self._establish_links(**key_args)


class DiffuseBSDF(BaseNode):
    """
    Lambertian and Oren-Nayar diffuse reflection

    Parameters
    ----------
    color : InputColor
        Color
    roughness : InputFloat
        Roughness
    normal : InputVector
        Normal
    weight : InputFloat
        Weight

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.roughness : FloatSocket
        Roughness
    i.normal : VectorSocket
        Normal
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        roughness: FloatSocket
        """Roughness"""
        normal: VectorSocket
        """Normal"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        roughness: InputFloat = 0.0,
        normal: InputVector = None,
        weight: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {
            "Color": color,
            "Roughness": roughness,
            "Normal": normal,
            "Weight": weight,
        }

        self._establish_links(**key_args)


class Emission(BaseNode):
    """
    Lambertian emission shader

    Parameters
    ----------
    color : InputColor
        Color
    strength : InputFloat
        Strength
    weight : InputFloat
        Weight

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.strength : FloatSocket
        Strength
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.emission : ShaderSocket
        Emission
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        strength: FloatSocket
        """Strength"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        emission: ShaderSocket
        """Emission"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        strength: InputFloat = 1.0,
        weight: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {"Color": color, "Strength": strength, "Weight": weight}

        self._establish_links(**key_args)


class GlassBSDF(BaseNode):
    """
    Glass-like shader mixing refraction and reflection at grazing angles

    Parameters
    ----------
    color : InputColor
        Color
    roughness : InputFloat
        Roughness
    ior : InputFloat
        IOR
    normal : InputVector
        Normal
    weight : InputFloat
        Weight
    thin_film_thickness : InputFloat
        Thin Film Thickness
    thin_film_ior : InputFloat
        Thin Film IOR

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.roughness : FloatSocket
        Roughness
    i.ior : FloatSocket
        IOR
    i.normal : VectorSocket
        Normal
    i.weight : FloatSocket
        Weight
    i.thin_film_thickness : FloatSocket
        Thin Film Thickness
    i.thin_film_ior : FloatSocket
        Thin Film IOR

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        roughness: FloatSocket
        """Roughness"""
        ior: FloatSocket
        """IOR"""
        normal: VectorSocket
        """Normal"""
        weight: FloatSocket
        """Weight"""
        thin_film_thickness: FloatSocket
        """Thin Film Thickness"""
        thin_film_ior: FloatSocket
        """Thin Film IOR"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        roughness: InputFloat = 0.0,
        ior: InputFloat = 1.5,
        normal: InputVector = None,
        weight: InputFloat = 0.0,
        thin_film_thickness: InputFloat = 0.0,
        thin_film_ior: InputFloat = 1.33,
        *,
        distribution: Literal["BECKMANN", "GGX", "MULTI_GGX"] = "MULTI_GGX",
    ):
        super().__init__()
        key_args = {
            "Color": color,
            "Roughness": roughness,
            "IOR": ior,
            "Normal": normal,
            "Weight": weight,
            "Thin Film Thickness": thin_film_thickness,
            "Thin Film IOR": thin_film_ior,
        }
        self.distribution = distribution
        self._establish_links(**key_args)

    @property
    def distribution(self) -> Literal["BECKMANN", "GGX", "MULTI_GGX"]:
        return self.node.distribution

    @distribution.setter
    def distribution(self, value: Literal["BECKMANN", "GGX", "MULTI_GGX"]):
        self.node.distribution = value


class GlossyBSDF(BaseNode):
    """
    Reflection with microfacet distribution, used for materials such as metal or mirrors

    Parameters
    ----------
    color : InputColor
        Color
    roughness : InputFloat
        Roughness
    anisotropy : InputFloat
        Anisotropy
    rotation : InputFloat
        Rotation
    normal : InputVector
        Normal
    tangent : InputVector
        Tangent
    weight : InputFloat
        Weight

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.roughness : FloatSocket
        Roughness
    i.anisotropy : FloatSocket
        Anisotropy
    i.rotation : FloatSocket
        Rotation
    i.normal : VectorSocket
        Normal
    i.tangent : VectorSocket
        Tangent
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        roughness: FloatSocket
        """Roughness"""
        anisotropy: FloatSocket
        """Anisotropy"""
        rotation: FloatSocket
        """Rotation"""
        normal: VectorSocket
        """Normal"""
        tangent: VectorSocket
        """Tangent"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        roughness: InputFloat = 0.5,
        anisotropy: InputFloat = 0.0,
        rotation: InputFloat = 0.0,
        normal: InputVector = None,
        tangent: InputVector = None,
        weight: InputFloat = 0.0,
        *,
        distribution: Literal[
            "BECKMANN", "GGX", "ASHIKHMIN_SHIRLEY", "MULTI_GGX"
        ] = "MULTI_GGX",
    ):
        super().__init__()
        key_args = {
            "Color": color,
            "Roughness": roughness,
            "Anisotropy": anisotropy,
            "Rotation": rotation,
            "Normal": normal,
            "Tangent": tangent,
            "Weight": weight,
        }
        self.distribution = distribution
        self._establish_links(**key_args)

    @property
    def distribution(
        self,
    ) -> Literal["BECKMANN", "GGX", "ASHIKHMIN_SHIRLEY", "MULTI_GGX"]:
        return self.node.distribution

    @distribution.setter
    def distribution(
        self, value: Literal["BECKMANN", "GGX", "ASHIKHMIN_SHIRLEY", "MULTI_GGX"]
    ):
        self.node.distribution = value


class HairBSDF(BaseNode):
    """
    Reflection and transmission shaders optimized for hair rendering

    Parameters
    ----------
    color : InputColor
        Color
    offset : InputFloat
        Offset
    roughnessu : InputFloat
        RoughnessU
    roughnessv : InputFloat
        RoughnessV
    tangent : InputVector
        Tangent
    weight : InputFloat
        Weight

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.offset : FloatSocket
        Offset
    i.roughnessu : FloatSocket
        RoughnessU
    i.roughnessv : FloatSocket
        RoughnessV
    i.tangent : VectorSocket
        Tangent
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        offset: FloatSocket
        """Offset"""
        roughnessu: FloatSocket
        """RoughnessU"""
        roughnessv: FloatSocket
        """RoughnessV"""
        tangent: VectorSocket
        """Tangent"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        offset: InputFloat = 0.0,
        roughnessu: InputFloat = 0.1,
        roughnessv: InputFloat = 1.0,
        tangent: InputVector = None,
        weight: InputFloat = 0.0,
        *,
        component: Literal["Reflection", "Transmission"] = "Reflection",
    ):
        super().__init__()
        key_args = {
            "Color": color,
            "Offset": offset,
            "RoughnessU": roughnessu,
            "RoughnessV": roughnessv,
            "Tangent": tangent,
            "Weight": weight,
        }
        self.component = component
        self._establish_links(**key_args)

    @property
    def component(self) -> Literal["Reflection", "Transmission"]:
        return self.node.component

    @component.setter
    def component(self, value: Literal["Reflection", "Transmission"]):
        self.node.component = value


class Holdout(BaseNode):
    """
        Create a "hole" in the image with zero alpha transparency, which is useful for compositing.
    Note: the holdout shader can only create alpha when transparency is enabled in the film settings

        Parameters
        ----------
        weight : InputFloat
            Weight

        Inputs
        ------
        i.weight : FloatSocket
            Weight

        Outputs
        -------
        o.holdout : ShaderSocket
            Holdout
    """

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

    class _Inputs(SocketAccessor):
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        holdout: ShaderSocket
        """Holdout"""

    if TYPE_CHECKING:

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

    def __init__(self, weight: InputFloat = 0.0):
        super().__init__()
        key_args = {"Weight": weight}

        self._establish_links(**key_args)


class MetallicBSDF(BaseNode):
    """
    Metallic reflection with microfacet distribution, and metallic fresnel

    Parameters
    ----------
    base_color : InputColor
        Base Color
    edge_tint : InputColor
        Edge Tint
    ior : InputVector
        IOR
    extinction : InputVector
        Extinction
    roughness : InputFloat
        Roughness
    anisotropy : InputFloat
        Anisotropy
    rotation : InputFloat
        Rotation
    normal : InputVector
        Normal
    tangent : InputVector
        Tangent
    weight : InputFloat
        Weight
    thin_film_thickness : InputFloat
        Thin Film Thickness
    thin_film_ior : InputFloat
        Thin Film IOR

    Inputs
    ------
    i.base_color : ColorSocket
        Base Color
    i.edge_tint : ColorSocket
        Edge Tint
    i.ior : VectorSocket
        IOR
    i.extinction : VectorSocket
        Extinction
    i.roughness : FloatSocket
        Roughness
    i.anisotropy : FloatSocket
        Anisotropy
    i.rotation : FloatSocket
        Rotation
    i.normal : VectorSocket
        Normal
    i.tangent : VectorSocket
        Tangent
    i.weight : FloatSocket
        Weight
    i.thin_film_thickness : FloatSocket
        Thin Film Thickness
    i.thin_film_ior : FloatSocket
        Thin Film IOR

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        base_color: ColorSocket
        """Base Color"""
        edge_tint: ColorSocket
        """Edge Tint"""
        ior: VectorSocket
        """IOR"""
        extinction: VectorSocket
        """Extinction"""
        roughness: FloatSocket
        """Roughness"""
        anisotropy: FloatSocket
        """Anisotropy"""
        rotation: FloatSocket
        """Rotation"""
        normal: VectorSocket
        """Normal"""
        tangent: VectorSocket
        """Tangent"""
        weight: FloatSocket
        """Weight"""
        thin_film_thickness: FloatSocket
        """Thin Film Thickness"""
        thin_film_ior: FloatSocket
        """Thin Film IOR"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        base_color: InputColor = None,
        edge_tint: InputColor = None,
        ior: InputVector = None,
        extinction: InputVector = None,
        roughness: InputFloat = 0.5,
        anisotropy: InputFloat = 0.0,
        rotation: InputFloat = 0.0,
        normal: InputVector = None,
        tangent: InputVector = None,
        weight: InputFloat = 0.0,
        thin_film_thickness: InputFloat = 0.0,
        thin_film_ior: InputFloat = 1.33,
        *,
        distribution: Literal["BECKMANN", "GGX", "MULTI_GGX"] = "MULTI_GGX",
        fresnel_type: Literal["PHYSICAL_CONDUCTOR", "F82"] = "F82",
    ):
        super().__init__()
        key_args = {
            "Base Color": base_color,
            "Edge Tint": edge_tint,
            "IOR": ior,
            "Extinction": extinction,
            "Roughness": roughness,
            "Anisotropy": anisotropy,
            "Rotation": rotation,
            "Normal": normal,
            "Tangent": tangent,
            "Weight": weight,
            "Thin Film Thickness": thin_film_thickness,
            "Thin Film IOR": thin_film_ior,
        }
        self.distribution = distribution
        self.fresnel_type = fresnel_type
        self._establish_links(**key_args)

    @classmethod
    def physical_conductor(
        cls,
        ior: InputVector = None,
        extinction: InputVector = None,
        roughness: InputFloat = 0.5,
        anisotropy: InputFloat = 0.0,
        rotation: InputFloat = 0.0,
        normal: InputVector = None,
        tangent: InputVector = None,
        thin_film_thickness: InputFloat = 0.0,
        thin_film_ior: InputFloat = 1.33,
    ) -> "MetallicBSDF":
        """Create Metallic BSDF with operation 'Physical Conductor'. Fresnel conductor based on the complex refractive index per color channel"""
        return cls(
            fresnel_type="PHYSICAL_CONDUCTOR",
            ior=ior,
            extinction=extinction,
            roughness=roughness,
            anisotropy=anisotropy,
            rotation=rotation,
            normal=normal,
            tangent=tangent,
            thin_film_thickness=thin_film_thickness,
            thin_film_ior=thin_film_ior,
        )

    @classmethod
    def f82_tint(
        cls,
        base_color: InputColor = None,
        edge_tint: InputColor = None,
        roughness: InputFloat = 0.5,
        anisotropy: InputFloat = 0.0,
        rotation: InputFloat = 0.0,
        normal: InputVector = None,
        tangent: InputVector = None,
        thin_film_thickness: InputFloat = 0.0,
        thin_film_ior: InputFloat = 1.33,
    ) -> "MetallicBSDF":
        """Create Metallic BSDF with operation 'F82 Tint'. An approximation of the Fresnel conductor curve based on the colors at perpendicular and near-grazing (roughly 82°) angles"""
        return cls(
            fresnel_type="F82",
            base_color=base_color,
            edge_tint=edge_tint,
            roughness=roughness,
            anisotropy=anisotropy,
            rotation=rotation,
            normal=normal,
            tangent=tangent,
            thin_film_thickness=thin_film_thickness,
            thin_film_ior=thin_film_ior,
        )

    @property
    def distribution(self) -> Literal["BECKMANN", "GGX", "MULTI_GGX"]:
        return self.node.distribution

    @distribution.setter
    def distribution(self, value: Literal["BECKMANN", "GGX", "MULTI_GGX"]):
        self.node.distribution = value

    @property
    def fresnel_type(self) -> Literal["PHYSICAL_CONDUCTOR", "F82"]:
        return self.node.fresnel_type

    @fresnel_type.setter
    def fresnel_type(self, value: Literal["PHYSICAL_CONDUCTOR", "F82"]):
        self.node.fresnel_type = value


class MixShader(BaseNode):
    """
    Mix two shaders together. Typically used for material layering

    Parameters
    ----------
    fac : InputFloat
        Factor
    shader : InputShader
        Shader
    shader_001 : InputShader
        Shader

    Inputs
    ------
    i.fac : FloatSocket
        Factor
    i.shader : ShaderSocket
        Shader
    i.shader_001 : ShaderSocket
        Shader

    Outputs
    -------
    o.shader : ShaderSocket
        Shader
    """

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

    class _Inputs(SocketAccessor):
        fac: FloatSocket
        """Factor"""
        shader: ShaderSocket
        """Shader"""
        shader_001: ShaderSocket
        """Shader"""

    class _Outputs(SocketAccessor):
        shader: ShaderSocket
        """Shader"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        fac: InputFloat = 0.5,
        shader: InputShader = None,
        shader_001: InputShader = None,
    ):
        super().__init__()
        key_args = {"Fac": fac, "Shader": shader, "Shader_001": shader_001}

        self._establish_links(**key_args)


class PrincipledBSDF(BaseNode):
    """
    Physically-based, easy-to-use shader for rendering surface materials, based on the OpenPBR model

    Parameters
    ----------
    base_color : InputColor
        Base Color
    metallic : InputFloat
        Metallic
    roughness : InputFloat
        Roughness
    ior : InputFloat
        IOR
    alpha : InputFloat
        Alpha
    thin_wall : InputBoolean
        Thin Wall
    normal : InputVector
        Normal
    weight : InputFloat
        Weight
    diffuse_roughness : InputFloat
        Diffuse Roughness
    subsurface_weight : InputFloat
        Subsurface Weight
    subsurface_radius : InputVector
        Subsurface Radius
    subsurface_scale : InputFloat
        Subsurface Scale
    subsurface_ior : InputFloat
        Subsurface IOR
    subsurface_anisotropy : InputFloat
        Subsurface Anisotropy
    specular_ior_level : InputFloat
        Specular IOR Level
    specular_tint : InputColor
        Specular Tint
    anisotropic : InputFloat
        Anisotropic
    anisotropic_rotation : InputFloat
        Anisotropic Rotation
    tangent : InputVector
        Tangent
    transmission_weight : InputFloat
        Transmission Weight
    coat_weight : InputFloat
        Coat Weight
    coat_roughness : InputFloat
        Coat Roughness
    coat_ior : InputFloat
        Coat IOR
    coat_tint : InputColor
        Coat Tint
    coat_normal : InputVector
        Coat Normal
    sheen_weight : InputFloat
        Sheen Weight
    sheen_roughness : InputFloat
        Sheen Roughness
    sheen_tint : InputColor
        Sheen Tint
    emission_color : InputColor
        Emission Color
    emission_strength : InputFloat
        Emission Strength
    thin_film_thickness : InputFloat
        Thin Film Thickness
    thin_film_ior : InputFloat
        Thin Film IOR

    Inputs
    ------
    i.base_color : ColorSocket
        Base Color
    i.metallic : FloatSocket
        Metallic
    i.roughness : FloatSocket
        Roughness
    i.ior : FloatSocket
        IOR
    i.alpha : FloatSocket
        Alpha
    i.thin_wall : BooleanSocket
        Thin Wall
    i.normal : VectorSocket
        Normal
    i.weight : FloatSocket
        Weight
    i.diffuse_roughness : FloatSocket
        Diffuse Roughness
    i.subsurface_weight : FloatSocket
        Subsurface Weight
    i.subsurface_radius : VectorSocket
        Subsurface Radius
    i.subsurface_scale : FloatSocket
        Subsurface Scale
    i.subsurface_ior : FloatSocket
        Subsurface IOR
    i.subsurface_anisotropy : FloatSocket
        Subsurface Anisotropy
    i.specular_ior_level : FloatSocket
        Specular IOR Level
    i.specular_tint : ColorSocket
        Specular Tint
    i.anisotropic : FloatSocket
        Anisotropic
    i.anisotropic_rotation : FloatSocket
        Anisotropic Rotation
    i.tangent : VectorSocket
        Tangent
    i.transmission_weight : FloatSocket
        Transmission Weight
    i.coat_weight : FloatSocket
        Coat Weight
    i.coat_roughness : FloatSocket
        Coat Roughness
    i.coat_ior : FloatSocket
        Coat IOR
    i.coat_tint : ColorSocket
        Coat Tint
    i.coat_normal : VectorSocket
        Coat Normal
    i.sheen_weight : FloatSocket
        Sheen Weight
    i.sheen_roughness : FloatSocket
        Sheen Roughness
    i.sheen_tint : ColorSocket
        Sheen Tint
    i.emission_color : ColorSocket
        Emission Color
    i.emission_strength : FloatSocket
        Emission Strength
    i.thin_film_thickness : FloatSocket
        Thin Film Thickness
    i.thin_film_ior : FloatSocket
        Thin Film IOR

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        base_color: ColorSocket
        """Base Color"""
        metallic: FloatSocket
        """Metallic"""
        roughness: FloatSocket
        """Roughness"""
        ior: FloatSocket
        """IOR"""
        alpha: FloatSocket
        """Alpha"""
        thin_wall: BooleanSocket
        """Thin Wall"""
        normal: VectorSocket
        """Normal"""
        weight: FloatSocket
        """Weight"""
        diffuse_roughness: FloatSocket
        """Diffuse Roughness"""
        subsurface_weight: FloatSocket
        """Subsurface Weight"""
        subsurface_radius: VectorSocket
        """Subsurface Radius"""
        subsurface_scale: FloatSocket
        """Subsurface Scale"""
        subsurface_ior: FloatSocket
        """Subsurface IOR"""
        subsurface_anisotropy: FloatSocket
        """Subsurface Anisotropy"""
        specular_ior_level: FloatSocket
        """Specular IOR Level"""
        specular_tint: ColorSocket
        """Specular Tint"""
        anisotropic: FloatSocket
        """Anisotropic"""
        anisotropic_rotation: FloatSocket
        """Anisotropic Rotation"""
        tangent: VectorSocket
        """Tangent"""
        transmission_weight: FloatSocket
        """Transmission Weight"""
        coat_weight: FloatSocket
        """Coat Weight"""
        coat_roughness: FloatSocket
        """Coat Roughness"""
        coat_ior: FloatSocket
        """Coat IOR"""
        coat_tint: ColorSocket
        """Coat Tint"""
        coat_normal: VectorSocket
        """Coat Normal"""
        sheen_weight: FloatSocket
        """Sheen Weight"""
        sheen_roughness: FloatSocket
        """Sheen Roughness"""
        sheen_tint: ColorSocket
        """Sheen Tint"""
        emission_color: ColorSocket
        """Emission Color"""
        emission_strength: FloatSocket
        """Emission Strength"""
        thin_film_thickness: FloatSocket
        """Thin Film Thickness"""
        thin_film_ior: FloatSocket
        """Thin Film IOR"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        base_color: InputColor = None,
        metallic: InputFloat = 0.0,
        roughness: InputFloat = 0.5,
        ior: InputFloat = 1.5,
        alpha: InputFloat = 1.0,
        thin_wall: InputBoolean = False,
        normal: InputVector = None,
        weight: InputFloat = 0.0,
        diffuse_roughness: InputFloat = 0.0,
        subsurface_weight: InputFloat = 0.0,
        subsurface_radius: InputVector = None,
        subsurface_scale: InputFloat = 0.005,
        subsurface_ior: InputFloat = 1.4,
        subsurface_anisotropy: InputFloat = 0.0,
        specular_ior_level: InputFloat = 0.5,
        specular_tint: InputColor = None,
        anisotropic: InputFloat = 0.0,
        anisotropic_rotation: InputFloat = 0.0,
        tangent: InputVector = None,
        transmission_weight: InputFloat = 0.0,
        coat_weight: InputFloat = 0.0,
        coat_roughness: InputFloat = 0.03,
        coat_ior: InputFloat = 1.5,
        coat_tint: InputColor = None,
        coat_normal: InputVector = None,
        sheen_weight: InputFloat = 0.0,
        sheen_roughness: InputFloat = 0.5,
        sheen_tint: InputColor = None,
        emission_color: InputColor = None,
        emission_strength: InputFloat = 0.0,
        thin_film_thickness: InputFloat = 0.0,
        thin_film_ior: InputFloat = 1.33,
        *,
        distribution: Literal["GGX", "MULTI_GGX"] = "MULTI_GGX",
        subsurface_method: Literal[
            "BURLEY", "RANDOM_WALK", "RANDOM_WALK_SKIN", "RANDOM_WALK_LEGACY"
        ] = "RANDOM_WALK",
    ):
        super().__init__()
        key_args = {
            "Base Color": base_color,
            "Metallic": metallic,
            "Roughness": roughness,
            "IOR": ior,
            "Alpha": alpha,
            "Thin Wall": thin_wall,
            "Normal": normal,
            "Weight": weight,
            "Diffuse Roughness": diffuse_roughness,
            "Subsurface Weight": subsurface_weight,
            "Subsurface Radius": subsurface_radius,
            "Subsurface Scale": subsurface_scale,
            "Subsurface IOR": subsurface_ior,
            "Subsurface Anisotropy": subsurface_anisotropy,
            "Specular IOR Level": specular_ior_level,
            "Specular Tint": specular_tint,
            "Anisotropic": anisotropic,
            "Anisotropic Rotation": anisotropic_rotation,
            "Tangent": tangent,
            "Transmission Weight": transmission_weight,
            "Coat Weight": coat_weight,
            "Coat Roughness": coat_roughness,
            "Coat IOR": coat_ior,
            "Coat Tint": coat_tint,
            "Coat Normal": coat_normal,
            "Sheen Weight": sheen_weight,
            "Sheen Roughness": sheen_roughness,
            "Sheen Tint": sheen_tint,
            "Emission Color": emission_color,
            "Emission Strength": emission_strength,
            "Thin Film Thickness": thin_film_thickness,
            "Thin Film IOR": thin_film_ior,
        }
        self.distribution = distribution
        self.subsurface_method = subsurface_method
        self._establish_links(**key_args)

    @property
    def distribution(self) -> Literal["GGX", "MULTI_GGX"]:
        return self.node.distribution

    @distribution.setter
    def distribution(self, value: Literal["GGX", "MULTI_GGX"]):
        self.node.distribution = value

    @property
    def subsurface_method(
        self,
    ) -> Literal["BURLEY", "RANDOM_WALK", "RANDOM_WALK_SKIN", "RANDOM_WALK_LEGACY"]:
        return self.node.subsurface_method

    @subsurface_method.setter
    def subsurface_method(
        self,
        value: Literal[
            "BURLEY", "RANDOM_WALK", "RANDOM_WALK_SKIN", "RANDOM_WALK_LEGACY"
        ],
    ):
        self.node.subsurface_method = value


class PrincipledHairBSDF(BaseNode):
    """
    Physically-based, easy-to-use shader for rendering hair and fur

    Parameters
    ----------
    color : InputColor
        Color
    melanin : InputFloat
        Melanin
    melanin_redness : InputFloat
        Melanin Redness
    tint : InputColor
        Tint
    absorption_coefficient : InputVector
        Absorption Coefficient
    aspect_ratio : InputFloat
        Aspect Ratio
    roughness : InputFloat
        Roughness
    radial_roughness : InputFloat
        Radial Roughness
    coat : InputFloat
        Coat
    ior : InputFloat
        IOR
    offset : InputFloat
        Offset
    random_color : InputFloat
        Random Color
    random_roughness : InputFloat
        Random Roughness
    random : InputFloat
        Random
    weight : InputFloat
        Weight
    r_lobe : InputFloat
        Reflection
    tt_lobe : InputFloat
        Transmission
    trt_lobe : InputFloat
        Secondary Reflection

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.melanin : FloatSocket
        Melanin
    i.melanin_redness : FloatSocket
        Melanin Redness
    i.tint : ColorSocket
        Tint
    i.absorption_coefficient : VectorSocket
        Absorption Coefficient
    i.aspect_ratio : FloatSocket
        Aspect Ratio
    i.roughness : FloatSocket
        Roughness
    i.radial_roughness : FloatSocket
        Radial Roughness
    i.coat : FloatSocket
        Coat
    i.ior : FloatSocket
        IOR
    i.offset : FloatSocket
        Offset
    i.random_color : FloatSocket
        Random Color
    i.random_roughness : FloatSocket
        Random Roughness
    i.random : FloatSocket
        Random
    i.weight : FloatSocket
        Weight
    i.r_lobe : FloatSocket
        Reflection
    i.tt_lobe : FloatSocket
        Transmission
    i.trt_lobe : FloatSocket
        Secondary Reflection

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        melanin: FloatSocket
        """Melanin"""
        melanin_redness: FloatSocket
        """Melanin Redness"""
        tint: ColorSocket
        """Tint"""
        absorption_coefficient: VectorSocket
        """Absorption Coefficient"""
        aspect_ratio: FloatSocket
        """Aspect Ratio"""
        roughness: FloatSocket
        """Roughness"""
        radial_roughness: FloatSocket
        """Radial Roughness"""
        coat: FloatSocket
        """Coat"""
        ior: FloatSocket
        """IOR"""
        offset: FloatSocket
        """Offset"""
        random_color: FloatSocket
        """Random Color"""
        random_roughness: FloatSocket
        """Random Roughness"""
        random: FloatSocket
        """Random"""
        weight: FloatSocket
        """Weight"""
        r_lobe: FloatSocket
        """Reflection"""
        tt_lobe: FloatSocket
        """Transmission"""
        trt_lobe: FloatSocket
        """Secondary Reflection"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        melanin: InputFloat = 0.8,
        melanin_redness: InputFloat = 1.0,
        tint: InputColor = None,
        absorption_coefficient: InputVector = None,
        aspect_ratio: InputFloat = 0.85,
        roughness: InputFloat = 0.3,
        radial_roughness: InputFloat = 0.3,
        coat: InputFloat = 0.0,
        ior: InputFloat = 1.55,
        offset: InputFloat = 0.0349,
        random_color: InputFloat = 0.0,
        random_roughness: InputFloat = 0.0,
        random: InputFloat = 0.0,
        weight: InputFloat = 0.0,
        r_lobe: InputFloat = 1.0,
        tt_lobe: InputFloat = 1.0,
        trt_lobe: InputFloat = 1.0,
        *,
        model: Literal["CHIANG", "HUANG"] = "CHIANG",
        parametrization: Literal["ABSORPTION", "MELANIN", "COLOR"] = "COLOR",
    ):
        super().__init__()
        key_args = {
            "Color": color,
            "Melanin": melanin,
            "Melanin Redness": melanin_redness,
            "Tint": tint,
            "Absorption Coefficient": absorption_coefficient,
            "Aspect Ratio": aspect_ratio,
            "Roughness": roughness,
            "Radial Roughness": radial_roughness,
            "Coat": coat,
            "IOR": ior,
            "Offset": offset,
            "Random Color": random_color,
            "Random Roughness": random_roughness,
            "Random": random,
            "Weight": weight,
            "R lobe": r_lobe,
            "TT lobe": tt_lobe,
            "TRT lobe": trt_lobe,
        }
        self.model = model
        self.parametrization = parametrization
        self._establish_links(**key_args)

    @property
    def model(self) -> Literal["CHIANG", "HUANG"]:
        return self.node.model

    @model.setter
    def model(self, value: Literal["CHIANG", "HUANG"]):
        self.node.model = value

    @property
    def parametrization(self) -> Literal["ABSORPTION", "MELANIN", "COLOR"]:
        return self.node.parametrization

    @parametrization.setter
    def parametrization(self, value: Literal["ABSORPTION", "MELANIN", "COLOR"]):
        self.node.parametrization = value


class RayPortalBSDF(BaseNode):
    """
    Continue tracing from an arbitrary new position and in a new direction

    Parameters
    ----------
    color : InputColor
        Color
    position : InputVector
        Position
    direction : InputVector
        Direction
    weight : InputFloat
        Weight

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.position : VectorSocket
        Position
    i.direction : VectorSocket
        Direction
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        position: VectorSocket
        """Position"""
        direction: VectorSocket
        """Direction"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        position: InputVector = None,
        direction: InputVector = None,
        weight: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {
            "Color": color,
            "Position": position,
            "Direction": direction,
            "Weight": weight,
        }

        self._establish_links(**key_args)


class RefractionBSDF(BaseNode):
    """
    Glossy refraction with sharp or microfacet distribution, typically used for materials that transmit light

    Parameters
    ----------
    color : InputColor
        Color
    roughness : InputFloat
        Roughness
    ior : InputFloat
        IOR
    normal : InputVector
        Normal
    weight : InputFloat
        Weight

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.roughness : FloatSocket
        Roughness
    i.ior : FloatSocket
        IOR
    i.normal : VectorSocket
        Normal
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        roughness: FloatSocket
        """Roughness"""
        ior: FloatSocket
        """IOR"""
        normal: VectorSocket
        """Normal"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        roughness: InputFloat = 0.0,
        ior: InputFloat = 1.45,
        normal: InputVector = None,
        weight: InputFloat = 0.0,
        *,
        distribution: Literal["BECKMANN", "GGX"] = "BECKMANN",
    ):
        super().__init__()
        key_args = {
            "Color": color,
            "Roughness": roughness,
            "IOR": ior,
            "Normal": normal,
            "Weight": weight,
        }
        self.distribution = distribution
        self._establish_links(**key_args)

    @property
    def distribution(self) -> Literal["BECKMANN", "GGX"]:
        return self.node.distribution

    @distribution.setter
    def distribution(self, value: Literal["BECKMANN", "GGX"]):
        self.node.distribution = value


class SheenBSDF(BaseNode):
    """
        Reflection for materials such as cloth.
    Typically mixed with other shaders (such as a Diffuse Shader) and is not particularly useful on its own

        Parameters
        ----------
        color : InputColor
            Color
        roughness : InputFloat
            Roughness
        normal : InputVector
            Normal
        weight : InputFloat
            Weight

        Inputs
        ------
        i.color : ColorSocket
            Color
        i.roughness : FloatSocket
            Roughness
        i.normal : VectorSocket
            Normal
        i.weight : FloatSocket
            Weight

        Outputs
        -------
        o.bsdf : ShaderSocket
            BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        roughness: FloatSocket
        """Roughness"""
        normal: VectorSocket
        """Normal"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        roughness: InputFloat = 0.5,
        normal: InputVector = None,
        weight: InputFloat = 0.0,
        *,
        distribution: Literal["ASHIKHMIN", "MICROFIBER"] = "MICROFIBER",
    ):
        super().__init__()
        key_args = {
            "Color": color,
            "Roughness": roughness,
            "Normal": normal,
            "Weight": weight,
        }
        self.distribution = distribution
        self._establish_links(**key_args)

    @property
    def distribution(self) -> Literal["ASHIKHMIN", "MICROFIBER"]:
        return self.node.distribution

    @distribution.setter
    def distribution(self, value: Literal["ASHIKHMIN", "MICROFIBER"]):
        self.node.distribution = value


class SpecularBSDF(BaseNode):
    """
    Similar to the Principled BSDF node but uses the specular workflow instead of metallic, which functions by specifying the facing (along normal) reflection color. Energy is not conserved, so the result may not be physically accurate

    Parameters
    ----------
    base_color : InputColor
        Base Color
    specular : InputColor
        Specular
    roughness : InputFloat
        Roughness
    emissive_color : InputColor
        Emissive Color
    transparency : InputFloat
        Transparency
    normal : InputVector
        Normal
    clear_coat : InputFloat
        Clear Coat
    clear_coat_roughness : InputFloat
        Clear Coat Roughness
    clear_coat_normal : InputVector
        Clear Coat Normal
    weight : InputFloat
        Weight

    Inputs
    ------
    i.base_color : ColorSocket
        Base Color
    i.specular : ColorSocket
        Specular
    i.roughness : FloatSocket
        Roughness
    i.emissive_color : ColorSocket
        Emissive Color
    i.transparency : FloatSocket
        Transparency
    i.normal : VectorSocket
        Normal
    i.clear_coat : FloatSocket
        Clear Coat
    i.clear_coat_roughness : FloatSocket
        Clear Coat Roughness
    i.clear_coat_normal : VectorSocket
        Clear Coat Normal
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        base_color: ColorSocket
        """Base Color"""
        specular: ColorSocket
        """Specular"""
        roughness: FloatSocket
        """Roughness"""
        emissive_color: ColorSocket
        """Emissive Color"""
        transparency: FloatSocket
        """Transparency"""
        normal: VectorSocket
        """Normal"""
        clear_coat: FloatSocket
        """Clear Coat"""
        clear_coat_roughness: FloatSocket
        """Clear Coat Roughness"""
        clear_coat_normal: VectorSocket
        """Clear Coat Normal"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        base_color: InputColor = None,
        specular: InputColor = None,
        roughness: InputFloat = 0.2,
        emissive_color: InputColor = None,
        transparency: InputFloat = 0.0,
        normal: InputVector = None,
        clear_coat: InputFloat = 0.0,
        clear_coat_roughness: InputFloat = 0.0,
        clear_coat_normal: InputVector = None,
        weight: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {
            "Base Color": base_color,
            "Specular": specular,
            "Roughness": roughness,
            "Emissive Color": emissive_color,
            "Transparency": transparency,
            "Normal": normal,
            "Clear Coat": clear_coat,
            "Clear Coat Roughness": clear_coat_roughness,
            "Clear Coat Normal": clear_coat_normal,
            "Weight": weight,
        }

        self._establish_links(**key_args)


class SubsurfaceScattering(BaseNode):
    """
        Subsurface multiple scattering shader to simulate light entering the surface and bouncing internally.
    Typically used for materials such as skin, wax, marble or milk

        Parameters
        ----------
        color : InputColor
            Color
        scale : InputFloat
            Scale
        radius : InputVector
            Radius
        ior : InputFloat
            IOR
        roughness : InputFloat
            Roughness
        anisotropy : InputFloat
            Anisotropy
        normal : InputVector
            Normal
        weight : InputFloat
            Weight

        Inputs
        ------
        i.color : ColorSocket
            Color
        i.scale : FloatSocket
            Scale
        i.radius : VectorSocket
            Radius
        i.ior : FloatSocket
            IOR
        i.roughness : FloatSocket
            Roughness
        i.anisotropy : FloatSocket
            Anisotropy
        i.normal : VectorSocket
            Normal
        i.weight : FloatSocket
            Weight

        Outputs
        -------
        o.bssrdf : ShaderSocket
            BSSRDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        scale: FloatSocket
        """Scale"""
        radius: VectorSocket
        """Radius"""
        ior: FloatSocket
        """IOR"""
        roughness: FloatSocket
        """Roughness"""
        anisotropy: FloatSocket
        """Anisotropy"""
        normal: VectorSocket
        """Normal"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bssrdf: ShaderSocket
        """BSSRDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        scale: InputFloat = 0.005,
        radius: InputVector = None,
        ior: InputFloat = 1.4,
        roughness: InputFloat = 1.0,
        anisotropy: InputFloat = 0.0,
        normal: InputVector = None,
        weight: InputFloat = 0.0,
        *,
        falloff: Literal[
            "BURLEY", "RANDOM_WALK", "RANDOM_WALK_SKIN", "RANDOM_WALK_LEGACY"
        ] = "RANDOM_WALK",
    ):
        super().__init__()
        key_args = {
            "Color": color,
            "Scale": scale,
            "Radius": radius,
            "IOR": ior,
            "Roughness": roughness,
            "Anisotropy": anisotropy,
            "Normal": normal,
            "Weight": weight,
        }
        self.falloff = falloff
        self._establish_links(**key_args)

    @property
    def falloff(
        self,
    ) -> Literal["BURLEY", "RANDOM_WALK", "RANDOM_WALK_SKIN", "RANDOM_WALK_LEGACY"]:
        return self.node.falloff

    @falloff.setter
    def falloff(
        self,
        value: Literal[
            "BURLEY", "RANDOM_WALK", "RANDOM_WALK_SKIN", "RANDOM_WALK_LEGACY"
        ],
    ):
        self.node.falloff = value


class ToonBSDF(BaseNode):
    """
    Diffuse and Glossy shaders with cartoon light effects

    Parameters
    ----------
    color : InputColor
        Color
    size : InputFloat
        Size
    smooth : InputFloat
        Smooth
    normal : InputVector
        Normal
    weight : InputFloat
        Weight

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.size : FloatSocket
        Size
    i.smooth : FloatSocket
        Smooth
    i.normal : VectorSocket
        Normal
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        size: FloatSocket
        """Size"""
        smooth: FloatSocket
        """Smooth"""
        normal: VectorSocket
        """Normal"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        size: InputFloat = 0.5,
        smooth: InputFloat = 0.0,
        normal: InputVector = None,
        weight: InputFloat = 0.0,
        *,
        component: Literal["DIFFUSE", "GLOSSY"] = "DIFFUSE",
    ):
        super().__init__()
        key_args = {
            "Color": color,
            "Size": size,
            "Smooth": smooth,
            "Normal": normal,
            "Weight": weight,
        }
        self.component = component
        self._establish_links(**key_args)

    @property
    def component(self) -> Literal["DIFFUSE", "GLOSSY"]:
        return self.node.component

    @component.setter
    def component(self, value: Literal["DIFFUSE", "GLOSSY"]):
        self.node.component = value


class TranslucentBSDF(BaseNode):
    """
    Lambertian diffuse transmission

    Parameters
    ----------
    color : InputColor
        Color
    normal : InputVector
        Normal
    weight : InputFloat
        Weight

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.normal : VectorSocket
        Normal
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        normal: VectorSocket
        """Normal"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        normal: InputVector = None,
        weight: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {"Color": color, "Normal": normal, "Weight": weight}

        self._establish_links(**key_args)


class TransparentBSDF(BaseNode):
    """
    Transparency without refraction, passing straight through the surface as if there were no geometry

    Parameters
    ----------
    color : InputColor
        Color
    weight : InputFloat
        Weight

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.weight : FloatSocket
        Weight

    Outputs
    -------
    o.bsdf : ShaderSocket
        BSDF
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        weight: FloatSocket
        """Weight"""

    class _Outputs(SocketAccessor):
        bsdf: ShaderSocket
        """BSDF"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        weight: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {"Color": color, "Weight": weight}

        self._establish_links(**key_args)
