# 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,
    InputInteger,
    InputMenu,
    InputVector,
)

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


class AntiAliasing(BaseNode):
    """
    Smooth away jagged edges

    Parameters
    ----------
    image : InputColor
        Image
    threshold : InputFloat
        Threshold
    contrast_limit : InputFloat
        Contrast Limit
    corner_rounding : InputFloat
        Corner Rounding

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.threshold : FloatSocket
        Threshold
    i.contrast_limit : FloatSocket
        Contrast Limit
    i.corner_rounding : FloatSocket
        Corner Rounding

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        threshold: FloatSocket
        """Threshold"""
        contrast_limit: FloatSocket
        """Contrast Limit"""
        corner_rounding: FloatSocket
        """Corner Rounding"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        threshold: InputFloat = 0.2,
        contrast_limit: InputFloat = 2.0,
        corner_rounding: InputFloat = 0.25,
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Threshold": threshold,
            "Contrast Limit": contrast_limit,
            "Corner Rounding": corner_rounding,
        }

        self._establish_links(**key_args)


class BilateralBlur(BaseNode):
    """
    Adaptively blur image, while retaining sharp edges

    Parameters
    ----------
    image : InputColor
        Image
    determinator : InputColor
        Determinator
    size : InputInteger
        Size
    threshold : InputFloat
        Threshold

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.determinator : ColorSocket
        Determinator
    i.size : IntegerSocket
        Size
    i.threshold : FloatSocket
        Threshold

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        determinator: ColorSocket
        """Determinator"""
        size: IntegerSocket
        """Size"""
        threshold: FloatSocket
        """Threshold"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        determinator: InputColor = None,
        size: InputInteger = 0,
        threshold: InputFloat = 0.1,
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Determinator": determinator,
            "Size": size,
            "Threshold": threshold,
        }

        self._establish_links(**key_args)


class Blur(BaseNode):
    """
    Blur an image, using several blur modes

    Parameters
    ----------
    image : InputColor
        Image
    size : InputVector
        Size
    type : InputMenu | Literal['Flat', 'Tent', 'Quadratic', 'Cubic', 'Gaussian', 'Fast Gaussian', 'Catrom', 'Mitch']
        Type
    extend_bounds : InputBoolean
        Extend Bounds
    separable : InputBoolean
        Separable

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.size : VectorSocket
        Size
    i.type : MenuSocket
        Type
    i.extend_bounds : BooleanSocket
        Extend Bounds
    i.separable : BooleanSocket
        Separable

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        size: VectorSocket
        """Size"""
        type: MenuSocket
        """Type"""
        extend_bounds: BooleanSocket
        """Extend Bounds"""
        separable: BooleanSocket
        """Separable"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        size: InputVector = None,
        type: InputMenu
        | Literal[
            "Flat",
            "Tent",
            "Quadratic",
            "Cubic",
            "Gaussian",
            "Fast Gaussian",
            "Catrom",
            "Mitch",
        ] = "Gaussian",
        extend_bounds: InputBoolean = False,
        separable: InputBoolean = True,
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Size": size,
            "Type": type,
            "Extend Bounds": extend_bounds,
            "Separable": separable,
        }

        self._establish_links(**key_args)

    @classmethod
    def flat(
        cls,
        image: InputColor = None,
        size: InputVector = None,
        extend_bounds: InputBoolean = False,
        separable: InputBoolean = True,
    ) -> "Blur":
        """Create Blur node with type 'Flat'."""
        return cls(
            image=image,
            size=size,
            extend_bounds=extend_bounds,
            separable=separable,
            type="Flat",
        )

    @classmethod
    def tent(
        cls,
        image: InputColor = None,
        size: InputVector = None,
        extend_bounds: InputBoolean = False,
        separable: InputBoolean = True,
    ) -> "Blur":
        """Create Blur node with type 'Tent'."""
        return cls(
            image=image,
            size=size,
            extend_bounds=extend_bounds,
            separable=separable,
            type="Tent",
        )

    @classmethod
    def quadratic(
        cls,
        image: InputColor = None,
        size: InputVector = None,
        extend_bounds: InputBoolean = False,
        separable: InputBoolean = True,
    ) -> "Blur":
        """Create Blur node with type 'Quadratic'."""
        return cls(
            image=image,
            size=size,
            extend_bounds=extend_bounds,
            separable=separable,
            type="Quadratic",
        )

    @classmethod
    def cubic(
        cls,
        image: InputColor = None,
        size: InputVector = None,
        extend_bounds: InputBoolean = False,
        separable: InputBoolean = True,
    ) -> "Blur":
        """Create Blur node with type 'Cubic'."""
        return cls(
            image=image,
            size=size,
            extend_bounds=extend_bounds,
            separable=separable,
            type="Cubic",
        )

    @classmethod
    def gaussian(
        cls,
        image: InputColor = None,
        size: InputVector = None,
        extend_bounds: InputBoolean = False,
        separable: InputBoolean = True,
    ) -> "Blur":
        """Create Blur node with type 'Gaussian'."""
        return cls(
            image=image,
            size=size,
            extend_bounds=extend_bounds,
            separable=separable,
            type="Gaussian",
        )

    @classmethod
    def fast_gaussian(
        cls,
        image: InputColor = None,
        size: InputVector = None,
        extend_bounds: InputBoolean = False,
        separable: InputBoolean = True,
    ) -> "Blur":
        """Create Blur node with type 'Fast Gaussian'."""
        return cls(
            image=image,
            size=size,
            extend_bounds=extend_bounds,
            separable=separable,
            type="Fast Gaussian",
        )

    @classmethod
    def catrom(
        cls,
        image: InputColor = None,
        size: InputVector = None,
        extend_bounds: InputBoolean = False,
        separable: InputBoolean = True,
    ) -> "Blur":
        """Create Blur node with type 'Catrom'."""
        return cls(
            image=image,
            size=size,
            extend_bounds=extend_bounds,
            separable=separable,
            type="Catrom",
        )

    @classmethod
    def mitch(
        cls,
        image: InputColor = None,
        size: InputVector = None,
        extend_bounds: InputBoolean = False,
        separable: InputBoolean = True,
    ) -> "Blur":
        """Create Blur node with type 'Mitch'."""
        return cls(
            image=image,
            size=size,
            extend_bounds=extend_bounds,
            separable=separable,
            type="Mitch",
        )


class BokehBlur(BaseNode):
    """
    Generate a bokeh type blur similar to Defocus. Unlike defocus an in-focus region is defined in the compositor

    Parameters
    ----------
    image : InputColor
        Image
    bokeh : InputColor
        Bokeh
    size : InputFloat
        Size
    mask : InputFloat
        Mask
    extend_bounds : InputBoolean
        Extend Bounds

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.bokeh : ColorSocket
        Bokeh
    i.size : FloatSocket
        Size
    i.mask : FloatSocket
        Mask
    i.extend_bounds : BooleanSocket
        Extend Bounds

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        bokeh: ColorSocket
        """Bokeh"""
        size: FloatSocket
        """Size"""
        mask: FloatSocket
        """Mask"""
        extend_bounds: BooleanSocket
        """Extend Bounds"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        bokeh: InputColor = None,
        size: InputFloat = 0.0,
        mask: InputFloat = 1.0,
        extend_bounds: InputBoolean = False,
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Bokeh": bokeh,
            "Size": size,
            "Mask": mask,
            "Extend Bounds": extend_bounds,
        }

        self._establish_links(**key_args)


class Convolve(BaseNode):
    """
    Convolves an image with a kernel

    Parameters
    ----------
    image : InputColor
        Image
    kernel_data_type : InputMenu | Literal['Float', 'Color']
        Kernel Data Type
    float_kernel : InputFloat
        Kernel
    color_kernel : InputColor
        Kernel
    normalize_kernel : InputBoolean
        Normalize Kernel

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.kernel_data_type : MenuSocket
        Kernel Data Type
    i.float_kernel : FloatSocket
        Kernel
    i.color_kernel : ColorSocket
        Kernel
    i.normalize_kernel : BooleanSocket
        Normalize Kernel

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        kernel_data_type: MenuSocket
        """Kernel Data Type"""
        float_kernel: FloatSocket
        """Kernel"""
        color_kernel: ColorSocket
        """Kernel"""
        normalize_kernel: BooleanSocket
        """Normalize Kernel"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        kernel_data_type: InputMenu | Literal["Float", "Color"] = "Float",
        float_kernel: InputFloat = 0.0,
        color_kernel: InputColor = None,
        normalize_kernel: InputBoolean = True,
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Kernel Data Type": kernel_data_type,
            "Float Kernel": float_kernel,
            "Color Kernel": color_kernel,
            "Normalize Kernel": normalize_kernel,
        }

        self._establish_links(**key_args)


class Defocus(BaseNode):
    """
    Apply depth of field in 2D, using a Z depth map or mask

    Parameters
    ----------
    image : InputColor
        Image
    z : InputFloat
        Z

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.z : FloatSocket
        Z

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        z: FloatSocket
        """Z"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        z: InputFloat = 1.0,
        *,
        bokeh: Literal[
            "OCTAGON", "HEPTAGON", "HEXAGON", "PENTAGON", "SQUARE", "TRIANGLE", "CIRCLE"
        ] = "CIRCLE",
        angle: float = 0.0,
        f_stop: float = 0.0,
        blur_max: float = 0.0,
        use_zbuffer: bool = True,
        z_scale: float = 0.0,
    ):
        super().__init__()
        key_args = {"Image": image, "Z": z}
        self.bokeh = bokeh
        self.angle = angle
        self.f_stop = f_stop
        self.blur_max = blur_max
        self.use_zbuffer = use_zbuffer
        self.z_scale = z_scale
        self._establish_links(**key_args)

    @property
    def bokeh(
        self,
    ) -> Literal[
        "OCTAGON", "HEPTAGON", "HEXAGON", "PENTAGON", "SQUARE", "TRIANGLE", "CIRCLE"
    ]:
        return self.node.bokeh

    @bokeh.setter
    def bokeh(
        self,
        value: Literal[
            "OCTAGON", "HEPTAGON", "HEXAGON", "PENTAGON", "SQUARE", "TRIANGLE", "CIRCLE"
        ],
    ):
        self.node.bokeh = value

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

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

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

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

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

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

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

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

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

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


class Denoise(BaseNode):
    """
    Denoise renders from Cycles and other ray tracing renderers

    Parameters
    ----------
    image : InputColor
        Image
    albedo : InputColor
        Albedo
    normal : InputVector
        Normal
    hdr : InputBoolean
        HDR
    prefilter : InputMenu | Literal['None', 'Fast', 'Accurate']
        Prefilter
    quality : InputMenu | Literal['Follow Scene', 'High', 'Balanced', 'Fast']
        Quality

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.albedo : ColorSocket
        Albedo
    i.normal : VectorSocket
        Normal
    i.hdr : BooleanSocket
        HDR
    i.prefilter : MenuSocket
        Prefilter
    i.quality : MenuSocket
        Quality

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        albedo: ColorSocket
        """Albedo"""
        normal: VectorSocket
        """Normal"""
        hdr: BooleanSocket
        """HDR"""
        prefilter: MenuSocket
        """Prefilter"""
        quality: MenuSocket
        """Quality"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        albedo: InputColor = None,
        normal: InputVector = None,
        hdr: InputBoolean = True,
        prefilter: InputMenu | Literal["None", "Fast", "Accurate"] = "Accurate",
        quality: InputMenu
        | Literal["Follow Scene", "High", "Balanced", "Fast"] = "Follow Scene",
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Albedo": albedo,
            "Normal": normal,
            "HDR": hdr,
            "Prefilter": prefilter,
            "Quality": quality,
        }

        self._establish_links(**key_args)


class Despeckle(BaseNode):
    """
    Smooth areas of an image in which noise is noticeable, while leaving complex areas untouched

    Parameters
    ----------
    image : InputColor
        Image
    fac : InputFloat
        Factor
    color_threshold : InputFloat
        Color Threshold
    neighbor_threshold : InputFloat
        Neighbor Threshold

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.fac : FloatSocket
        Factor
    i.color_threshold : FloatSocket
        Color Threshold
    i.neighbor_threshold : FloatSocket
        Neighbor Threshold

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        fac: FloatSocket
        """Factor"""
        color_threshold: FloatSocket
        """Color Threshold"""
        neighbor_threshold: FloatSocket
        """Neighbor Threshold"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        fac: InputFloat = 1.0,
        color_threshold: InputFloat = 0.5,
        neighbor_threshold: InputFloat = 0.5,
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Fac": fac,
            "Color Threshold": color_threshold,
            "Neighbor Threshold": neighbor_threshold,
        }

        self._establish_links(**key_args)


class DilateErode(BaseNode):
    """
    Expand and shrink masks

    Parameters
    ----------
    mask : InputFloat
        Mask
    size : InputInteger
        Size
    type : InputMenu | Literal['Steps', 'Threshold', 'Distance', 'Feather']
        Type
    falloff_size : InputFloat
        Falloff Size
    falloff : InputMenu | Literal['Smooth', 'Sphere', 'Root', 'Inverse Square', 'Sharp', 'Linear']
        Falloff

    Inputs
    ------
    i.mask : FloatSocket
        Mask
    i.size : IntegerSocket
        Size
    i.type : MenuSocket
        Type
    i.falloff_size : FloatSocket
        Falloff Size
    i.falloff : MenuSocket
        Falloff

    Outputs
    -------
    o.mask : FloatSocket
        Mask
    """

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

    class _Inputs(SocketAccessor):
        mask: FloatSocket
        """Mask"""
        size: IntegerSocket
        """Size"""
        type: MenuSocket
        """Type"""
        falloff_size: FloatSocket
        """Falloff Size"""
        falloff: MenuSocket
        """Falloff"""

    class _Outputs(SocketAccessor):
        mask: FloatSocket
        """Mask"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        mask: InputFloat = 0.0,
        size: InputInteger = 0,
        type: InputMenu
        | Literal["Steps", "Threshold", "Distance", "Feather"] = "Steps",
        falloff_size: InputFloat = 0.0,
        falloff: InputMenu
        | Literal[
            "Smooth", "Sphere", "Root", "Inverse Square", "Sharp", "Linear"
        ] = "Smooth",
    ):
        super().__init__()
        key_args = {
            "Mask": mask,
            "Size": size,
            "Type": type,
            "Falloff Size": falloff_size,
            "Falloff": falloff,
        }

        self._establish_links(**key_args)

    @classmethod
    def steps(cls, mask: InputFloat = 0.0, size: InputInteger = 0) -> "DilateErode":
        """Create Dilate/Erode node with type 'Steps'."""
        return cls(mask=mask, size=size, type="Steps")

    @classmethod
    def threshold(
        cls,
        mask: InputFloat = 0.0,
        size: InputInteger = 0,
        falloff_size: InputFloat = 0.0,
    ) -> "DilateErode":
        """Create Dilate/Erode node with type 'Threshold'."""
        return cls(mask=mask, size=size, falloff_size=falloff_size, type="Threshold")

    @classmethod
    def distance(cls, mask: InputFloat = 0.0, size: InputInteger = 0) -> "DilateErode":
        """Create Dilate/Erode node with type 'Distance'."""
        return cls(mask=mask, size=size, type="Distance")

    @classmethod
    def feather(
        cls,
        mask: InputFloat = 0.0,
        size: InputInteger = 0,
        falloff: InputMenu
        | Literal[
            "Smooth", "Sphere", "Root", "Inverse Square", "Sharp", "Linear"
        ] = "Smooth",
    ) -> "DilateErode":
        """Create Dilate/Erode node with type 'Feather'."""
        return cls(mask=mask, size=size, falloff=falloff, type="Feather")


class DirectionalBlur(BaseNode):
    """
    Blur an image along a direction

    Parameters
    ----------
    image : InputColor
        Image
    samples : InputInteger
        Samples
    center : InputVector
        Center
    rotation : InputFloat
        Rotation
    scale : InputFloat
        Scale
    translation_amount : InputFloat
        Amount
    translation_direction : InputFloat
        Direction

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.samples : IntegerSocket
        Samples
    i.center : VectorSocket
        Center
    i.rotation : FloatSocket
        Rotation
    i.scale : FloatSocket
        Scale
    i.translation_amount : FloatSocket
        Amount
    i.translation_direction : FloatSocket
        Direction

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        samples: IntegerSocket
        """Samples"""
        center: VectorSocket
        """Center"""
        rotation: FloatSocket
        """Rotation"""
        scale: FloatSocket
        """Scale"""
        translation_amount: FloatSocket
        """Amount"""
        translation_direction: FloatSocket
        """Direction"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        samples: InputInteger = 1,
        center: InputVector = None,
        rotation: InputFloat = 0.0,
        scale: InputFloat = 1.0,
        translation_amount: InputFloat = 0.0,
        translation_direction: InputFloat = 0.0,
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Samples": samples,
            "Center": center,
            "Rotation": rotation,
            "Scale": scale,
            "Translation Amount": translation_amount,
            "Translation Direction": translation_direction,
        }

        self._establish_links(**key_args)


class Filter(BaseNode):
    """
    Apply common image enhancement filters

    Parameters
    ----------
    image : InputColor
        Image
    fac : InputFloat
        Factor
    type : InputMenu | Literal['Soften', 'Box Sharpen', 'Diamond Sharpen', 'Laplace', 'Sobel', 'Prewitt', 'Kirsch', 'Shadow']
        Type

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.fac : FloatSocket
        Factor
    i.type : MenuSocket
        Type

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        fac: FloatSocket
        """Factor"""
        type: MenuSocket
        """Type"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        fac: InputFloat = 1.0,
        type: InputMenu
        | Literal[
            "Soften",
            "Box Sharpen",
            "Diamond Sharpen",
            "Laplace",
            "Sobel",
            "Prewitt",
            "Kirsch",
            "Shadow",
        ] = "Soften",
    ):
        super().__init__()
        key_args = {"Image": image, "Fac": fac, "Type": type}

        self._establish_links(**key_args)

    @classmethod
    def soften(cls, image: InputColor = None, fac: InputFloat = 1.0) -> "Filter":
        """Create Filter node with type 'Soften'."""
        return cls(image=image, fac=fac, type="Soften")

    @classmethod
    def box_sharpen(cls, image: InputColor = None, fac: InputFloat = 1.0) -> "Filter":
        """Create Filter node with type 'Box Sharpen'."""
        return cls(image=image, fac=fac, type="Box Sharpen")

    @classmethod
    def diamond_sharpen(
        cls, image: InputColor = None, fac: InputFloat = 1.0
    ) -> "Filter":
        """Create Filter node with type 'Diamond Sharpen'."""
        return cls(image=image, fac=fac, type="Diamond Sharpen")

    @classmethod
    def laplace(cls, image: InputColor = None, fac: InputFloat = 1.0) -> "Filter":
        """Create Filter node with type 'Laplace'."""
        return cls(image=image, fac=fac, type="Laplace")

    @classmethod
    def sobel(cls, image: InputColor = None, fac: InputFloat = 1.0) -> "Filter":
        """Create Filter node with type 'Sobel'."""
        return cls(image=image, fac=fac, type="Sobel")

    @classmethod
    def prewitt(cls, image: InputColor = None, fac: InputFloat = 1.0) -> "Filter":
        """Create Filter node with type 'Prewitt'."""
        return cls(image=image, fac=fac, type="Prewitt")

    @classmethod
    def kirsch(cls, image: InputColor = None, fac: InputFloat = 1.0) -> "Filter":
        """Create Filter node with type 'Kirsch'."""
        return cls(image=image, fac=fac, type="Kirsch")

    @classmethod
    def shadow(cls, image: InputColor = None, fac: InputFloat = 1.0) -> "Filter":
        """Create Filter node with type 'Shadow'."""
        return cls(image=image, fac=fac, type="Shadow")


class Glare(BaseNode):
    """
    Add lens flares, fog and glows around bright parts of the image

    Parameters
    ----------
    image : InputColor
        Image
    type : InputMenu | Literal['Bloom', 'Ghosts', 'Streaks', 'Fog Glow', 'Simple Star', 'Sun Beams', 'Kernel']
        Type
    quality : InputMenu | Literal['High', 'Medium', 'Low']
        Quality
    highlights_threshold : InputFloat
        Threshold
    highlights_smoothness : InputFloat
        Smoothness
    clamp_highlights : InputBoolean
        Clamp
    maximum_highlights : InputFloat
        Maximum
    strength : InputFloat
        Strength
    saturation : InputFloat
        Saturation
    tint : InputColor
        Tint
    size : InputFloat
        Size
    streaks : InputInteger
        Streaks
    streaks_angle : InputFloat
        Streaks Angle
    iterations : InputInteger
        Iterations
    fade : InputFloat
        Fade
    color_modulation : InputFloat
        Color Modulation
    diagonal_star : InputBoolean
        Diagonal
    sun_position : InputVector
        Sun Position
    jitter : InputFloat
        Jitter
    kernel_data_type : InputMenu | Literal['Float', 'Color']
        Kernel Data Type
    float_kernel : InputFloat
        Kernel
    color_kernel : InputColor
        Kernel

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.type : MenuSocket
        Type
    i.quality : MenuSocket
        Quality
    i.highlights_threshold : FloatSocket
        Threshold
    i.highlights_smoothness : FloatSocket
        Smoothness
    i.clamp_highlights : BooleanSocket
        Clamp
    i.maximum_highlights : FloatSocket
        Maximum
    i.strength : FloatSocket
        Strength
    i.saturation : FloatSocket
        Saturation
    i.tint : ColorSocket
        Tint
    i.size : FloatSocket
        Size
    i.streaks : IntegerSocket
        Streaks
    i.streaks_angle : FloatSocket
        Streaks Angle
    i.iterations : IntegerSocket
        Iterations
    i.fade : FloatSocket
        Fade
    i.color_modulation : FloatSocket
        Color Modulation
    i.diagonal_star : BooleanSocket
        Diagonal
    i.sun_position : VectorSocket
        Sun Position
    i.jitter : FloatSocket
        Jitter
    i.kernel_data_type : MenuSocket
        Kernel Data Type
    i.float_kernel : FloatSocket
        Kernel
    i.color_kernel : ColorSocket
        Kernel

    Outputs
    -------
    o.image : ColorSocket
        Image
    o.glare : ColorSocket
        Glare
    o.highlights : ColorSocket
        Highlights
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        type: MenuSocket
        """Type"""
        quality: MenuSocket
        """Quality"""
        highlights_threshold: FloatSocket
        """Threshold"""
        highlights_smoothness: FloatSocket
        """Smoothness"""
        clamp_highlights: BooleanSocket
        """Clamp"""
        maximum_highlights: FloatSocket
        """Maximum"""
        strength: FloatSocket
        """Strength"""
        saturation: FloatSocket
        """Saturation"""
        tint: ColorSocket
        """Tint"""
        size: FloatSocket
        """Size"""
        streaks: IntegerSocket
        """Streaks"""
        streaks_angle: FloatSocket
        """Streaks Angle"""
        iterations: IntegerSocket
        """Iterations"""
        fade: FloatSocket
        """Fade"""
        color_modulation: FloatSocket
        """Color Modulation"""
        diagonal_star: BooleanSocket
        """Diagonal"""
        sun_position: VectorSocket
        """Sun Position"""
        jitter: FloatSocket
        """Jitter"""
        kernel_data_type: MenuSocket
        """Kernel Data Type"""
        float_kernel: FloatSocket
        """Kernel"""
        color_kernel: ColorSocket
        """Kernel"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        glare: ColorSocket
        """Glare"""
        highlights: ColorSocket
        """Highlights"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        type: InputMenu
        | Literal[
            "Bloom",
            "Ghosts",
            "Streaks",
            "Fog Glow",
            "Simple Star",
            "Sun Beams",
            "Kernel",
        ] = "Streaks",
        quality: InputMenu | Literal["High", "Medium", "Low"] = "Medium",
        highlights_threshold: InputFloat = 1.0,
        highlights_smoothness: InputFloat = 0.1,
        clamp_highlights: InputBoolean = False,
        maximum_highlights: InputFloat = 10.0,
        strength: InputFloat = 1.0,
        saturation: InputFloat = 1.0,
        tint: InputColor = None,
        size: InputFloat = 0.5,
        streaks: InputInteger = 4,
        streaks_angle: InputFloat = 0.0,
        iterations: InputInteger = 3,
        fade: InputFloat = 0.9,
        color_modulation: InputFloat = 0.25,
        diagonal_star: InputBoolean = True,
        sun_position: InputVector = None,
        jitter: InputFloat = 0.0,
        kernel_data_type: InputMenu | Literal["Float", "Color"] = "Float",
        float_kernel: InputFloat = 0.0,
        color_kernel: InputColor = None,
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Type": type,
            "Quality": quality,
            "Highlights Threshold": highlights_threshold,
            "Highlights Smoothness": highlights_smoothness,
            "Clamp Highlights": clamp_highlights,
            "Maximum Highlights": maximum_highlights,
            "Strength": strength,
            "Saturation": saturation,
            "Tint": tint,
            "Size": size,
            "Streaks": streaks,
            "Streaks Angle": streaks_angle,
            "Iterations": iterations,
            "Fade": fade,
            "Color Modulation": color_modulation,
            "Diagonal Star": diagonal_star,
            "Sun Position": sun_position,
            "Jitter": jitter,
            "Kernel Data Type": kernel_data_type,
            "Float Kernel": float_kernel,
            "Color Kernel": color_kernel,
        }

        self._establish_links(**key_args)

    @classmethod
    def bloom(
        cls,
        image: InputColor = None,
        quality: InputMenu | Literal["High", "Medium", "Low"] = "Medium",
        highlights_threshold: InputFloat = 1.0,
        highlights_smoothness: InputFloat = 0.1,
        clamp_highlights: InputBoolean = False,
        maximum_highlights: InputFloat = 10.0,
        strength: InputFloat = 1.0,
        saturation: InputFloat = 1.0,
        tint: InputColor = None,
        size: InputFloat = 0.5,
    ) -> "Glare":
        """Create Glare node with type 'Bloom'."""
        return cls(
            image=image,
            quality=quality,
            highlights_threshold=highlights_threshold,
            highlights_smoothness=highlights_smoothness,
            clamp_highlights=clamp_highlights,
            maximum_highlights=maximum_highlights,
            strength=strength,
            saturation=saturation,
            tint=tint,
            size=size,
            type="Bloom",
        )

    @classmethod
    def ghosts(
        cls,
        image: InputColor = None,
        quality: InputMenu | Literal["High", "Medium", "Low"] = "Medium",
        highlights_threshold: InputFloat = 1.0,
        highlights_smoothness: InputFloat = 0.1,
        clamp_highlights: InputBoolean = False,
        maximum_highlights: InputFloat = 10.0,
        strength: InputFloat = 1.0,
        saturation: InputFloat = 1.0,
        tint: InputColor = None,
        iterations: InputInteger = 3,
        color_modulation: InputFloat = 0.25,
    ) -> "Glare":
        """Create Glare node with type 'Ghosts'."""
        return cls(
            image=image,
            quality=quality,
            highlights_threshold=highlights_threshold,
            highlights_smoothness=highlights_smoothness,
            clamp_highlights=clamp_highlights,
            maximum_highlights=maximum_highlights,
            strength=strength,
            saturation=saturation,
            tint=tint,
            iterations=iterations,
            color_modulation=color_modulation,
            type="Ghosts",
        )

    @classmethod
    def streaks(
        cls,
        image: InputColor = None,
        quality: InputMenu | Literal["High", "Medium", "Low"] = "Medium",
        highlights_threshold: InputFloat = 1.0,
        highlights_smoothness: InputFloat = 0.1,
        clamp_highlights: InputBoolean = False,
        maximum_highlights: InputFloat = 10.0,
        strength: InputFloat = 1.0,
        saturation: InputFloat = 1.0,
        tint: InputColor = None,
        streaks: InputInteger = 4,
        streaks_angle: InputFloat = 0.0,
        iterations: InputInteger = 3,
        fade: InputFloat = 0.9,
        color_modulation: InputFloat = 0.25,
    ) -> "Glare":
        """Create Glare node with type 'Streaks'."""
        return cls(
            image=image,
            quality=quality,
            highlights_threshold=highlights_threshold,
            highlights_smoothness=highlights_smoothness,
            clamp_highlights=clamp_highlights,
            maximum_highlights=maximum_highlights,
            strength=strength,
            saturation=saturation,
            tint=tint,
            streaks=streaks,
            streaks_angle=streaks_angle,
            iterations=iterations,
            fade=fade,
            color_modulation=color_modulation,
            type="Streaks",
        )

    @classmethod
    def fog_glow(
        cls,
        image: InputColor = None,
        quality: InputMenu | Literal["High", "Medium", "Low"] = "Medium",
        highlights_threshold: InputFloat = 1.0,
        highlights_smoothness: InputFloat = 0.1,
        clamp_highlights: InputBoolean = False,
        maximum_highlights: InputFloat = 10.0,
        strength: InputFloat = 1.0,
        saturation: InputFloat = 1.0,
        tint: InputColor = None,
        size: InputFloat = 0.5,
    ) -> "Glare":
        """Create Glare node with type 'Fog Glow'."""
        return cls(
            image=image,
            quality=quality,
            highlights_threshold=highlights_threshold,
            highlights_smoothness=highlights_smoothness,
            clamp_highlights=clamp_highlights,
            maximum_highlights=maximum_highlights,
            strength=strength,
            saturation=saturation,
            tint=tint,
            size=size,
            type="Fog Glow",
        )

    @classmethod
    def simple_star(
        cls,
        image: InputColor = None,
        quality: InputMenu | Literal["High", "Medium", "Low"] = "Medium",
        highlights_threshold: InputFloat = 1.0,
        highlights_smoothness: InputFloat = 0.1,
        clamp_highlights: InputBoolean = False,
        maximum_highlights: InputFloat = 10.0,
        strength: InputFloat = 1.0,
        saturation: InputFloat = 1.0,
        tint: InputColor = None,
        iterations: InputInteger = 3,
        fade: InputFloat = 0.9,
        diagonal_star: InputBoolean = True,
    ) -> "Glare":
        """Create Glare node with type 'Simple Star'."""
        return cls(
            image=image,
            quality=quality,
            highlights_threshold=highlights_threshold,
            highlights_smoothness=highlights_smoothness,
            clamp_highlights=clamp_highlights,
            maximum_highlights=maximum_highlights,
            strength=strength,
            saturation=saturation,
            tint=tint,
            iterations=iterations,
            fade=fade,
            diagonal_star=diagonal_star,
            type="Simple Star",
        )

    @classmethod
    def sun_beams(
        cls,
        image: InputColor = None,
        quality: InputMenu | Literal["High", "Medium", "Low"] = "Medium",
        highlights_threshold: InputFloat = 1.0,
        highlights_smoothness: InputFloat = 0.1,
        clamp_highlights: InputBoolean = False,
        maximum_highlights: InputFloat = 10.0,
        strength: InputFloat = 1.0,
        saturation: InputFloat = 1.0,
        tint: InputColor = None,
        size: InputFloat = 0.5,
        sun_position: InputVector = None,
        jitter: InputFloat = 0.0,
    ) -> "Glare":
        """Create Glare node with type 'Sun Beams'."""
        return cls(
            image=image,
            quality=quality,
            highlights_threshold=highlights_threshold,
            highlights_smoothness=highlights_smoothness,
            clamp_highlights=clamp_highlights,
            maximum_highlights=maximum_highlights,
            strength=strength,
            saturation=saturation,
            tint=tint,
            size=size,
            sun_position=sun_position,
            jitter=jitter,
            type="Sun Beams",
        )

    @classmethod
    def kernel(
        cls,
        image: InputColor = None,
        quality: InputMenu | Literal["High", "Medium", "Low"] = "Medium",
        highlights_threshold: InputFloat = 1.0,
        highlights_smoothness: InputFloat = 0.1,
        clamp_highlights: InputBoolean = False,
        maximum_highlights: InputFloat = 10.0,
        strength: InputFloat = 1.0,
        saturation: InputFloat = 1.0,
        tint: InputColor = None,
        kernel_data_type: InputMenu | Literal["Float", "Color"] = "Float",
        float_kernel: InputFloat = 0.0,
    ) -> "Glare":
        """Create Glare node with type 'Kernel'."""
        return cls(
            image=image,
            quality=quality,
            highlights_threshold=highlights_threshold,
            highlights_smoothness=highlights_smoothness,
            clamp_highlights=clamp_highlights,
            maximum_highlights=maximum_highlights,
            strength=strength,
            saturation=saturation,
            tint=tint,
            kernel_data_type=kernel_data_type,
            float_kernel=float_kernel,
            type="Kernel",
        )


class Inpaint(BaseNode):
    """
    Extend borders of an image into transparent or masked regions

    Parameters
    ----------
    image : InputColor
        Image
    size : InputInteger
        Size

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.size : IntegerSocket
        Size

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        size: IntegerSocket
        """Size"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        size: InputInteger = 0,
    ):
        super().__init__()
        key_args = {"Image": image, "Size": size}

        self._establish_links(**key_args)


class Kuwahara(BaseNode):
    """
    Apply smoothing filter that preserves edges, for stylized and painterly effects

    Parameters
    ----------
    image : InputColor
        Image
    size : InputFloat
        Size
    type : InputMenu | Literal['Classic', 'Anisotropic']
        Type
    uniformity : InputInteger
        Uniformity
    sharpness : InputFloat
        Sharpness
    eccentricity : InputFloat
        Eccentricity
    high_precision : InputBoolean
        High Precision

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.size : FloatSocket
        Size
    i.type : MenuSocket
        Type
    i.uniformity : IntegerSocket
        Uniformity
    i.sharpness : FloatSocket
        Sharpness
    i.eccentricity : FloatSocket
        Eccentricity
    i.high_precision : BooleanSocket
        High Precision

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        size: FloatSocket
        """Size"""
        type: MenuSocket
        """Type"""
        uniformity: IntegerSocket
        """Uniformity"""
        sharpness: FloatSocket
        """Sharpness"""
        eccentricity: FloatSocket
        """Eccentricity"""
        high_precision: BooleanSocket
        """High Precision"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        size: InputFloat = 6.0,
        type: InputMenu | Literal["Classic", "Anisotropic"] = "Anisotropic",
        uniformity: InputInteger = 4,
        sharpness: InputFloat = 1.0,
        eccentricity: InputFloat = 1.0,
        high_precision: InputBoolean = False,
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Size": size,
            "Type": type,
            "Uniformity": uniformity,
            "Sharpness": sharpness,
            "Eccentricity": eccentricity,
            "High Precision": high_precision,
        }

        self._establish_links(**key_args)

    @classmethod
    def classic(
        cls,
        image: InputColor = None,
        size: InputFloat = 6.0,
        high_precision: InputBoolean = False,
    ) -> "Kuwahara":
        """Create Kuwahara node with type 'Classic'."""
        return cls(
            image=image, size=size, high_precision=high_precision, type="Classic"
        )

    @classmethod
    def anisotropic(
        cls,
        image: InputColor = None,
        size: InputFloat = 6.0,
        uniformity: InputInteger = 4,
        sharpness: InputFloat = 1.0,
        eccentricity: InputFloat = 1.0,
    ) -> "Kuwahara":
        """Create Kuwahara node with type 'Anisotropic'."""
        return cls(
            image=image,
            size=size,
            uniformity=uniformity,
            sharpness=sharpness,
            eccentricity=eccentricity,
            type="Anisotropic",
        )


class MaskToSDF(BaseNode):
    """
    Computes a signed distance field from the given mask

    Parameters
    ----------
    mask : InputBoolean
        Mask

    Inputs
    ------
    i.mask : BooleanSocket
        Mask

    Outputs
    -------
    o.sdf : FloatSocket
        SDF
    o.nearest_pixel : IntegerSocket
        Nearest Pixel
    """

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

    class _Inputs(SocketAccessor):
        mask: BooleanSocket
        """Mask"""

    class _Outputs(SocketAccessor):
        sdf: FloatSocket
        """SDF"""
        nearest_pixel: IntegerSocket
        """Nearest Pixel"""

    if TYPE_CHECKING:

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

    def __init__(self, mask: InputBoolean = False):
        super().__init__()
        key_args = {"Mask": mask}

        self._establish_links(**key_args)


class Pixelate(BaseNode):
    """
    Reduce detail in an image by making individual pixels more prominent, for a blocky or mosaic-like appearance

    Parameters
    ----------
    color : InputColor
        Color
    size : InputInteger
        Size

    Inputs
    ------
    i.color : ColorSocket
        Color
    i.size : IntegerSocket
        Size

    Outputs
    -------
    o.color : ColorSocket
        Color
    """

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

    class _Inputs(SocketAccessor):
        color: ColorSocket
        """Color"""
        size: IntegerSocket
        """Size"""

    class _Outputs(SocketAccessor):
        color: ColorSocket
        """Color"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        color: InputColor = None,
        size: InputInteger = 1,
    ):
        super().__init__()
        key_args = {"Color": color, "Size": size}

        self._establish_links(**key_args)


class VectorBlur(BaseNode):
    """
    Uses the vector speed render pass to blur the image pixels in 2D

    Parameters
    ----------
    image : InputColor
        Image
    speed : InputVector
        Speed
    z : InputFloat
        Depth
    samples : InputInteger
        Samples
    shutter : InputFloat
        Shutter

    Inputs
    ------
    i.image : ColorSocket
        Image
    i.speed : VectorSocket
        Speed
    i.z : FloatSocket
        Depth
    i.samples : IntegerSocket
        Samples
    i.shutter : FloatSocket
        Shutter

    Outputs
    -------
    o.image : ColorSocket
        Image
    """

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

    class _Inputs(SocketAccessor):
        image: ColorSocket
        """Image"""
        speed: VectorSocket
        """Speed"""
        z: FloatSocket
        """Depth"""
        samples: IntegerSocket
        """Samples"""
        shutter: FloatSocket
        """Shutter"""

    class _Outputs(SocketAccessor):
        image: ColorSocket
        """Image"""

    if TYPE_CHECKING:

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

    def __init__(
        self,
        image: InputColor = None,
        speed: InputVector = None,
        z: InputFloat = 0.0,
        samples: InputInteger = 32,
        shutter: InputFloat = 0.5,
    ):
        super().__init__()
        key_args = {
            "Image": image,
            "Speed": speed,
            "Z": z,
            "Samples": samples,
            "Shutter": shutter,
        }

        self._establish_links(**key_args)
