"""
This type stub file was generated by pyright.
"""

import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore

class vtkLightKit(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkLightKit - a simple but quality lighting kit
    
    Superclass: vtkObject
    
    vtkLightKit is designed to make general purpose lighting of vtk
    scenes simple, flexible, and attractive (or at least not horribly
    ugly without significant effort).  Use a LightKit when you want more
    control over your lighting than you can get with the default vtk
    light, which is a headlight located at the camera. (HeadLights are
    very simple to use, but they don't show the shape of objects very
    well, don't give a good sense of "up" and "down", and don't evenly
    light the object.)
    
    A LightKit consists of three lights, a key light, a fill light, and a
    headlight.  The main light is the key light.  It is usually
    positioned so that it appears like an overhead light (like the sun,
    or a ceiling light).  It is generally positioned to shine down on the
    scene from about a 45 degree angle vertically and at least a little
    offset side to side.  The key light usually at least about twice as
    bright as the total of all other lights in the scene to provide good
    modeling of object features.
    
    The other lights in the kit (the fill light, headlight, and a pair of
    back lights) are weaker sources that provide extra illumination to
    fill in the spots that the key light misses.  The fill light is
    usually positioned across from or opposite from the key light (though
    still on the same side of the object as the camera) in order to
    simulate diffuse reflections from other objects in the scene.  The
    headlight, always located at the position of the camera, reduces the
    contrast between areas lit by the key and fill light. The two back
    lights, one on the left of the object as seen from the observer and
    one on the right, fill on the high-contrast areas behind the object. 
    To enforce the relationship between the different lights, the
    intensity of the fill, back and headlights are set as a ratio to the
    key light brightness.  Thus, the brightness of all the lights in the
    scene can be changed by changing the key light intensity.
    
    All lights are directional lights (infinitely far away with no
    falloff).  Lights move with the camera.
    
    For simplicity, the position of lights in the LightKit can only be
    specified using angles: the elevation (latitude) and azimuth
    (longitude) of each light with respect to the camera, expressed in
    degrees.  (Lights always shine on the camera's lookat point.) For
    example, a light at (elevation=0, azimuth=0) is located at the camera
    (a headlight).  A light at (elevation=90, azimuth=0) is above the
    lookat point, shining down.  Negative azimuth values move the lights
    clockwise as seen above, positive values counter-clockwise.  So, a
    light at (elevation=45, azimuth=-20) is above and in front of the
    object and shining slightly from the left side.
    
    vtkLightKit limits the colors that can be assigned to any light to
    those of incandescent sources such as light bulbs and sunlight.  It
    defines a special color spectrum called "warmth" from which light
    colors can be chosen, where 0 is cold blue, 0.5 is neutral white, and
    1 is deep sunset red.  Colors close to 0.5 are "cool whites" and "warm
    whites," respectively.
    
    Since colors far from white on the warmth scale appear less bright,
    key-to-fill and key-to-headlight ratios are skewed by key, fill, and
    headlight colors.  If the flag MaintainLuminance is set, vtkLightKit
    will attempt to compensate for these perceptual differences by
    increasing the brightness of more saturated colors.
    
    A LightKit is not explicitly part of the vtk pipeline.  Rather, it is
    a composite object that controls the behavior of lights using a
    unified user interface.  Every time a parameter of vtkLightKit is
    adjusted, the properties of its lights are modified.
    
    @par Credits: vtkLightKit was originally written and contributed to
    vtk by Michael Halle (mhalle@bwh.harvard.edu) at the Surgical
    Planning Lab, Brigham and Women's Hospital.
    """
    def AddLightsToRenderer(self, vtkRenderer):
        """
        V.AddLightsToRenderer(vtkRenderer)
        C++: void AddLightsToRenderer(vtkRenderer *renderer)
        
        Add lights to, or remove lights from, a renderer. Lights may be
        added to more than one renderer, if desired.
        """
        ...
    
    def DeepCopy(self, vtkLightKit):
        """
        V.DeepCopy(vtkLightKit)
        C++: void DeepCopy(vtkLightKit *kit)
        """
        ...
    
    def GetBackLightAngle(self):
        """
        V.GetBackLightAngle() -> (float, float)
        C++: virtual double *GetBackLightAngle()
        """
        ...
    
    def GetBackLightAzimuth(self):
        """
        V.GetBackLightAzimuth() -> float
        C++: double GetBackLightAzimuth()
        """
        ...
    
    def GetBackLightColor(self):
        """
        V.GetBackLightColor() -> (float, float, float)
        C++: virtual double *GetBackLightColor()
        
        Returns the floating-point RGB values of each of the light's
        color.
        """
        ...
    
    def GetBackLightElevation(self):
        """
        V.GetBackLightElevation() -> float
        C++: double GetBackLightElevation()
        """
        ...
    
    def GetBackLightWarmth(self):
        """
        V.GetBackLightWarmth() -> float
        C++: virtual double GetBackLightWarmth()
        """
        ...
    
    def GetFillLightAngle(self):
        """
        V.GetFillLightAngle() -> (float, float)
        C++: virtual double *GetFillLightAngle()
        """
        ...
    
    def GetFillLightAzimuth(self):
        """
        V.GetFillLightAzimuth() -> float
        C++: double GetFillLightAzimuth()
        """
        ...
    
    def GetFillLightColor(self):
        """
        V.GetFillLightColor() -> (float, float, float)
        C++: virtual double *GetFillLightColor()
        
        Returns the floating-point RGB values of each of the light's
        color.
        """
        ...
    
    def GetFillLightElevation(self):
        """
        V.GetFillLightElevation() -> float
        C++: double GetFillLightElevation()
        """
        ...
    
    def GetFillLightWarmth(self):
        """
        V.GetFillLightWarmth() -> float
        C++: virtual double GetFillLightWarmth()
        """
        ...
    
    def GetHeadLightColor(self):
        """
        V.GetHeadLightColor() -> (float, float, float)
        C++: virtual double *GetHeadLightColor()
        
        Returns the floating-point RGB values of each of the light's
        color.
        """
        ...
    
    def GetHeadLightWarmth(self):
        """
        V.GetHeadLightWarmth() -> float
        C++: virtual double GetHeadLightWarmth()
        """
        ...
    
    def GetKeyLightAngle(self):
        """
        V.GetKeyLightAngle() -> (float, float)
        C++: virtual double *GetKeyLightAngle()
        """
        ...
    
    def GetKeyLightAzimuth(self):
        """
        V.GetKeyLightAzimuth() -> float
        C++: double GetKeyLightAzimuth()
        """
        ...
    
    def GetKeyLightColor(self):
        """
        V.GetKeyLightColor() -> (float, float, float)
        C++: virtual double *GetKeyLightColor()
        
        Returns the floating-point RGB values of each of the light's
        color.
        """
        ...
    
    def GetKeyLightElevation(self):
        """
        V.GetKeyLightElevation() -> float
        C++: double GetKeyLightElevation()
        """
        ...
    
    def GetKeyLightIntensity(self):
        """
        V.GetKeyLightIntensity() -> float
        C++: virtual double GetKeyLightIntensity()
        
        Set/Get the intensity of the key light.  The key light is the
        brightest light in the scene.  The intensities of the other two
        lights are ratios of the key light's intensity.
        """
        ...
    
    def GetKeyLightWarmth(self):
        """
        V.GetKeyLightWarmth() -> float
        C++: virtual double GetKeyLightWarmth()
        
        Set the warmth of each the lights.  Warmth is a parameter that
        varies from 0 to 1, where 0 is "cold" (looks icy or lit by a very
        blue sky), 1 is "warm" (the red of a very red sunset, or the
        embers of a campfire), and 0.5 is a neutral white.  The warmth
        scale is non-linear. Warmth values close to 0.5 are subtly
        "warmer" or "cooler," much like a warmer tungsten incandescent
        bulb, a cooler halogen, or daylight (cooler still).  Moving
        further away from 0.5, colors become more quickly varying towards
        blues and reds.  With regards to aesthetics, extremes of warmth
        should be used sparingly.
        """
        ...
    
    def GetKeyToBackRatio(self):
        """
        V.GetKeyToBackRatio() -> float
        C++: virtual double GetKeyToBackRatio()
        
        Set/Get the key-to-back light ratio.  This ratio controls how
        bright the back lights are compared to the key light: larger
        values correspond to dimmer back lights.  The back lights fill in
        the remaining high-contrast regions behind the object. Values
        between 2 and 10 are good.
        """
        ...
    
    def GetKeyToBackRatioMaxValue(self):
        """
        V.GetKeyToBackRatioMaxValue() -> float
        C++: virtual double GetKeyToBackRatioMaxValue()
        
        Set/Get the key-to-back light ratio.  This ratio controls how
        bright the back lights are compared to the key light: larger
        values correspond to dimmer back lights.  The back lights fill in
        the remaining high-contrast regions behind the object. Values
        between 2 and 10 are good.
        """
        ...
    
    def GetKeyToBackRatioMinValue(self):
        """
        V.GetKeyToBackRatioMinValue() -> float
        C++: virtual double GetKeyToBackRatioMinValue()
        
        Set/Get the key-to-back light ratio.  This ratio controls how
        bright the back lights are compared to the key light: larger
        values correspond to dimmer back lights.  The back lights fill in
        the remaining high-contrast regions behind the object. Values
        between 2 and 10 are good.
        """
        ...
    
    def GetKeyToFillRatio(self):
        """
        V.GetKeyToFillRatio() -> float
        C++: virtual double GetKeyToFillRatio()
        
        Set/Get the key-to-fill ratio.  This ratio controls how bright
        the fill light is compared to the key light: larger values
        correspond to a dimmer fill light.  The purpose of the fill light
        is to light parts of the object not lit by the key light, while
        still maintaining contrast.  This type of lighting may correspond
        to indirect illumination from the key light, bounced off a wall,
        floor, or other object.  The fill light should never be brighter
        than the key light:  a good range for the key-to-fill ratio is
        between 2 and 10.
        """
        ...
    
    def GetKeyToFillRatioMaxValue(self):
        """
        V.GetKeyToFillRatioMaxValue() -> float
        C++: virtual double GetKeyToFillRatioMaxValue()
        
        Set/Get the key-to-fill ratio.  This ratio controls how bright
        the fill light is compared to the key light: larger values
        correspond to a dimmer fill light.  The purpose of the fill light
        is to light parts of the object not lit by the key light, while
        still maintaining contrast.  This type of lighting may correspond
        to indirect illumination from the key light, bounced off a wall,
        floor, or other object.  The fill light should never be brighter
        than the key light:  a good range for the key-to-fill ratio is
        between 2 and 10.
        """
        ...
    
    def GetKeyToFillRatioMinValue(self):
        """
        V.GetKeyToFillRatioMinValue() -> float
        C++: virtual double GetKeyToFillRatioMinValue()
        
        Set/Get the key-to-fill ratio.  This ratio controls how bright
        the fill light is compared to the key light: larger values
        correspond to a dimmer fill light.  The purpose of the fill light
        is to light parts of the object not lit by the key light, while
        still maintaining contrast.  This type of lighting may correspond
        to indirect illumination from the key light, bounced off a wall,
        floor, or other object.  The fill light should never be brighter
        than the key light:  a good range for the key-to-fill ratio is
        between 2 and 10.
        """
        ...
    
    def GetKeyToHeadRatio(self):
        """
        V.GetKeyToHeadRatio() -> float
        C++: virtual double GetKeyToHeadRatio()
        
        Set/Get the key-to-headlight ratio.  Similar to the key-to-fill
        ratio, this ratio controls how bright the headlight light is
        compared to the key light: larger values correspond to a dimmer
        headlight light.  The headlight is special kind of fill light,
        lighting only the parts of the object that the camera can see. As
        such, a headlight tends to reduce the contrast of a scene.  It
        can be used to fill in "shadows" of the object missed by the key
        and fill lights.  The headlight should always be significantly
        dimmer than the key light:  ratios of 2 to 15 are typical.
        """
        ...
    
    def GetKeyToHeadRatioMaxValue(self):
        """
        V.GetKeyToHeadRatioMaxValue() -> float
        C++: virtual double GetKeyToHeadRatioMaxValue()
        
        Set/Get the key-to-headlight ratio.  Similar to the key-to-fill
        ratio, this ratio controls how bright the headlight light is
        compared to the key light: larger values correspond to a dimmer
        headlight light.  The headlight is special kind of fill light,
        lighting only the parts of the object that the camera can see. As
        such, a headlight tends to reduce the contrast of a scene.  It
        can be used to fill in "shadows" of the object missed by the key
        and fill lights.  The headlight should always be significantly
        dimmer than the key light:  ratios of 2 to 15 are typical.
        """
        ...
    
    def GetKeyToHeadRatioMinValue(self):
        """
        V.GetKeyToHeadRatioMinValue() -> float
        C++: virtual double GetKeyToHeadRatioMinValue()
        
        Set/Get the key-to-headlight ratio.  Similar to the key-to-fill
        ratio, this ratio controls how bright the headlight light is
        compared to the key light: larger values correspond to a dimmer
        headlight light.  The headlight is special kind of fill light,
        lighting only the parts of the object that the camera can see. As
        such, a headlight tends to reduce the contrast of a scene.  It
        can be used to fill in "shadows" of the object missed by the key
        and fill lights.  The headlight should always be significantly
        dimmer than the key light:  ratios of 2 to 15 are typical.
        """
        ...
    
    def GetMaintainLuminance(self):
        """
        V.GetMaintainLuminance() -> int
        C++: virtual vtkTypeBool GetMaintainLuminance()
        
        If MaintainLuminance is set, the LightKit will attempt to
        maintain the apparent intensity of lights based on their
        perceptual brightnesses. By default, MaintainLuminance is off.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetShortStringFromSubType(self, p_int):
        """
        V.GetShortStringFromSubType(int) -> string
        C++: static const char *GetShortStringFromSubType(int subtype)
        
        Helper method to go from a enum subtype to a string subtype The
        difference from GetStringFromSubType is that it returns a shorter
        strings (useful for GUI with minimum space)
        """
        ...
    
    def GetStringFromSubType(self, p_int):
        """
        V.GetStringFromSubType(int) -> string
        C++: static const char *GetStringFromSubType(int type)
        
        Helper method to go from a enum subtype to a string subtype
        """
        ...
    
    def GetStringFromType(self, p_int):
        """
        V.GetStringFromType(int) -> string
        C++: static const char *GetStringFromType(int type)
        
        Helper method to go from a enum type to a string type
        """
        ...
    
    def GetSubType(self, LightKitType, p_int):
        """
        V.GetSubType(LightKitType, int) -> LightKitSubType
        C++: static LightKitSubType GetSubType(LightKitType type, int i)
        
        Return the possible subtype from a given type. You have to pass
        in a number i [0,3] no check is done.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def MaintainLuminanceOff(self):
        """
        V.MaintainLuminanceOff()
        C++: virtual void MaintainLuminanceOff()
        
        If MaintainLuminance is set, the LightKit will attempt to
        maintain the apparent intensity of lights based on their
        perceptual brightnesses. By default, MaintainLuminance is off.
        """
        ...
    
    def MaintainLuminanceOn(self):
        """
        V.MaintainLuminanceOn()
        C++: virtual void MaintainLuminanceOn()
        
        If MaintainLuminance is set, the LightKit will attempt to
        maintain the apparent intensity of lights based on their
        perceptual brightnesses. By default, MaintainLuminance is off.
        """
        ...
    
    def Modified(self):
        """
        V.Modified()
        C++: void Modified() override;
        
        Update the modification time for this object. Many filters rely
        on the modification time to determine if they need to recompute
        their data. The modification time is a unique monotonically
        increasing unsigned long integer.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkLightKit
        C++: vtkLightKit *NewInstance()
        """
        ...
    
    def RemoveLightsFromRenderer(self, vtkRenderer):
        """
        V.RemoveLightsFromRenderer(vtkRenderer)
        C++: void RemoveLightsFromRenderer(vtkRenderer *renderer)
        
        Add lights to, or remove lights from, a renderer. Lights may be
        added to more than one renderer, if desired.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkLightKit
        C++: static vtkLightKit *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetBackLightAngle(self, p_float, p_float_1):
        """
        V.SetBackLightAngle(float, float)
        C++: void SetBackLightAngle(double elevation, double azimuth)
        V.SetBackLightAngle([float, float])
        C++: void SetBackLightAngle(double angle[2])
        """
        ...
    
    def SetBackLightAzimuth(self, p_float):
        """
        V.SetBackLightAzimuth(float)
        C++: void SetBackLightAzimuth(double x)
        """
        ...
    
    def SetBackLightElevation(self, p_float):
        """
        V.SetBackLightElevation(float)
        C++: void SetBackLightElevation(double x)
        """
        ...
    
    def SetBackLightWarmth(self, p_float):
        """
        V.SetBackLightWarmth(float)
        C++: virtual void SetBackLightWarmth(double _arg)
        """
        ...
    
    def SetFillLightAngle(self, p_float, p_float_1):
        """
        V.SetFillLightAngle(float, float)
        C++: void SetFillLightAngle(double elevation, double azimuth)
        V.SetFillLightAngle([float, float])
        C++: void SetFillLightAngle(double angle[2])
        """
        ...
    
    def SetFillLightAzimuth(self, p_float):
        """
        V.SetFillLightAzimuth(float)
        C++: void SetFillLightAzimuth(double x)
        """
        ...
    
    def SetFillLightElevation(self, p_float):
        """
        V.SetFillLightElevation(float)
        C++: void SetFillLightElevation(double x)
        """
        ...
    
    def SetFillLightWarmth(self, p_float):
        """
        V.SetFillLightWarmth(float)
        C++: virtual void SetFillLightWarmth(double _arg)
        """
        ...
    
    def SetHeadLightWarmth(self, p_float):
        """
        V.SetHeadLightWarmth(float)
        C++: virtual void SetHeadLightWarmth(double _arg)
        """
        ...
    
    def SetKeyLightAngle(self, p_float, p_float_1):
        """
        V.SetKeyLightAngle(float, float)
        C++: void SetKeyLightAngle(double elevation, double azimuth)
        V.SetKeyLightAngle([float, float])
        C++: void SetKeyLightAngle(double angle[2])
        
        Get/Set the position of the key, fill, and back lights using
        angular methods.  Elevation corresponds to latitude, azimuth to
        longitude.  It is recommended that the key light always be on the
        viewer's side of the object and above the object, while the fill
        light generally lights the part of the object not lit by the fill
        light.  The headlight, which is always located at the viewer, can
        then be used to reduce the contrast in the image. There are a
        pair of back lights.  They are located at the same elevation and
        at opposing azimuths (ie, one to the left, and one to the right).
         They are generally set at the equator (elevation = 0), and at
        approximately 120 degrees (lighting from each side and behind).
        """
        ...
    
    def SetKeyLightAzimuth(self, p_float):
        """
        V.SetKeyLightAzimuth(float)
        C++: void SetKeyLightAzimuth(double x)
        """
        ...
    
    def SetKeyLightElevation(self, p_float):
        """
        V.SetKeyLightElevation(float)
        C++: void SetKeyLightElevation(double x)
        """
        ...
    
    def SetKeyLightIntensity(self, p_float):
        """
        V.SetKeyLightIntensity(float)
        C++: virtual void SetKeyLightIntensity(double _arg)
        
        Set/Get the intensity of the key light.  The key light is the
        brightest light in the scene.  The intensities of the other two
        lights are ratios of the key light's intensity.
        """
        ...
    
    def SetKeyLightWarmth(self, p_float):
        """
        V.SetKeyLightWarmth(float)
        C++: virtual void SetKeyLightWarmth(double _arg)
        
        Set the warmth of each the lights.  Warmth is a parameter that
        varies from 0 to 1, where 0 is "cold" (looks icy or lit by a very
        blue sky), 1 is "warm" (the red of a very red sunset, or the
        embers of a campfire), and 0.5 is a neutral white.  The warmth
        scale is non-linear. Warmth values close to 0.5 are subtly
        "warmer" or "cooler," much like a warmer tungsten incandescent
        bulb, a cooler halogen, or daylight (cooler still).  Moving
        further away from 0.5, colors become more quickly varying towards
        blues and reds.  With regards to aesthetics, extremes of warmth
        should be used sparingly.
        """
        ...
    
    def SetKeyToBackRatio(self, p_float):
        """
        V.SetKeyToBackRatio(float)
        C++: virtual void SetKeyToBackRatio(double _arg)
        
        Set/Get the key-to-back light ratio.  This ratio controls how
        bright the back lights are compared to the key light: larger
        values correspond to dimmer back lights.  The back lights fill in
        the remaining high-contrast regions behind the object. Values
        between 2 and 10 are good.
        """
        ...
    
    def SetKeyToFillRatio(self, p_float):
        """
        V.SetKeyToFillRatio(float)
        C++: virtual void SetKeyToFillRatio(double _arg)
        
        Set/Get the key-to-fill ratio.  This ratio controls how bright
        the fill light is compared to the key light: larger values
        correspond to a dimmer fill light.  The purpose of the fill light
        is to light parts of the object not lit by the key light, while
        still maintaining contrast.  This type of lighting may correspond
        to indirect illumination from the key light, bounced off a wall,
        floor, or other object.  The fill light should never be brighter
        than the key light:  a good range for the key-to-fill ratio is
        between 2 and 10.
        """
        ...
    
    def SetKeyToHeadRatio(self, p_float):
        """
        V.SetKeyToHeadRatio(float)
        C++: virtual void SetKeyToHeadRatio(double _arg)
        
        Set/Get the key-to-headlight ratio.  Similar to the key-to-fill
        ratio, this ratio controls how bright the headlight light is
        compared to the key light: larger values correspond to a dimmer
        headlight light.  The headlight is special kind of fill light,
        lighting only the parts of the object that the camera can see. As
        such, a headlight tends to reduce the contrast of a scene.  It
        can be used to fill in "shadows" of the object missed by the key
        and fill lights.  The headlight should always be significantly
        dimmer than the key light:  ratios of 2 to 15 are typical.
        """
        ...
    
    def SetMaintainLuminance(self, p_int):
        """
        V.SetMaintainLuminance(int)
        C++: virtual void SetMaintainLuminance(vtkTypeBool _arg)
        
        If MaintainLuminance is set, the LightKit will attempt to
        maintain the apparent intensity of lights based on their
        perceptual brightnesses. By default, MaintainLuminance is off.
        """
        ...
    
    def Update(self):
        """
        V.Update()
        C++: void Update()
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    Azimuth = ...
    Elevation = ...
    Intensity = ...
    KBRatio = ...
    KFRatio = ...
    KHRatio = ...
    LightKitSubType = ...
    LightKitType = ...
    TBackLight = ...
    TFillLight = ...
    THeadLight = ...
    TKeyLight = ...
    Warmth = ...
    __dict__ = ...
    __vtkname__ = ...


