"""


Types (bpy.types)
*****************

"""

import typing

import mathutils

class bpy_struct:

  """

  built-in base class for all classes in bpy.types.

  Note: Note that :class:`bpy.types.bpy_struct` is not actually available from within Blender,
it only exists for the purpose of documentation.

  """

  def as_pointer(self) -> int:

    """

    Returns the memory address which holds a pointer to Blender's internal data

    Note: This is intended only for advanced script writers who need to
pass blender data to their own C/Python modules.

    """

    ...

  def driver_add(self, path: str, index: int = -1) -> typing.Union[FCurve, typing.List[typing.Any]]:

    """

    Adds driver(s) to the given property

    """

    ...

  def driver_remove(self, path: str, index: int = -1) -> bool:

    """

    Remove driver(s) from the given property

    """

    ...

  def get(self, key: str, default: typing.Any = None) -> None:

    """

    Returns the value of the custom property assigned to key or default
when not found (matches Python's dictionary function of the same name).

    Note: Only the :class:`bpy.types.ID`, :class:`bpy.types.Bone` and
:class:`bpy.types.PoseBone` classes support custom properties.

    """

    ...

  def is_property_hidden(self, property: typing.Any) -> bool:

    """

    Check if a property is hidden.

    """

    ...

  def is_property_overridable_library(self, property: typing.Any) -> bool:

    """

    Check if a property is overridable.

    """

    ...

  def is_property_readonly(self, property: typing.Any) -> bool:

    """

    Check if a property is readonly.

    """

    ...

  def is_property_set(self, property: typing.Any, ghost: bool = True) -> bool:

    """

    Check if a property is set, use for testing operator properties.

    """

    ...

  def items(self) -> typing.List[typing.Any]:

    """

    Returns the items of this objects custom properties (matches Python's
dictionary function of the same name).

    Note: Only the :class:`bpy.types.ID`, :class:`bpy.types.Bone` and
:class:`bpy.types.PoseBone` classes support custom properties.

    """

    ...

  def keyframe_delete(self, data_path: str, index: int = -1, frame: float = bpy.context.scene.frame_current, group: str = '') -> bool:

    """

    Remove a keyframe from this properties fcurve.

    """

    ...

  def keyframe_insert(self, data_path: str, index: int = -1, frame: float = bpy.context.scene.frame_current, group: str = '', options: typing.Any = set()) -> bool:

    """

    Insert a keyframe on the property given, adding fcurves and animation data when necessary.

    This is the most simple example of inserting a keyframe from python.

    .. code::


      import bpy

      obj = bpy.context.object

      # set the keyframe at frame 1
      obj.location = (3.0, 4.0, 10.0)
      obj.keyframe_insert(data_path="location", frame=1)

    Note that when keying data paths which contain nested properties this must be
done from the :class:`ID` subclass, in this case the :class:`Armature` rather
than the bone.

    .. code::


      import bpy
      from bpy.props import (
          FloatProperty,
          PointerProperty,
      )


      # Define a nested property.
      class MyPropGroup(bpy.types.PropertyGroup):
          nested: FloatProperty(name="Nested", default=0.0)


      # Register it so its available for all bones.
      bpy.utils.register_class(MyPropGroup)
      bpy.types.Bone.my_prop = PointerProperty(
          type=MyPropGroup,
          name="MyProp",
      )

      # Get a bone.
      obj = bpy.data.objects["Armature"]
      arm = obj.data

      # Set the keyframe at frame 1.
      arm.bones["Bone"].my_prop.nested = 10
      arm.keyframe_insert(
          data_path='bones["Bone"].my_prop.nested',
          frame=1,
          group="Nested Group",
      )

    """

    ...

  def keys(self) -> typing.List[str]:

    """

    Returns the keys of this objects custom properties (matches Python's
dictionary function of the same name).

    Note: Only the :class:`bpy.types.ID`, :class:`bpy.types.Bone` and
:class:`bpy.types.PoseBone` classes support custom properties.

    """

    ...

  def path_from_id(self, property: str = '') -> str:

    """

    Returns the data path from the ID to this object (string).

    """

    ...

  def path_resolve(self, path: str, coerce: bool = True) -> None:

    """

    Returns the property from the path, raise an exception when not found.

    """

    ...

  def pop(self, key: str, default: typing.Any = None) -> None:

    """

    Remove and return the value of the custom property assigned to key or default
when not found (matches Python's dictionary function of the same name).

    Note: Only the :class:`bpy.types.ID`, :class:`bpy.types.Bone` and
:class:`bpy.types.PoseBone` classes support custom properties.

    """

    ...

  def property_overridable_library_set(self, property: typing.Any, overridable: typing.Any) -> bool:

    """

    Define a property as overridable or not (only for custom properties!).

    """

    ...

  def property_unset(self, property: typing.Any) -> None:

    """

    Unset a property, will use default value afterward.

    """

    ...

  def type_recast(self) -> typing.Any:

    """

    Return a new instance, this is needed because types
such as textures can be changed at runtime.

    """

    ...

  def values(self) -> typing.List[typing.Any]:

    """

    Returns the values of this objects custom properties (matches Python's
dictionary function of the same name).

    Note: Only the :class:`bpy.types.ID`, :class:`bpy.types.Bone` and
:class:`bpy.types.PoseBone` classes support custom properties.

    """

    ...

  id_data: typing.Any = ...

  """

  The :class:`bpy.types.ID` object this datablock is from or None, (not available for all data types)

  """

class bpy_prop_collection:

  """

  built-in class used for all collections.

  Note: Note that :class:`bpy.types.bpy_prop_collection` is not actually available from within Blender,
it only exists for the purpose of documentation.

  """

  def find(self, key: str) -> int:

    """

    Returns the index of a key in a collection or -1 when not found
(matches Python's string find function of the same name).

    """

    ...

  def foreach_get(self, attr: typing.Any, seq: typing.Any) -> None:

    """

    This is a function to give fast access to attributes within a collection.

    Only works for 'basic type' properties (bool, int and float)!
Multi-dimensional arrays (like array of vectors) will be flattened into seq.

    .. code::


      collection.foreach_get(attr, some_seq)

      # Python equivalent
      for i in range(len(seq)):
          some_seq[i] = getattr(collection[i], attr)

    """

    ...

  def foreach_set(self, attr: typing.Any, seq: typing.Any) -> None:

    """

    This is a function to give fast access to attributes within a collection.

    Only works for 'basic type' properties (bool, int and float)!
seq must be uni-dimensional, multi-dimensional arrays (like array of vectors) will be re-created from it.

    .. code::


      collection.foreach_set(attr, some_seq)

      # Python equivalent
      for i in range(len(some_seq)):
          setattr(collection[i], attr, some_seq[i])

    """

    ...

  def get(self, key: str, default: typing.Any = None) -> None:

    """

    Returns the value of the item assigned to key or default when not found
(matches Python's dictionary function of the same name).

    """

    ...

  def items(self) -> typing.List[typing.Tuple[typing.Any, ...]]:

    """

    Return the identifiers of collection members
(matching Python's dict.items() functionality).

    """

    ...

  def keys(self) -> typing.List[str]:

    """

    Return the identifiers of collection members
(matching Python's dict.keys() functionality).

    """

    ...

  def values(self) -> typing.List[typing.Any]:

    """

    Return the values of collection
(matching Python's dict.values() functionality).

    """

    ...

class ActionFCurves(bpy_struct):

  """

  Collection of action F-Curves

  """

  def new(self, data_path: str, index: int = 0, action_group: str = '') -> FCurve:

    """

    Add an F-Curve to the action

    """

    ...

  def find(self, data_path: str, index: int = 0) -> FCurve:

    """

    Find an F-Curve. Note that this function performs a linear scan of all F-Curves in the action.

    """

    ...

  def remove(self, fcurve: FCurve) -> None:

    """

    Remove action group

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ActionGroup(bpy_struct):

  """

  Groups of F-Curves

  """

  channels: typing.Union[typing.Sequence[FCurve], typing.Mapping[str, FCurve], bpy_prop_collection] = ...

  """

  F-Curves in this group

  """

  color_set: str = ...

  """

  Custom color set to use

  """

  colors: ThemeBoneColorSet = ...

  """

  Copy of the colors associated with the group's color set

  """

  is_custom_color_set: bool = ...

  """

  Color set is user-defined instead of a fixed theme color set

  """

  lock: bool = ...

  """

  Action group is locked

  """

  name: str = ...

  select: bool = ...

  """

  Action group is selected

  """

  show_expanded: bool = ...

  """

  Action group is expanded except in graph editor

  """

  show_expanded_graph: bool = ...

  """

  Action group is expanded in graph editor

  """

  use_pin: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ActionGroups(bpy_struct):

  """

  Collection of action groups

  """

  def new(self, name: str) -> ActionGroup:

    """

    Create a new action group and add it to the action

    """

    ...

  def remove(self, action_group: ActionGroup) -> None:

    """

    Remove action group

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ActionPoseMarkers(bpy_struct):

  """

  Collection of timeline markers

  """

  active: TimelineMarker = ...

  """

  Active pose marker for this action

  """

  active_index: int = ...

  """

  Index of active pose marker

  """

  def new(self, name: str) -> TimelineMarker:

    """

    Add a pose marker to the action

    """

    ...

  def remove(self, marker: TimelineMarker) -> None:

    """

    Remove a timeline marker

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Addon(bpy_struct):

  """

  Python add-ons to be loaded automatically

  """

  module: str = ...

  """

  Module name

  """

  preferences: AddonPreferences = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AddonPreferences(bpy_struct):

  bl_idname: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Addons(bpy_struct):

  """

  Collection of add-ons

  """

  @classmethod

  def new(cls) -> Addon:

    """

    Add a new add-on

    """

    ...

  @classmethod

  def remove(cls, addon: Addon) -> None:

    """

    Remove add-on

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AlembicObjectPath(bpy_struct):

  """

  Path of an object inside of an Alembic archive

  """

  path: str = ...

  """

  Object path

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AlembicObjectPaths(bpy_struct):

  """

  Collection of object paths

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AnimData(bpy_struct):

  """

  Animation data for data-block

  """

  action: Action = ...

  """

  Active Action for this data-block

  """

  action_blend_type: str = ...

  """

  Method used for combining Active Action's result with result of NLA stack

  * ``REPLACE``
Replace, The strip values replace the accumulated results by amount specified by influence.

  * ``COMBINE``
Combine, The strip values are combined with accumulated results by appropriately using addition, multiplication, or quaternion math, based on channel type.

  * ``ADD``
Add, Weighted result of strip is added to the accumulated results.

  * ``SUBTRACT``
Subtract, Weighted result of strip is removed from the accumulated results.

  * ``MULTIPLY``
Multiply, Weighted result of strip is multiplied with the accumulated results.

  """

  action_extrapolation: str = ...

  """

  Action to take for gaps past the Active Action's range (when evaluating with NLA)

  * ``NOTHING``
Nothing, Strip has no influence past its extents.

  * ``HOLD``
Hold, Hold the first frame if no previous strips in track, and always hold last frame.

  * ``HOLD_FORWARD``
Hold Forward, Only hold last frame.

  """

  action_influence: float = ...

  """

  Amount the Active Action contributes to the result of the NLA stack

  """

  drivers: typing.Union[AnimDataDrivers, typing.Sequence[FCurve], typing.Mapping[str, FCurve], bpy_prop_collection] = ...

  """

  The Drivers/Expressions for this data-block

  """

  nla_tracks: typing.Union[NlaTracks, typing.Sequence[NlaTrack], typing.Mapping[str, NlaTrack], bpy_prop_collection] = ...

  """

  NLA Tracks (i.e. Animation Layers)

  """

  use_nla: bool = ...

  """

  NLA stack is evaluated when evaluating this block

  """

  use_pin: bool = ...

  use_tweak_mode: bool = ...

  """

  Whether to enable or disable tweak mode in NLA

  """

  def nla_tweak_strip_time_to_scene(self, frame: float, invert: bool = False) -> float:

    """

    Convert a time value from the local time of the tweaked strip to scene time, exactly as done by built-in key editing tools. Returns the input time unchanged if not tweaking.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AnimDataDrivers(bpy_struct):

  """

  Collection of Driver F-Curves

  """

  def new(self, data_path: str, index: int = 0) -> FCurve:

    """

    new

    """

    ...

  def remove(self, driver: FCurve) -> None:

    """

    remove

    """

    ...

  def from_existing(self, src_driver: FCurve = None) -> FCurve:

    """

    Add a new driver given an existing one

    """

    ...

  def find(self, data_path: str, index: int = 0) -> FCurve:

    """

    Find a driver F-Curve. Note that this function performs a linear scan of all driver F-Curves.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AnimViz(bpy_struct):

  """

  Settings for the visualization of motion

  """

  motion_path: AnimVizMotionPaths = ...

  """

  Motion Path settings for visualization

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AnimVizMotionPaths(bpy_struct):

  """

  Motion Path settings for animation visualization

  """

  bake_location: str = ...

  """

  When calculating Bone Paths, use Head or Tips

  * ``HEADS``
Heads, Calculate bone paths from heads.

  * ``TAILS``
Tails, Calculate bone paths from tails.

  """

  frame_after: int = ...

  """

  Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method)

  """

  frame_before: int = ...

  """

  Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method)

  """

  frame_end: int = ...

  """

  End frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method)

  """

  frame_start: int = ...

  """

  Starting frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method)

  """

  frame_step: int = ...

  """

  Number of frames between paths shown (not for 'On Keyframes' Onion-skinning method)

  """

  has_motion_paths: bool = ...

  """

  Are there any bone paths that will need updating (read-only)

  """

  show_frame_numbers: bool = ...

  """

  Show frame numbers on Motion Paths

  """

  show_keyframe_action_all: bool = ...

  """

  For bone motion paths, search whole Action for keyframes instead of in group with matching name only (is slower)

  """

  show_keyframe_highlight: bool = ...

  """

  Emphasize position of keyframes on Motion Paths

  """

  show_keyframe_numbers: bool = ...

  """

  Show frame numbers of Keyframes on Motion Paths

  """

  type: str = ...

  """

  Type of range to show for Motion Paths

  * ``CURRENT_FRAME``
Around Frame, Display Paths of poses within a fixed number of frames around the current frame.

  * ``RANGE``
In Range, Display Paths of poses within specified range.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AnyType(bpy_struct):

  """

  RNA type used for pointers to any possible data

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Area(bpy_struct):

  """

  Area in a subdivided screen, containing an editor

  """

  height: int = ...

  """

  Area height

  """

  regions: typing.Union[typing.Sequence[Region], typing.Mapping[str, Region], bpy_prop_collection] = ...

  """

  Regions this area is subdivided in

  """

  show_menus: bool = ...

  """

  Show menus in the header

  """

  spaces: typing.Union[AreaSpaces, typing.Sequence[Space], typing.Mapping[str, Space], bpy_prop_collection] = ...

  """

  Spaces contained in this area, the first being the active space (NOTE: Useful for example to restore a previously used 3D view space in a certain area to get the old view orientation)

  """

  type: str = ...

  """

  Current editor type for this area

  * ``EMPTY``
Empty.

  * ``VIEW_3D``
3D Viewport, Manipulate objects in a 3D environment.

  * ``IMAGE_EDITOR``
UV/Image Editor, View and edit images and UV Maps.

  * ``NODE_EDITOR``
Node Editor, Editor for node-based shading and compositing tools.

  * ``SEQUENCE_EDITOR``
Video Sequencer, Video editing tools.

  * ``CLIP_EDITOR``
Movie Clip Editor, Motion tracking tools.

  * ``DOPESHEET_EDITOR``
Dope Sheet, Adjust timing of keyframes.

  * ``GRAPH_EDITOR``
Graph Editor, Edit drivers and keyframe interpolation.

  * ``NLA_EDITOR``
Nonlinear Animation, Combine and layer Actions.

  * ``TEXT_EDITOR``
Text Editor, Edit scripts and in-file documentation.

  * ``CONSOLE``
Python Console, Interactive programmatic console for advanced editing and script development.

  * ``INFO``
Info, Log of operations, warnings and error messages.

  * ``TOPBAR``
Top Bar, Global bar at the top of the screen for global per-window settings.

  * ``STATUSBAR``
Status Bar, Global bar at the bottom of the screen for general status information.

  * ``OUTLINER``
Outliner, Overview of scene graph and all available data-blocks.

  * ``PROPERTIES``
Properties, Edit properties of active object and related data-blocks.

  * ``FILE_BROWSER``
File Browser, Browse for files and assets.

  * ``PREFERENCES``
Preferences, Edit persistent configuration settings.

  """

  ui_type: str = ...

  """

  Current editor type for this area

  """

  width: int = ...

  """

  Area width

  """

  x: int = ...

  """

  The window relative vertical location of the area

  """

  y: int = ...

  """

  The window relative horizontal location of the area

  """

  def tag_redraw(self) -> None:

    """

    tag_redraw

    """

    ...

  def header_text_set(self, text: str) -> None:

    """

    Set the header status text

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AreaSpaces(bpy_struct):

  """

  Collection of spaces

  """

  active: Space = ...

  """

  Space currently being displayed in this area

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ArmatureBones(bpy_struct):

  """

  Collection of armature bones

  """

  active: Bone = ...

  """

  Armature's active bone

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ArmatureConstraintTargets(bpy_struct):

  """

  Collection of target bones and weights

  """

  def new(self) -> ConstraintTargetBone:

    """

    Add a new target to the constraint

    """

    ...

  def remove(self, target: ConstraintTargetBone) -> None:

    """

    Delete target from the constraint

    """

    ...

  def clear(self) -> None:

    """

    Delete all targets from object

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ArmatureEditBones(bpy_struct):

  """

  Collection of armature edit bones

  """

  active: EditBone = ...

  """

  Armatures active edit bone

  """

  def new(self, name: str) -> EditBone:

    """

    Add a new bone

    """

    ...

  def remove(self, bone: EditBone) -> None:

    """

    Remove an existing bone from the armature

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Attribute(bpy_struct):

  """

  Geometry attribute

  """

  data_type: str = ...

  """

  Type of data stored in attribute

  * ``FLOAT``
Float, Floating point value.

  * ``INT``
Integer, 32 bit integer.

  * ``FLOAT_VECTOR``
Vector, 3D vector with floating point values.

  * ``FLOAT_COLOR``
Float Color, RGBA color with floating point precisions.

  * ``BYTE_COLOR``
Byte Color, RGBA color with 8-bit precision.

  * ``STRING``
String, Text string.

  """

  domain: str = ...

  """

  Domain of the Attribute

  * ``VERTEX``
Vertex, Attribute on mesh vertex.

  * ``EDGE``
Edge, Attribute on mesh edge.

  * ``CORNER``
Corner, Attribute on mesh polygon corner.

  * ``POLYGON``
Polygon, Attribute on mesh polygons.

  * ``POINT``
Point, Attribute on point.

  * ``CURVE``
Curve, Attribute on hair curve.

  """

  name: str = ...

  """

  Name of the Attribute

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AttributeGroup(bpy_struct):

  """

  Group of geometry attributes

  """

  active: Attribute = ...

  """

  Active attribute

  """

  active_index: int = ...

  def new(self, name: str, type: str, domain: str) -> Attribute:

    """

    Add an attribute

    """

    ...

  def remove(self, attribute: Attribute) -> None:

    """

    Remove an attribute

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BakeSettings(bpy_struct):

  """

  Bake data for a Scene data-block

  """

  cage_extrusion: float = ...

  """

  Inflate the active object by the specified distance for baking. This helps matching to points nearer to the outside of the selected object meshes

  """

  cage_object: Object = ...

  """

  Object to use as cage instead of calculating the cage from the active object with cage extrusion

  """

  filepath: str = ...

  """

  Image filepath to use when saving externally

  """

  height: int = ...

  """

  Vertical dimension of the baking map

  """

  image_settings: ImageFormatSettings = ...

  margin: int = ...

  """

  Extends the baked result as a post process filter

  """

  max_ray_distance: float = ...

  """

  The maximum ray distance for matching points between the active and selected objects. If zero, there is no limit

  """

  normal_b: str = ...

  """

  Axis to bake in blue channel

  """

  normal_g: str = ...

  """

  Axis to bake in green channel

  """

  normal_r: str = ...

  """

  Axis to bake in red channel

  """

  normal_space: str = ...

  """

  Choose normal space for baking

  * ``OBJECT``
Object, Bake the normals in object space.

  * ``TANGENT``
Tangent, Bake the normals in tangent space.

  """

  pass_filter: typing.Set[str] = ...

  """

  Passes to include in the active baking pass

  """

  save_mode: str = ...

  """

  Choose how to save the baking map

  * ``INTERNAL``
Internal, Save the baking map in an internal image data-block.

  * ``EXTERNAL``
External, Save the baking map in an external file.

  """

  use_automatic_name: bool = ...

  """

  Automatically name the output file with the pass type (external only)

  """

  use_cage: bool = ...

  """

  Cast rays to active object from a cage

  """

  use_clear: bool = ...

  """

  Clear Images before baking (internal only)

  """

  use_pass_ambient_occlusion: bool = ...

  """

  Add ambient occlusion contribution

  """

  use_pass_color: bool = ...

  """

  Color the pass

  """

  use_pass_diffuse: bool = ...

  """

  Add diffuse contribution

  """

  use_pass_direct: bool = ...

  """

  Add direct lighting contribution

  """

  use_pass_emit: bool = ...

  """

  Add emission contribution

  """

  use_pass_glossy: bool = ...

  """

  Add glossy contribution

  """

  use_pass_indirect: bool = ...

  """

  Add indirect lighting contribution

  """

  use_pass_transmission: bool = ...

  """

  Add transmission contribution

  """

  use_selected_to_active: bool = ...

  """

  Bake shading on the surface of selected objects to the active object

  """

  use_split_materials: bool = ...

  """

  Split external images per material (external only)

  """

  width: int = ...

  """

  Horizontal dimension of the baking map

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BezierSplinePoint(bpy_struct):

  """

  Bezier curve point with two handles

  """

  co: typing.Tuple[float, float, float] = ...

  """

  Coordinates of the control point

  """

  handle_left: typing.Tuple[float, float, float] = ...

  """

  Coordinates of the first handle

  """

  handle_left_type: str = ...

  """

  Handle types

  """

  handle_right: typing.Tuple[float, float, float] = ...

  """

  Coordinates of the second handle

  """

  handle_right_type: str = ...

  """

  Handle types

  """

  hide: bool = ...

  """

  Visibility status

  """

  radius: float = ...

  """

  Radius for beveling

  """

  select_control_point: bool = ...

  """

  Control point selection status

  """

  select_left_handle: bool = ...

  """

  Handle 1 selection status

  """

  select_right_handle: bool = ...

  """

  Handle 2 selection status

  """

  tilt: float = ...

  """

  Tilt in 3D View

  """

  weight_softbody: float = ...

  """

  Softbody goal weight

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendData(bpy_struct):

  """

  Main data structure representing a .blend file and all its data-blocks

  """

  actions: typing.Union[BlendDataActions, typing.Sequence[Action], typing.Mapping[str, Action], bpy_prop_collection] = ...

  """

  Action data-blocks

  """

  armatures: typing.Union[BlendDataArmatures, typing.Sequence[Armature], typing.Mapping[str, Armature], bpy_prop_collection] = ...

  """

  Armature data-blocks

  """

  brushes: typing.Union[BlendDataBrushes, typing.Sequence[Brush], typing.Mapping[str, Brush], bpy_prop_collection] = ...

  """

  Brush data-blocks

  """

  cache_files: typing.Union[BlendDataCacheFiles, typing.Sequence[CacheFile], typing.Mapping[str, CacheFile], bpy_prop_collection] = ...

  """

  Cache Files data-blocks

  """

  cameras: typing.Union[BlendDataCameras, typing.Sequence[Camera], typing.Mapping[str, Camera], bpy_prop_collection] = ...

  """

  Camera data-blocks

  """

  collections: typing.Union[BlendDataCollections, typing.Sequence[Collection], typing.Mapping[str, Collection], bpy_prop_collection] = ...

  """

  Collection data-blocks

  """

  curves: typing.Union[BlendDataCurves, typing.Sequence[Curve], typing.Mapping[str, Curve], bpy_prop_collection] = ...

  """

  Curve data-blocks

  """

  filepath: str = ...

  """

  Path to the .blend file

  """

  fonts: typing.Union[BlendDataFonts, typing.Sequence[VectorFont], typing.Mapping[str, VectorFont], bpy_prop_collection] = ...

  """

  Vector font data-blocks

  """

  grease_pencils: typing.Union[BlendDataGreasePencils, typing.Sequence[GreasePencil], typing.Mapping[str, GreasePencil], bpy_prop_collection] = ...

  """

  Grease Pencil data-blocks

  """

  images: typing.Union[BlendDataImages, typing.Sequence[Image], typing.Mapping[str, Image], bpy_prop_collection] = ...

  """

  Image data-blocks

  """

  is_dirty: bool = ...

  """

  Have recent edits been saved to disk

  """

  is_saved: bool = ...

  """

  Has the current session been saved to disk as a .blend file

  """

  lattices: typing.Union[BlendDataLattices, typing.Sequence[Lattice], typing.Mapping[str, Lattice], bpy_prop_collection] = ...

  """

  Lattice data-blocks

  """

  libraries: typing.Union[BlendDataLibraries, typing.Sequence[Library], typing.Mapping[str, Library], bpy_prop_collection] = ...

  """

  Library data-blocks

  """

  lightprobes: typing.Union[BlendDataProbes, typing.Sequence[LightProbe], typing.Mapping[str, LightProbe], bpy_prop_collection] = ...

  """

  LightProbe data-blocks

  """

  lights: typing.Union[BlendDataLights, typing.Sequence[Light], typing.Mapping[str, Light], bpy_prop_collection] = ...

  """

  Light data-blocks

  """

  linestyles: typing.Union[BlendDataLineStyles, typing.Sequence[FreestyleLineStyle], typing.Mapping[str, FreestyleLineStyle], bpy_prop_collection] = ...

  """

  Line Style data-blocks

  """

  masks: typing.Union[BlendDataMasks, typing.Sequence[Mask], typing.Mapping[str, Mask], bpy_prop_collection] = ...

  """

  Masks data-blocks

  """

  materials: typing.Union[BlendDataMaterials, typing.Sequence[Material], typing.Mapping[str, Material], bpy_prop_collection] = ...

  """

  Material data-blocks

  """

  meshes: typing.Union[BlendDataMeshes, typing.Sequence[Mesh], typing.Mapping[str, Mesh], bpy_prop_collection] = ...

  """

  Mesh data-blocks

  """

  metaballs: typing.Union[BlendDataMetaBalls, typing.Sequence[MetaBall], typing.Mapping[str, MetaBall], bpy_prop_collection] = ...

  """

  Metaball data-blocks

  """

  movieclips: typing.Union[BlendDataMovieClips, typing.Sequence[MovieClip], typing.Mapping[str, MovieClip], bpy_prop_collection] = ...

  """

  Movie Clip data-blocks

  """

  node_groups: typing.Union[BlendDataNodeTrees, typing.Sequence[NodeTree], typing.Mapping[str, NodeTree], bpy_prop_collection] = ...

  """

  Node group data-blocks

  """

  objects: typing.Union[BlendDataObjects, typing.Sequence[Object], typing.Mapping[str, Object], bpy_prop_collection] = ...

  """

  Object data-blocks

  """

  paint_curves: typing.Union[BlendDataPaintCurves, typing.Sequence[PaintCurve], typing.Mapping[str, PaintCurve], bpy_prop_collection] = ...

  """

  Paint Curves data-blocks

  """

  palettes: typing.Union[BlendDataPalettes, typing.Sequence[Palette], typing.Mapping[str, Palette], bpy_prop_collection] = ...

  """

  Palette data-blocks

  """

  particles: typing.Union[BlendDataParticles, typing.Sequence[ParticleSettings], typing.Mapping[str, ParticleSettings], bpy_prop_collection] = ...

  """

  Particle data-blocks

  """

  scenes: typing.Union[BlendDataScenes, typing.Sequence[Scene], typing.Mapping[str, Scene], bpy_prop_collection] = ...

  """

  Scene data-blocks

  """

  screens: typing.Union[BlendDataScreens, typing.Sequence[Screen], typing.Mapping[str, Screen], bpy_prop_collection] = ...

  """

  Screen data-blocks

  """

  shape_keys: typing.Union[typing.Sequence[Key], typing.Mapping[str, Key], bpy_prop_collection] = ...

  """

  Shape Key data-blocks

  """

  sounds: typing.Union[BlendDataSounds, typing.Sequence[Sound], typing.Mapping[str, Sound], bpy_prop_collection] = ...

  """

  Sound data-blocks

  """

  speakers: typing.Union[BlendDataSpeakers, typing.Sequence[Speaker], typing.Mapping[str, Speaker], bpy_prop_collection] = ...

  """

  Speaker data-blocks

  """

  texts: typing.Union[BlendDataTexts, typing.Sequence[Text], typing.Mapping[str, Text], bpy_prop_collection] = ...

  """

  Text data-blocks

  """

  textures: typing.Union[BlendDataTextures, typing.Sequence[Texture], typing.Mapping[str, Texture], bpy_prop_collection] = ...

  """

  Texture data-blocks

  """

  use_autopack: bool = ...

  """

  Automatically pack all external data into .blend file

  """

  version: typing.Tuple[int, int, int] = ...

  """

  File format version the .blend file was saved with

  """

  volumes: typing.Union[BlendDataVolumes, typing.Sequence[Volume], typing.Mapping[str, Volume], bpy_prop_collection] = ...

  """

  Volume data-blocks

  """

  window_managers: typing.Union[BlendDataWindowManagers, typing.Sequence[WindowManager], typing.Mapping[str, WindowManager], bpy_prop_collection] = ...

  """

  Window manager data-blocks

  """

  workspaces: typing.Union[BlendDataWorkSpaces, typing.Sequence[WorkSpace], typing.Mapping[str, WorkSpace], bpy_prop_collection] = ...

  """

  Workspace data-blocks

  """

  worlds: typing.Union[BlendDataWorlds, typing.Sequence[World], typing.Mapping[str, World], bpy_prop_collection] = ...

  """

  World data-blocks

  """

  def batch_remove(self, ids: typing.Any = (id1, id2, ...)) -> None:

    """

    Remove (delete) several IDs at once.

    WARNING: Considered experimental feature currently.

    Note that this function is quicker than individual calls to :func:`remove()` (from :class:`bpy.types.BlendData`
ID collections), but less safe/versatile (it can break Blender, e.g. by removing all scenes...).

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def orphans_purge(self) -> None:

    """

    Remove (delete) all IDs with no user.

    WARNING: Considered experimental feature currently.

    """

    ...

class BlendDataActions(bpy_struct):

  """

  Collection of actions

  """

  def new(self, name: str) -> Action:

    """

    Add a new action to the main database

    """

    ...

  def remove(self, action: Action, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a action from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataArmatures(bpy_struct):

  """

  Collection of armatures

  """

  def new(self, name: str) -> Armature:

    """

    Add a new armature to the main database

    """

    ...

  def remove(self, armature: Armature, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a armature from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataBrushes(bpy_struct):

  """

  Collection of brushes

  """

  def new(self, name: str, mode: str = 'TEXTURE_PAINT') -> Brush:

    """

    Add a new brush to the main database

    """

    ...

  def remove(self, brush: Brush, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a brush from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  def create_gpencil_data(self, brush: Brush) -> None:

    """

    Add grease pencil brush settings

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataCacheFiles(bpy_struct):

  """

  Collection of cache files

  """

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataCameras(bpy_struct):

  """

  Collection of cameras

  """

  def new(self, name: str) -> Camera:

    """

    Add a new camera to the main database

    """

    ...

  def remove(self, camera: Camera, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a camera from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataCollections(bpy_struct):

  """

  Collection of collections

  """

  def new(self, name: str) -> Collection:

    """

    Add a new collection to the main database

    """

    ...

  def remove(self, collection: Collection, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a collection from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataCurves(bpy_struct):

  """

  Collection of curves

  """

  def new(self, name: str, type: str) -> Curve:

    """

    Add a new curve to the main database

    """

    ...

  def remove(self, curve: Curve, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a curve from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataFonts(bpy_struct):

  """

  Collection of fonts

  """

  def load(self, filepath: str, check_existing: bool = False) -> VectorFont:

    """

    Load a new font into the main database

    """

    ...

  def remove(self, vfont: VectorFont, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a font from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataGreasePencils(bpy_struct):

  """

  Collection of grease pencils

  """

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  def new(self, name: str) -> GreasePencil:

    """

    Add a new grease pencil datablock to the main database

    """

    ...

  def remove(self, grease_pencil: GreasePencil, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a grease pencil instance from the current blendfile

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataImages(bpy_struct):

  """

  Collection of images

  """

  def new(self, name: str, width: int, height: int, alpha: bool = False, float_buffer: bool = False, stereo3d: bool = False, is_data: bool = False, tiled: bool = False) -> Image:

    """

    Add a new image to the main database

    """

    ...

  def load(self, filepath: str, check_existing: bool = False) -> Image:

    """

    Load a new image into the main database

    """

    ...

  def remove(self, image: Image, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove an image from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataLattices(bpy_struct):

  """

  Collection of lattices

  """

  def new(self, name: str) -> Lattice:

    """

    Add a new lattice to the main database

    """

    ...

  def remove(self, lattice: Lattice, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a lattice from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataLibraries(bpy_struct):

  """

  Collection of libraries

  """

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  def remove(self, library: Library, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a camera from the current blendfile

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def load(self, filepath: str, link: bool = False, relative: bool = False) -> None:

    """

    Returns a context manager which exposes 2 library objects on entering.
Each object has attributes matching bpy.data which are lists of strings to be linked.

    .. code::

      import bpy

      filepath = "//link_library.blend"

      # load a single scene we know the name of.
      with bpy.data.libraries.load(filepath) as (data_from, data_to):
          data_to.scenes = ["Scene"]


      # load all meshes
      with bpy.data.libraries.load(filepath) as (data_from, data_to):
          data_to.meshes = data_from.meshes


      # link all objects starting with 'A'
      with bpy.data.libraries.load(filepath, link=True) as (data_from, data_to):
          data_to.objects = [name for name in data_from.objects if name.startswith("A")]


      # append everything
      with bpy.data.libraries.load(filepath) as (data_from, data_to):
          for attr in dir(data_to):
              setattr(data_to, attr, getattr(data_from, attr))


      # the loaded objects can be accessed from 'data_to' outside of the context
      # since loading the data replaces the strings for the datablocks or None
      # if the datablock could not be loaded.
      with bpy.data.libraries.load(filepath) as (data_from, data_to):
          data_to.meshes = data_from.meshes
      # now operate directly on the loaded data
      for mesh in data_to.meshes:
          if mesh is not None:
              print(mesh.name)

    """

    ...

  def write(self, filepath: str, datablocks: typing.Set[typing.Any], path_remap: str = False, fake_user: bool = False, compress: bool = False) -> None:

    """

    Write data-blocks into a blend file.

    Note: Indirectly referenced data-blocks will be expanded and written too.

    .. code::

      import bpy

      filepath = "//new_library.blend"

      # write selected objects and their data to a blend file
      data_blocks = set(bpy.context.selected_objects)
      bpy.data.libraries.write(filepath, data_blocks)


      # write all meshes starting with a capital letter and
      # set them with fake-user enabled so they aren't lost on re-saving
      data_blocks = {mesh for mesh in bpy.data.meshes if mesh.name[:1].isupper()}
      bpy.data.libraries.write(filepath, data_blocks, fake_user=True)


      # write all materials, textures and node groups to a library
      data_blocks = {*bpy.data.materials, *bpy.data.textures, *bpy.data.node_groups}
      bpy.data.libraries.write(filepath, data_blocks)

    """

    ...

class BlendDataLights(bpy_struct):

  """

  Collection of lights

  """

  def new(self, name: str, type: str) -> Light:

    """

    Add a new light to the main database

    """

    ...

  def remove(self, light: Light, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a light from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataLineStyles(bpy_struct):

  """

  Collection of line styles

  """

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  def new(self, name: str) -> FreestyleLineStyle:

    """

    Add a new line style instance to the main database

    """

    ...

  def remove(self, linestyle: FreestyleLineStyle, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a line style instance from the current blendfile

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataMasks(bpy_struct):

  """

  Collection of masks

  """

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  def new(self, name: str) -> Mask:

    """

    Add a new mask with a given name to the main database

    """

    ...

  def remove(self, mask: Mask, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a masks from the current blendfile.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataMaterials(bpy_struct):

  """

  Collection of materials

  """

  def new(self, name: str) -> Material:

    """

    Add a new material to the main database

    """

    ...

  def create_gpencil_data(self, material: Material) -> None:

    """

    Add grease pencil material settings

    """

    ...

  def remove_gpencil_data(self, material: Material) -> None:

    """

    Remove grease pencil material settings

    """

    ...

  def remove(self, material: Material, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a material from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataMeshes(bpy_struct):

  """

  Collection of meshes

  """

  def new(self, name: str) -> Mesh:

    """

    Add a new mesh to the main database

    """

    ...

  def new_from_object(self, object: Object, preserve_all_data_layers: bool = False, depsgraph: Depsgraph = None) -> Mesh:

    """

    Add a new mesh created from given object (undeformed geometry if object is original, and final evaluated geometry, with all modifiers etc., if object is evaluated)

    """

    ...

  def remove(self, mesh: Mesh, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a mesh from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataMetaBalls(bpy_struct):

  """

  Collection of metaballs

  """

  def new(self, name: str) -> MetaBall:

    """

    Add a new metaball to the main database

    """

    ...

  def remove(self, metaball: MetaBall, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a metaball from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataMovieClips(bpy_struct):

  """

  Collection of movie clips

  """

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  def remove(self, clip: MovieClip, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a movie clip from the current blendfile.

    """

    ...

  def load(self, filepath: str, check_existing: bool = False) -> MovieClip:

    """

    Add a new movie clip to the main database from a file (while ``check_existing`` is disabled for consistency with other load functions, behavior with multiple movie-clips using the same file may incorrectly generate proxies)

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataNodeTrees(bpy_struct):

  """

  Collection of node trees

  """

  def new(self, name: str, type: str) -> NodeTree:

    """

    Add a new node tree to the main database

    """

    ...

  def remove(self, tree: NodeTree, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a node tree from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataObjects(bpy_struct):

  """

  Collection of objects

  """

  def new(self, name: str, object_data: ID) -> Object:

    """

    Add a new object to the main database

    """

    ...

  def remove(self, object: Object, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a object from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataPaintCurves(bpy_struct):

  """

  Collection of paint curves

  """

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataPalettes(bpy_struct):

  """

  Collection of palettes

  """

  def new(self, name: str) -> Palette:

    """

    Add a new palette to the main database

    """

    ...

  def remove(self, palette: Palette, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a palette from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataParticles(bpy_struct):

  """

  Collection of particle settings

  """

  def new(self, name: str) -> ParticleSettings:

    """

    Add a new particle settings instance to the main database

    """

    ...

  def remove(self, particle: ParticleSettings, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a particle settings instance from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataProbes(bpy_struct):

  """

  Collection of light probes

  """

  def new(self, name: str, type: str) -> LightProbe:

    """

    Add a new probe to the main database

    """

    ...

  def remove(self, lightprobe: LightProbe, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a probe from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataScenes(bpy_struct):

  """

  Collection of scenes

  """

  def new(self, name: str) -> Scene:

    """

    Add a new scene to the main database

    """

    ...

  def remove(self, scene: Scene, do_unlink: bool = True) -> None:

    """

    Remove a scene from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataScreens(bpy_struct):

  """

  Collection of screens

  """

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataSounds(bpy_struct):

  """

  Collection of sounds

  """

  def load(self, filepath: str, check_existing: bool = False) -> Sound:

    """

    Add a new sound to the main database from a file

    """

    ...

  def remove(self, sound: Sound, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a sound from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataSpeakers(bpy_struct):

  """

  Collection of speakers

  """

  def new(self, name: str) -> Speaker:

    """

    Add a new speaker to the main database

    """

    ...

  def remove(self, speaker: Speaker, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a speaker from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataTexts(bpy_struct):

  """

  Collection of texts

  """

  def new(self, name: str) -> Text:

    """

    Add a new text to the main database

    """

    ...

  def remove(self, text: Text, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a text from the current blendfile

    """

    ...

  def load(self, filepath: str, internal: bool = False) -> Text:

    """

    Add a new text to the main database from a file

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataTextures(bpy_struct):

  """

  Collection of textures

  """

  def new(self, name: str, type: str) -> Texture:

    """

    Add a new texture to the main database

    """

    ...

  def remove(self, texture: Texture, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a texture from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataVolumes(bpy_struct):

  """

  Collection of volumes

  """

  def new(self, name: str) -> Volume:

    """

    Add a new volume to the main database

    """

    ...

  def remove(self, volume: Volume, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a volume from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataWindowManagers(bpy_struct):

  """

  Collection of window managers

  """

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataWorkSpaces(bpy_struct):

  """

  Collection of workspaces

  """

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendDataWorlds(bpy_struct):

  """

  Collection of worlds

  """

  def new(self, name: str) -> World:

    """

    Add a new world to the main database

    """

    ...

  def remove(self, world: World, do_unlink: bool = True, do_id_user: bool = True, do_ui_user: bool = True) -> None:

    """

    Remove a world from the current blendfile

    """

    ...

  def tag(self, value: bool) -> None:

    """

    tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlenderRNA(bpy_struct):

  """

  Blender RNA structure definitions

  """

  structs: typing.Union[typing.Sequence[Struct], typing.Mapping[str, Struct], bpy_prop_collection] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoidRule(bpy_struct):

  name: str = ...

  """

  Boid rule name

  """

  type: str = ...

  """

  * ``GOAL``
Goal, Go to assigned object or loudest assigned signal source.

  * ``AVOID``
Avoid, Get away from assigned object or loudest assigned signal source.

  * ``AVOID_COLLISION``
Avoid Collision, Maneuver to avoid collisions with other boids and deflector objects in near future.

  * ``SEPARATE``
Separate, Keep from going through other boids.

  * ``FLOCK``
Flock, Move to center of neighbors and match their velocity.

  * ``FOLLOW_LEADER``
Follow Leader, Follow a boid or assigned object.

  * ``AVERAGE_SPEED``
Average Speed, Maintain speed, flight level or wander.

  * ``FIGHT``
Fight, Go to closest enemy and attack when in range.

  """

  use_in_air: bool = ...

  """

  Use rule when boid is flying

  """

  use_on_land: bool = ...

  """

  Use rule when boid is on land

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoidSettings(bpy_struct):

  """

  Settings for boid physics

  """

  accuracy: float = ...

  """

  Accuracy of attack

  """

  active_boid_state: BoidRule = ...

  active_boid_state_index: int = ...

  aggression: float = ...

  """

  Boid will fight this times stronger enemy

  """

  air_acc_max: float = ...

  """

  Maximum acceleration in air (relative to maximum speed)

  """

  air_ave_max: float = ...

  """

  Maximum angular velocity in air (relative to 180 degrees)

  """

  air_personal_space: float = ...

  """

  Radius of boids personal space in air (% of particle size)

  """

  air_speed_max: float = ...

  """

  Maximum speed in air

  """

  air_speed_min: float = ...

  """

  Minimum speed in air (relative to maximum speed)

  """

  bank: float = ...

  """

  Amount of rotation around velocity vector on turns

  """

  health: float = ...

  """

  Initial boid health when born

  """

  height: float = ...

  """

  Boid height relative to particle size

  """

  land_acc_max: float = ...

  """

  Maximum acceleration on land (relative to maximum speed)

  """

  land_ave_max: float = ...

  """

  Maximum angular velocity on land (relative to 180 degrees)

  """

  land_jump_speed: float = ...

  """

  Maximum speed for jumping

  """

  land_personal_space: float = ...

  """

  Radius of boids personal space on land (% of particle size)

  """

  land_smooth: float = ...

  """

  How smoothly the boids land

  """

  land_speed_max: float = ...

  """

  Maximum speed on land

  """

  land_stick_force: float = ...

  """

  How strong a force must be to start effecting a boid on land

  """

  pitch: float = ...

  """

  Amount of rotation around side vector

  """

  range: float = ...

  """

  Maximum distance from which a boid can attack

  """

  states: typing.Union[typing.Sequence[BoidState], typing.Mapping[str, BoidState], bpy_prop_collection] = ...

  strength: float = ...

  """

  Maximum caused damage on attack per second

  """

  use_climb: bool = ...

  """

  Allow boids to climb goal objects

  """

  use_flight: bool = ...

  """

  Allow boids to move in air

  """

  use_land: bool = ...

  """

  Allow boids to move on land

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoidState(bpy_struct):

  """

  Boid state for boid physics

  """

  active_boid_rule: BoidRule = ...

  active_boid_rule_index: int = ...

  falloff: float = ...

  name: str = ...

  """

  Boid state name

  """

  rule_fuzzy: float = ...

  rules: typing.Union[typing.Sequence[BoidRule], typing.Mapping[str, BoidRule], bpy_prop_collection] = ...

  ruleset_type: str = ...

  """

  How the rules in the list are evaluated

  * ``FUZZY``
Fuzzy, Rules are gone through top to bottom (only the first rule which effect is above fuzziness threshold is evaluated).

  * ``RANDOM``
Random, A random rule is selected for each boid.

  * ``AVERAGE``
Average, All rules are averaged.

  """

  volume: float = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Bone(bpy_struct):

  """

  Bone in an Armature data-block

  """

  bbone_curveinx: float = ...

  """

  X-axis handle offset for start of the B-Bone's curve, adjusts curvature

  """

  bbone_curveiny: float = ...

  """

  Y-axis handle offset for start of the B-Bone's curve, adjusts curvature

  """

  bbone_curveoutx: float = ...

  """

  X-axis handle offset for end of the B-Bone's curve, adjusts curvature

  """

  bbone_curveouty: float = ...

  """

  Y-axis handle offset for end of the B-Bone's curve, adjusts curvature

  """

  bbone_custom_handle_end: Bone = ...

  """

  Bone that serves as the end handle for the B-Bone curve

  """

  bbone_custom_handle_start: Bone = ...

  """

  Bone that serves as the start handle for the B-Bone curve

  """

  bbone_easein: float = ...

  """

  Length of first Bezier Handle (for B-Bones only)

  """

  bbone_easeout: float = ...

  """

  Length of second Bezier Handle (for B-Bones only)

  """

  bbone_handle_type_end: str = ...

  """

  Selects how the end handle of the B-Bone is computed

  * ``AUTO``
Automatic, Use connected parent and children to compute the handle.

  * ``ABSOLUTE``
Absolute, Use the position of the specified bone to compute the handle.

  * ``RELATIVE``
Relative, Use the offset of the specified bone from rest pose to compute the handle.

  * ``TANGENT``
Tangent, Use the orientation of the specified bone to compute the handle, ignoring the location.

  """

  bbone_handle_type_start: str = ...

  """

  Selects how the start handle of the B-Bone is computed

  * ``AUTO``
Automatic, Use connected parent and children to compute the handle.

  * ``ABSOLUTE``
Absolute, Use the position of the specified bone to compute the handle.

  * ``RELATIVE``
Relative, Use the offset of the specified bone from rest pose to compute the handle.

  * ``TANGENT``
Tangent, Use the orientation of the specified bone to compute the handle, ignoring the location.

  """

  bbone_rollin: float = ...

  """

  Roll offset for the start of the B-Bone, adjusts twist

  """

  bbone_rollout: float = ...

  """

  Roll offset for the end of the B-Bone, adjusts twist

  """

  bbone_scaleinx: float = ...

  """

  X-axis scale factor for start of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_scaleiny: float = ...

  """

  Y-axis scale factor for start of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_scaleoutx: float = ...

  """

  X-axis scale factor for end of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_scaleouty: float = ...

  """

  Y-axis scale factor for end of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_segments: int = ...

  """

  Number of subdivisions of bone (for B-Bones only)

  """

  bbone_x: float = ...

  """

  B-Bone X size

  """

  bbone_z: float = ...

  """

  B-Bone Z size

  """

  children: typing.Union[typing.Sequence[Bone], typing.Mapping[str, Bone], bpy_prop_collection] = ...

  """

  Bones which are children of this bone

  """

  envelope_distance: float = ...

  """

  Bone deformation distance (for Envelope deform only)

  """

  envelope_weight: float = ...

  """

  Bone deformation weight (for Envelope deform only)

  """

  head: typing.Tuple[float, float, float] = ...

  """

  Location of head end of the bone relative to its parent

  """

  head_local: typing.Tuple[float, float, float] = ...

  """

  Location of head end of the bone relative to armature

  """

  head_radius: float = ...

  """

  Radius of head of bone (for Envelope deform only)

  """

  hide: bool = ...

  """

  Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)

  """

  hide_select: bool = ...

  """

  Bone is able to be selected

  """

  inherit_scale: str = ...

  """

  Specifies how the bone inherits scaling from the parent bone

  * ``FULL``
Full, Inherit all effects of parent scaling.

  * ``FIX_SHEAR``
Fix Shear, Inherit scaling, but remove shearing of the child in the rest orientation.

  * ``ALIGNED``
Aligned, Rotate non-uniform parent scaling to align with the child, applying parent X scale to child X axis, and so forth.

  * ``AVERAGE``
Average, Inherit uniform scaling representing the overall change in the volume of the parent.

  * ``NONE``
None, Completely ignore parent scaling.

  * ``NONE_LEGACY``
None (Legacy), Ignore parent scaling without compensating for parent shear. Replicates the effect of disabling the original Inherit Scale checkbox.

  """

  layers: typing.Tuple[bool, ...] = ...

  """

  Layers bone exists in

  """

  length: float = ...

  """

  Length of the bone

  """

  matrix: typing.Tuple[typing.Tuple[float, float, float], typing.Tuple[float, float, float], typing.Tuple[float, float, float]] = ...

  """

  3x3 bone matrix

  """

  matrix_local: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  4x4 bone matrix relative to armature

  """

  name: str = ...

  parent: Bone = ...

  """

  Parent bone (in same Armature)

  """

  select: bool = ...

  select_head: bool = ...

  select_tail: bool = ...

  show_wire: bool = ...

  """

  Bone is always drawn as Wireframe regardless of viewport draw mode (useful for non-obstructive custom bone shapes)

  """

  tail: typing.Tuple[float, float, float] = ...

  """

  Location of tail end of the bone relative to its parent

  """

  tail_local: typing.Tuple[float, float, float] = ...

  """

  Location of tail end of the bone relative to armature

  """

  tail_radius: float = ...

  """

  Radius of tail of bone (for Envelope deform only)

  """

  use_connect: bool = ...

  """

  When bone has a parent, bone's head is stuck to the parent's tail

  """

  use_cyclic_offset: bool = ...

  """

  When bone doesn't have a parent, it receives cyclic offset effects (Deprecated)

  """

  use_deform: bool = ...

  """

  Enable Bone to deform geometry

  """

  use_endroll_as_inroll: bool = ...

  """

  Add Roll Out of the Start Handle bone to the Roll In value

  """

  use_envelope_multiply: bool = ...

  """

  When deforming bone, multiply effects of Vertex Group weights with Envelope influence

  """

  use_inherit_rotation: bool = ...

  """

  Bone inherits rotation or scale from parent bone

  """

  use_inherit_scale: bool = ...

  """

  DEPRECATED: Bone inherits scaling from parent bone

  """

  use_local_location: bool = ...

  """

  Bone location is set in local space

  """

  use_relative_parent: bool = ...

  """

  Object children will use relative transform, like deform

  """

  basename: typing.Any = ...

  """

  The name of this bone before any '.' character

  (readonly)

  """

  center: typing.Any = ...

  """

  The midpoint between the head and the tail.

  (readonly)

  """

  children: typing.Any = ...

  """

  A list of all the bones children.

    Note: Takes ``O(len(bones))`` time.

  (readonly)

  """

  children_recursive: typing.Any = ...

  """

  A list of all children from this bone.

    Note: Takes ``O(len(bones)**2)`` time.

  (readonly)

  """

  children_recursive_basename: typing.Any = ...

  """

  Returns a chain of children with the same base name as this bone.
Only direct chains are supported, forks caused by multiple children
with matching base names will terminate the function
and not be returned.

  Note: Takes ``O(len(bones)**2)`` time.

  (readonly)

  """

  parent_recursive: typing.Any = ...

  """

  A list of parents, starting with the immediate parent

  (readonly)

  """

  vector: typing.Any = ...

  """

  The direction this bone is pointing.
Utility function for (tail - head)

  (readonly)

  """

  x_axis: typing.Any = ...

  """

  Vector pointing down the x-axis of the bone.

  (readonly)

  """

  y_axis: typing.Any = ...

  """

  Vector pointing down the y-axis of the bone.

  (readonly)

  """

  z_axis: typing.Any = ...

  """

  Vector pointing down the z-axis of the bone.

  (readonly)

  """

  def evaluate_envelope(self, point: typing.Tuple[float, float, float]) -> float:

    """

    Calculate bone envelope at given point

    """

    ...

  def convert_local_to_pose(self, matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]], matrix_local: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]], parent_matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0)), parent_matrix_local: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0)), invert: bool = False) -> typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]]:

    """

    Transform a matrix from Local to Pose space (or back), taking into account options like Inherit Scale and Local Location. Unlike Object.convert_space, this uses custom rest and pose matrices provided by the caller. If the parent matrices are omitted, the bone is assumed to have no parent.

    """

    ...

  @classmethod

  def MatrixFromAxisRoll(cls, axis: typing.Tuple[float, float, float], roll: float) -> typing.Tuple[typing.Tuple[float, float, float], typing.Tuple[float, float, float], typing.Tuple[float, float, float]]:

    """

    Convert the axis + roll representation to a matrix

    """

    ...

  @classmethod

  def AxisRollFromMatrix(cls, matrix: typing.Tuple[typing.Tuple[float, float, float], typing.Tuple[float, float, float], typing.Tuple[float, float, float]], axis: typing.Tuple[float, float, float] = (0.0, 0.0, 0.0)) -> None:

    """

    Convert a rotational matrix to the axis + roll representation

    """

    ...

  def parent_index(self, parent_test: typing.Any) -> None:

    """

    The same as 'bone in other_bone.parent_recursive'
but saved generating a list.

    """

    ...

  def translate(self, vec: typing.Any) -> None:

    """

    Utility function to add *vec* to the head and tail of this bone

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoneGroup(bpy_struct):

  """

  Groups of Pose Channels (Bones)

  """

  color_set: str = ...

  """

  Custom color set to use

  """

  colors: ThemeBoneColorSet = ...

  """

  Copy of the colors associated with the group's color set

  """

  is_custom_color_set: bool = ...

  """

  Color set is user-defined instead of a fixed theme color set

  """

  name: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoneGroups(bpy_struct):

  """

  Collection of bone groups

  """

  active: BoneGroup = ...

  """

  Active bone group for this pose

  """

  active_index: int = ...

  """

  Active index in bone groups array

  """

  def new(self, name: str = 'Group') -> BoneGroup:

    """

    Add a new bone group to the object

    """

    ...

  def remove(self, group: BoneGroup) -> None:

    """

    Remove a bone group from this object

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BrushCapabilities(bpy_struct):

  """

  Read-only indications of supported operations

  """

  has_overlay: bool = ...

  has_random_texture_angle: bool = ...

  has_smooth_stroke: bool = ...

  has_spacing: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BrushCapabilitiesImagePaint(bpy_struct):

  """

  Read-only indications of supported operations

  """

  has_accumulate: bool = ...

  has_color: bool = ...

  has_radius: bool = ...

  has_space_attenuation: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BrushCapabilitiesSculpt(bpy_struct):

  """

  Read-only indications of which brush operations are supported by the current sculpt tool

  """

  has_accumulate: bool = ...

  has_auto_smooth: bool = ...

  has_color: bool = ...

  has_direction: bool = ...

  has_gravity: bool = ...

  has_height: bool = ...

  has_jitter: bool = ...

  has_normal_weight: bool = ...

  has_persistence: bool = ...

  has_pinch_factor: bool = ...

  has_plane_offset: bool = ...

  has_rake_factor: bool = ...

  has_random_texture_angle: bool = ...

  has_sculpt_plane: bool = ...

  has_secondary_color: bool = ...

  has_smooth_stroke: bool = ...

  has_space_attenuation: bool = ...

  has_strength_pressure: bool = ...

  has_tilt: bool = ...

  has_topology_rake: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BrushCapabilitiesVertexPaint(bpy_struct):

  """

  Read-only indications of supported operations

  """

  has_color: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BrushCapabilitiesWeightPaint(bpy_struct):

  """

  Read-only indications of supported operations

  """

  has_weight: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BrushGpencilSettings(bpy_struct):

  """

  Settings for grease pencil brush

  """

  active_smooth_factor: float = ...

  """

  Amount of smoothing while drawing

  """

  angle: float = ...

  """

  Direction of the stroke at which brush gives maximal thickness (0° for horizontal)

  """

  angle_factor: float = ...

  """

  Reduce brush thickness by this factor when stroke is perpendicular to 'Angle' direction

  """

  aspect: typing.Tuple[float, float] = ...

  brush_draw_mode: str = ...

  """

  Preselected mode when using this brush

  * ``ACTIVE``
Active, Use current mode.

  * ``MATERIAL``
Material, Use always material mode.

  * ``VERTEXCOLOR``
Vertex Color, Use always Vertex Color mode.

  """

  curve_jitter: CurveMapping = ...

  """

  Curve used for the jitter effect

  """

  curve_random_hue: CurveMapping = ...

  """

  Curve used for modulating effect

  """

  curve_random_pressure: CurveMapping = ...

  """

  Curve used for modulating effect

  """

  curve_random_saturation: CurveMapping = ...

  """

  Curve used for modulating effect

  """

  curve_random_strength: CurveMapping = ...

  """

  Curve used for modulating effect

  """

  curve_random_uv: CurveMapping = ...

  """

  Curve used for modulating effect

  """

  curve_random_value: CurveMapping = ...

  """

  Curve used for modulating effect

  """

  curve_sensitivity: CurveMapping = ...

  """

  Curve used for the sensitivity

  """

  curve_strength: CurveMapping = ...

  """

  Curve used for the strength

  """

  direction: str = ...

  """

  * ``ADD``
Add, Add effect of brush.

  * ``SUBTRACT``
Subtract, Subtract effect of brush.

  """

  eraser_mode: str = ...

  """

  Eraser Mode

  * ``SOFT``
Dissolve, Erase strokes, fading their points strength and thickness.

  * ``HARD``
Point, Erase stroke points.

  * ``STROKE``
Stroke, Erase entire strokes.

  """

  eraser_strength_factor: float = ...

  """

  Amount of erasing for strength

  """

  eraser_thickness_factor: float = ...

  """

  Amount of erasing for thickness

  """

  fill_direction: str = ...

  """

  Direction of the fill

  * ``NORMAL``
Normal, Fill internal area.

  * ``INVERT``
Inverted, Fill inverted area.

  """

  fill_draw_mode: str = ...

  """

  Mode to draw boundary limits

  * ``BOTH``
All, Use both visible strokes and edit lines as fill boundary limits.

  * ``STROKE``
Strokes, Use visible strokes as fill boundary limits.

  * ``CONTROL``
Edit Lines, Use edit lines as fill boundary limits.

  """

  fill_factor: int = ...

  """

  Multiplier for fill resolution, higher resolution is more accurate but slower

  """

  fill_layer_mode: str = ...

  """

  Layers used as boundaries

  * ``VISIBLE``
Visible, Visible layers.

  * ``ACTIVE``
Active, Only active layer.

  * ``ABOVE``
Layer Above, Layer above active.

  * ``BELOW``
Layer Below, Layer below active.

  * ``ALL_ABOVE``
All Above, All layers above active.

  * ``ALL_BELOW``
All Below, All layers below active.

  """

  fill_leak: int = ...

  """

  Size in pixels to consider the leak closed

  """

  fill_simplify_level: int = ...

  """

  Number of simplify steps (large values reduce fill accuracy)

  """

  fill_threshold: float = ...

  """

  Threshold to consider color transparent for filling

  """

  gpencil_paint_icon: str = ...

  gpencil_sculpt_icon: str = ...

  gpencil_vertex_icon: str = ...

  gpencil_weight_icon: str = ...

  hardness: float = ...

  """

  Gradient from the center of Dot and Box strokes (set to 1 for a solid stroke)

  """

  input_samples: int = ...

  """

  Generate intermediate points for very fast mouse movements. Set to 0 to disable

  """

  material: Material = ...

  """

  Material used for strokes drawn using this brush

  """

  pen_jitter: float = ...

  """

  Jitter factor for new strokes

  """

  pen_smooth_factor: float = ...

  """

  Amount of smoothing to apply after finish newly created strokes, to reduce jitter/noise

  """

  pen_smooth_steps: int = ...

  """

  Number of times to smooth newly created strokes

  """

  pen_strength: float = ...

  """

  Color strength for new strokes (affect alpha factor of color)

  """

  pen_subdivision_steps: int = ...

  """

  Number of times to subdivide newly created strokes, for less jagged strokes

  """

  pin_draw_mode: bool = ...

  """

  Pin the mode to the brush

  """

  random_hue_factor: float = ...

  """

  Random factor to modify original hue

  """

  random_pressure: float = ...

  """

  Randomness factor for pressure in new strokes

  """

  random_saturation_factor: float = ...

  """

  Random factor to modify original saturation

  """

  random_strength: float = ...

  """

  Randomness factor strength in new strokes

  """

  random_value_factor: float = ...

  """

  Random factor to modify original value

  """

  show_fill: bool = ...

  """

  Show transparent lines to use as boundary for filling

  """

  show_fill_boundary: bool = ...

  """

  Show help lines for filling to see boundaries

  """

  show_lasso: bool = ...

  """

  Do not draw fill color while drawing the stroke

  """

  simplify_factor: float = ...

  """

  Factor of Simplify using adaptive algorithm

  """

  use_default_eraser: bool = ...

  """

  Use this brush when enable eraser with fast switch key

  """

  use_edit_position: bool = ...

  """

  The brush affects the position of the point

  """

  use_edit_pressure: bool = ...

  """

  Affect pressure values as well when smoothing strokes

  """

  use_edit_strength: bool = ...

  """

  The brush affects the color strength of the point

  """

  use_edit_thickness: bool = ...

  """

  The brush affects the thickness of the point

  """

  use_edit_uv: bool = ...

  """

  The brush affects the UV rotation of the point

  """

  use_jitter_pressure: bool = ...

  """

  Use tablet pressure for jitter

  """

  use_material_pin: bool = ...

  """

  Keep material assigned to brush

  """

  use_occlude_eraser: bool = ...

  """

  Erase only strokes visible and not occluded

  """

  use_pressure: bool = ...

  """

  Use tablet pressure

  """

  use_random_press_hue: bool = ...

  """

  Use pressure to modulate randomness

  """

  use_random_press_radius: bool = ...

  """

  Use pressure to modulate randomness

  """

  use_random_press_sat: bool = ...

  """

  Use pressure to modulate randomness

  """

  use_random_press_strength: bool = ...

  """

  Use pressure to modulate randomness

  """

  use_random_press_uv: bool = ...

  """

  Use pressure to modulate randomness

  """

  use_random_press_val: bool = ...

  """

  Use pressure to modulate randomness

  """

  use_settings_postprocess: bool = ...

  """

  Additional post processing options for new strokes

  """

  use_settings_random: bool = ...

  """

  Random brush settings

  """

  use_settings_stabilizer: bool = ...

  """

  Draw lines with a delay to allow smooth strokes. Press Shift key to override while drawing

  """

  use_strength_pressure: bool = ...

  """

  Use tablet pressure for color strength

  """

  use_stroke_random_hue: bool = ...

  """

  Use randomness at stroke level

  """

  use_stroke_random_radius: bool = ...

  """

  Use randomness at stroke level

  """

  use_stroke_random_sat: bool = ...

  """

  Use randomness at stroke level

  """

  use_stroke_random_strength: bool = ...

  """

  Use randomness at stroke level

  """

  use_stroke_random_uv: bool = ...

  """

  Use randomness at stroke level

  """

  use_stroke_random_val: bool = ...

  """

  Use randomness at stroke level

  """

  use_trim: bool = ...

  """

  Trim intersecting stroke ends

  """

  uv_random: float = ...

  """

  Random factor for autogenerated UV rotation

  """

  vertex_color_factor: float = ...

  """

  Factor used to mix vertex color to get final color

  """

  vertex_mode: str = ...

  """

  Defines how vertex color affect to the strokes

  * ``STROKE``
Stroke, Vertex Color affects to Stroke only.

  * ``FILL``
Fill, Vertex Color affects to Fill only.

  * ``BOTH``
Stroke and Fill, Vertex Color affects to Stroke and Fill.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ByteColorAttributeValue(bpy_struct):

  """

  Color value in geometry attribute

  """

  color: typing.Tuple[float, float, float, float] = ...

  """

  RGBA color in scene linear color space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CameraBackgroundImage(bpy_struct):

  """

  Image and settings for display in the 3D View background

  """

  alpha: float = ...

  """

  Image opacity to blend the image against the background color

  """

  clip: MovieClip = ...

  """

  Movie clip displayed and edited in this space

  """

  clip_user: MovieClipUser = ...

  """

  Parameters defining which frame of the movie clip is displayed

  """

  display_depth: str = ...

  """

  Display under or over everything

  """

  frame_method: str = ...

  """

  How the image fits in the camera frame

  """

  image: Image = ...

  """

  Image displayed and edited in this space

  """

  image_user: ImageUser = ...

  """

  Parameters defining which layer, pass and frame of the image is displayed

  """

  offset: typing.Tuple[float, float] = ...

  rotation: float = ...

  """

  Rotation for the background image (ortho view only)

  """

  scale: float = ...

  """

  Scale the background image

  """

  show_background_image: bool = ...

  """

  Show this image as background

  """

  show_expanded: bool = ...

  """

  Show the expanded in the user interface

  """

  show_on_foreground: bool = ...

  """

  Show this image in front of objects in viewport

  """

  source: str = ...

  """

  Data source used for background

  """

  use_camera_clip: bool = ...

  """

  Use movie clip from active scene camera

  """

  use_flip_x: bool = ...

  """

  Flip the background image horizontally

  """

  use_flip_y: bool = ...

  """

  Flip the background image vertically

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CameraBackgroundImages(bpy_struct):

  """

  Collection of background images

  """

  def new(self) -> CameraBackgroundImage:

    """

    Add new background image

    """

    ...

  def remove(self, image: CameraBackgroundImage) -> None:

    """

    Remove background image

    """

    ...

  def clear(self) -> None:

    """

    Remove all background images

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CameraDOFSettings(bpy_struct):

  """

  Depth of Field settings

  """

  aperture_blades: int = ...

  """

  Number of blades in aperture for polygonal bokeh (at least 3)

  """

  aperture_fstop: float = ...

  """

  F-Stop ratio (lower numbers give more defocus, higher numbers give a sharper image)

  """

  aperture_ratio: float = ...

  """

  Distortion to simulate anamorphic lens bokeh

  """

  aperture_rotation: float = ...

  """

  Rotation of blades in aperture

  """

  focus_distance: float = ...

  """

  Distance to the focus point for depth of field

  """

  focus_object: Object = ...

  """

  Use this object to define the depth of field focal point

  """

  use_dof: bool = ...

  """

  Use Depth of Field

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CameraStereoData(bpy_struct):

  """

  Stereoscopy settings for a Camera data-block

  """

  convergence_distance: float = ...

  """

  The converge point for the stereo cameras (often the distance between a projector and the projection screen)

  """

  convergence_mode: str = ...

  """

  * ``OFFAXIS``
Off-Axis, Off-axis frustums converging in a plane.

  * ``PARALLEL``
Parallel, Parallel cameras with no convergence.

  * ``TOE``
Toe-in, Rotated cameras, looking at the convergence distance.

  """

  interocular_distance: float = ...

  """

  Set the distance between the eyes - the stereo plane distance / 30 should be fine

  """

  pivot: str = ...

  pole_merge_angle_from: float = ...

  """

  Angle at which interocular distance starts to fade to 0

  """

  pole_merge_angle_to: float = ...

  """

  Angle at which interocular distance is 0

  """

  use_pole_merge: bool = ...

  """

  Fade interocular distance to 0 after the given cutoff angle

  """

  use_spherical_stereo: bool = ...

  """

  Render every pixel rotating the camera around the middle of the interocular distance

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ChannelDriverVariables(bpy_struct):

  """

  Collection of channel driver Variables

  """

  def new(self) -> DriverVariable:

    """

    Add a new variable for the driver

    """

    ...

  def remove(self, variable: DriverVariable) -> None:

    """

    Remove an existing variable from the driver

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ChildParticle(bpy_struct):

  """

  Child particle interpolated from simulated or edited particles

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ClothCollisionSettings(bpy_struct):

  """

  Cloth simulation settings for self collision and collision with other objects

  """

  collection: Collection = ...

  """

  Limit colliders to this Collection

  """

  collision_quality: int = ...

  """

  How many collision iterations should be done. (higher is better quality but slower)

  """

  damping: float = ...

  """

  Amount of velocity lost on collision

  """

  distance_min: float = ...

  """

  Minimum distance between collision objects before collision response takes effect

  """

  friction: float = ...

  """

  Friction force if a collision happened (higher = less movement)

  """

  impulse_clamp: float = ...

  """

  Clamp collision impulses to avoid instability (0.0 to disable clamping)

  """

  self_distance_min: float = ...

  """

  Minimum distance between cloth faces before collision response takes effect

  """

  self_friction: float = ...

  """

  Friction with self contact

  """

  self_impulse_clamp: float = ...

  """

  Clamp collision impulses to avoid instability (0.0 to disable clamping)

  """

  use_collision: bool = ...

  """

  Enable collisions with other objects

  """

  use_self_collision: bool = ...

  """

  Enable self collisions

  """

  vertex_group_self_collisions: str = ...

  """

  Vertex group to define vertices which are not used during self collisions

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ClothSettings(bpy_struct):

  """

  Cloth simulation settings for an object

  """

  air_damping: float = ...

  """

  Air has normally some thickness which slows falling things down

  """

  bending_damping: float = ...

  """

  Amount of damping in bending behavior

  """

  bending_model: str = ...

  """

  Physical model for simulating bending forces

  * ``ANGULAR``
Angular, Cloth model with angular bending springs.

  * ``LINEAR``
Linear, Cloth model with linear bending springs (legacy).

  """

  bending_stiffness: float = ...

  """

  How much the material resists bending

  """

  bending_stiffness_max: float = ...

  """

  Maximum bending stiffness value

  """

  collider_friction: float = ...

  compression_damping: float = ...

  """

  Amount of damping in compression behavior

  """

  compression_stiffness: float = ...

  """

  How much the material resists compression

  """

  compression_stiffness_max: float = ...

  """

  Maximum compression stiffness value

  """

  density_strength: float = ...

  """

  Influence of target density on the simulation

  """

  density_target: float = ...

  """

  Maximum density of hair

  """

  effector_weights: EffectorWeights = ...

  fluid_density: float = ...

  """

  Density (kg/l) of the fluid contained inside the object, used to create a hydrostatic pressure gradient simulating the weight of the internal fluid, or buoyancy from the surrounding fluid if negative

  """

  goal_default: float = ...

  """

  Default Goal (vertex target position) value, when no Vertex Group used

  """

  goal_friction: float = ...

  """

  Goal (vertex target position) friction

  """

  goal_max: float = ...

  """

  Goal maximum, vertex group weights are scaled to match this range

  """

  goal_min: float = ...

  """

  Goal minimum, vertex group weights are scaled to match this range

  """

  goal_spring: float = ...

  """

  Goal (vertex target position) spring stiffness

  """

  gravity: typing.Tuple[float, float, float] = ...

  """

  Gravity or external force vector

  """

  internal_compression_stiffness: float = ...

  """

  How much the material resists compression

  """

  internal_compression_stiffness_max: float = ...

  """

  Maximum compression stiffness value

  """

  internal_friction: float = ...

  internal_spring_max_diversion: float = ...

  """

  How much the rays used to connect the internal points can diverge from the vertex normal

  """

  internal_spring_max_length: float = ...

  """

  The maximum length an internal spring can have during creation. If the distance between internal points is greater than this, no internal spring will be created between these points. A length of zero means that there is no length limit

  """

  internal_spring_normal_check: bool = ...

  """

  Require the points the internal springs connect to have opposite normal directions

  """

  internal_tension_stiffness: float = ...

  """

  How much the material resists stretching

  """

  internal_tension_stiffness_max: float = ...

  """

  Maximum tension stiffness value

  """

  mass: float = ...

  """

  The mass of each vertex on the cloth material

  """

  pin_stiffness: float = ...

  """

  Pin (vertex target position) spring stiffness

  """

  pressure_factor: float = ...

  """

  Ambient pressure (kPa) that balances out between the inside and outside of the object when it has the target volume

  """

  quality: int = ...

  """

  Quality of the simulation in steps per frame (higher is better quality but slower)

  """

  rest_shape_key: ShapeKey = ...

  """

  Shape key to use the rest spring lengths from

  """

  sewing_force_max: float = ...

  """

  Maximum sewing force

  """

  shear_damping: float = ...

  """

  Amount of damping in shearing behavior

  """

  shear_stiffness: float = ...

  """

  How much the material resists shearing

  """

  shear_stiffness_max: float = ...

  """

  Maximum shear scaling value

  """

  shrink_max: float = ...

  """

  Max amount to shrink cloth by

  """

  shrink_min: float = ...

  """

  Factor by which to shrink cloth

  """

  target_volume: float = ...

  """

  The mesh volume where the inner/outer pressure will be the same. If set to zero the change in volume will not affect pressure

  """

  tension_damping: float = ...

  """

  Amount of damping in stretching behavior

  """

  tension_stiffness: float = ...

  """

  How much the material resists stretching

  """

  tension_stiffness_max: float = ...

  """

  Maximum tension stiffness value

  """

  time_scale: float = ...

  """

  Cloth speed is multiplied by this value

  """

  uniform_pressure_force: float = ...

  """

  The uniform pressure that is constantly applied to the mesh, in units of Pressure Scale. Can be negative

  """

  use_dynamic_mesh: bool = ...

  """

  Make simulation respect deformations in the base mesh

  """

  use_internal_springs: bool = ...

  """

  Simulate an internal volume structure by creating springs connecting the opposite sides of the mesh

  """

  use_pressure: bool = ...

  """

  Simulate pressure inside a closed cloth mesh

  """

  use_pressure_volume: bool = ...

  """

  Use the Target Volume parameter as the initial volume, instead of calculating it from the mesh itself

  """

  use_sewing_springs: bool = ...

  """

  Pulls loose edges together

  """

  vertex_group_bending: str = ...

  """

  Vertex group for fine control over bending stiffness

  """

  vertex_group_intern: str = ...

  """

  Vertex group for fine control over the internal spring stiffness

  """

  vertex_group_mass: str = ...

  """

  Vertex Group for pinning of vertices

  """

  vertex_group_pressure: str = ...

  """

  Vertex Group for where to apply pressure. Zero weight means no pressure while a weight of one means full pressure. Faces with a vertex that has zero weight will be excluded from the volume calculation

  """

  vertex_group_shear_stiffness: str = ...

  """

  Vertex group for fine control over shear stiffness

  """

  vertex_group_shrink: str = ...

  """

  Vertex Group for shrinking cloth

  """

  vertex_group_structural_stiffness: str = ...

  """

  Vertex group for fine control over structural stiffness

  """

  voxel_cell_size: float = ...

  """

  Size of the voxel grid cells for interaction effects

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ClothSolverResult(bpy_struct):

  """

  Result of cloth solver iteration

  """

  avg_error: float = ...

  """

  Average error during substeps

  """

  avg_iterations: float = ...

  """

  Average iterations during substeps

  """

  max_error: float = ...

  """

  Maximum error during substeps

  """

  max_iterations: int = ...

  """

  Maximum iterations during substeps

  """

  min_error: float = ...

  """

  Minimum error during substeps

  """

  min_iterations: int = ...

  """

  Minimum iterations during substeps

  """

  status: typing.Set[str] = ...

  """

  Status of the solver iteration

  * ``SUCCESS``
Success, Computation was successful.

  * ``NUMERICAL_ISSUE``
Numerical Issue, The provided data did not satisfy the prerequisites.

  * ``NO_CONVERGENCE``
No Convergence, Iterative procedure did not converge.

  * ``INVALID_INPUT``
Invalid Input, The inputs are invalid, or the algorithm has been improperly called.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CollectionChildren(bpy_struct):

  """

  Collection of child collections

  """

  def link(self, child: Collection) -> None:

    """

    Add this collection as child of this collection

    """

    ...

  def unlink(self, child: Collection) -> None:

    """

    Remove this child collection from a collection

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CollectionObjects(bpy_struct):

  """

  Collection of collection objects

  """

  def link(self, object: Object) -> None:

    """

    Add this object to a collection

    """

    ...

  def unlink(self, object: Object) -> None:

    """

    Remove this object from a collection

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CollisionSettings(bpy_struct):

  """

  Collision settings for object in physics simulation

  """

  absorption: float = ...

  """

  How much of effector force gets lost during collision with this object (in percent)

  """

  cloth_friction: float = ...

  """

  Friction for cloth collisions

  """

  damping: float = ...

  """

  Amount of damping during collision

  """

  damping_factor: float = ...

  """

  Amount of damping during particle collision

  """

  damping_random: float = ...

  """

  Random variation of damping

  """

  friction_factor: float = ...

  """

  Amount of friction during particle collision

  """

  friction_random: float = ...

  """

  Random variation of friction

  """

  permeability: float = ...

  """

  Chance that the particle will pass through the mesh

  """

  stickiness: float = ...

  """

  Amount of stickiness to surface collision

  """

  thickness_inner: float = ...

  """

  Inner face thickness (only used by softbodies)

  """

  thickness_outer: float = ...

  """

  Outer face thickness

  """

  use: bool = ...

  """

  Enable this objects as a collider for physics systems

  """

  use_culling: bool = ...

  """

  Cloth collision acts with respect to the collider normals (improves penetration recovery)

  """

  use_normal: bool = ...

  """

  Cloth collision impulses act in the direction of the collider normals (more reliable in some cases)

  """

  use_particle_kill: bool = ...

  """

  Kill collided particles

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorManagedDisplaySettings(bpy_struct):

  """

  Color management specific to display device

  """

  display_device: str = ...

  """

  Display device name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorManagedInputColorspaceSettings(bpy_struct):

  """

  Input color space settings

  """

  is_data: bool = ...

  """

  Treat image as non-color data without color management, like normal or displacement maps

  """

  name: str = ...

  """

  Color space in the image file, to convert to and from when saving and loading the image

  * ``Filmic Log``
Filmic Log, Log based filmic shaper with 16.5 stops of latitude, and 25 stops of dynamic range.

  * ``Linear``
Linear, Rec. 709 (Full Range), Blender native linear space.

  * ``Linear ACES``
Linear ACES, ACES linear space.

  * ``Non-Color``
Non-Color, Color space used for images which contains non-color data (i,e, normal maps).

  * ``Raw``
Raw.

  * ``sRGB``
sRGB, Standard RGB Display Space.

  * ``XYZ``
XYZ.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorManagedSequencerColorspaceSettings(bpy_struct):

  """

  Input color space settings

  """

  name: str = ...

  """

  Color space that the sequencer operates in

  * ``Filmic Log``
Filmic Log, Log based filmic shaper with 16.5 stops of latitude, and 25 stops of dynamic range.

  * ``Linear``
Linear, Rec. 709 (Full Range), Blender native linear space.

  * ``Linear ACES``
Linear ACES, ACES linear space.

  * ``Non-Color``
Non-Color, Color space used for images which contains non-color data (i,e, normal maps).

  * ``Raw``
Raw.

  * ``sRGB``
sRGB, Standard RGB Display Space.

  * ``XYZ``
XYZ.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorManagedViewSettings(bpy_struct):

  """

  Color management settings used for displaying images on the display

  """

  curve_mapping: CurveMapping = ...

  """

  Color curve mapping applied before display transform

  """

  exposure: float = ...

  """

  Exposure (stops) applied before display transform

  """

  gamma: float = ...

  """

  Amount of gamma modification applied after display transform

  """

  look: str = ...

  """

  Additional transform applied before view transform for artistic needs

  * ``NONE``
None, Do not modify image in an artistic manner.

  """

  use_curve_mapping: bool = ...

  """

  Use RGB curved for pre-display transformation

  """

  view_transform: str = ...

  """

  View used when converting image to a display space

  * ``NONE``
None, Do not perform any color transform on display, use old non-color managed technique for display.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorMapping(bpy_struct):

  """

  Color mapping settings

  """

  blend_color: typing.Tuple[float, float, float] = ...

  """

  Blend color to mix with texture output color

  """

  blend_factor: float = ...

  blend_type: str = ...

  """

  Mode used to mix with texture output color

  """

  brightness: float = ...

  """

  Adjust the brightness of the texture

  """

  color_ramp: ColorRamp = ...

  contrast: float = ...

  """

  Adjust the contrast of the texture

  """

  saturation: float = ...

  """

  Adjust the saturation of colors in the texture

  """

  use_color_ramp: bool = ...

  """

  Toggle color ramp operations

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorRamp(bpy_struct):

  """

  Color ramp mapping a scalar value to a color

  """

  color_mode: str = ...

  """

  Set color mode to use for interpolation

  """

  elements: typing.Union[ColorRampElements, typing.Sequence[ColorRampElement], typing.Mapping[str, ColorRampElement], bpy_prop_collection] = ...

  hue_interpolation: str = ...

  """

  Set color interpolation

  """

  interpolation: str = ...

  """

  Set interpolation between color stops

  """

  def evaluate(self, position: float) -> typing.Tuple[float, float, float, float]:

    """

    Evaluate ColorRamp

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorRampElement(bpy_struct):

  """

  Element defining a color at a position in the color ramp

  """

  alpha: float = ...

  """

  Set alpha of selected color stop

  """

  color: typing.Tuple[float, float, float, float] = ...

  """

  Set color of selected color stop

  """

  position: float = ...

  """

  Set position of selected color stop

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorRampElements(bpy_struct):

  """

  Collection of Color Ramp Elements

  """

  def new(self, position: float) -> ColorRampElement:

    """

    Add element to ColorRamp

    """

    ...

  def remove(self, element: ColorRampElement) -> None:

    """

    Delete element from ColorRamp

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeOutputFileFileSlots(bpy_struct):

  """

  Collection of File Output node slots

  """

  def new(self, name: str) -> NodeSocket:

    """

    Add a file slot to this node

    """

    ...

  def remove(self, socket: NodeSocket) -> None:

    """

    Remove a file slot from this node

    """

    ...

  def clear(self) -> None:

    """

    Remove all file slots from this node

    """

    ...

  def move(self, from_index: int, to_index: int) -> None:

    """

    Move a file slot to another position

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeOutputFileLayerSlots(bpy_struct):

  """

  Collection of File Output node slots

  """

  def new(self, name: str) -> NodeSocket:

    """

    Add a file slot to this node

    """

    ...

  def remove(self, socket: NodeSocket) -> None:

    """

    Remove a file slot from this node

    """

    ...

  def clear(self) -> None:

    """

    Remove all file slots from this node

    """

    ...

  def move(self, from_index: int, to_index: int) -> None:

    """

    Move a file slot to another position

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ConsoleLine(bpy_struct):

  """

  Input line for the interactive console

  """

  body: str = ...

  """

  Text in the line

  """

  current_character: int = ...

  type: str = ...

  """

  Console line type when used in scrollback

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Constraint(bpy_struct):

  """

  Constraint modifying the transformation of objects and bones

  """

  active: bool = ...

  """

  Constraint is the one being edited

  """

  error_location: float = ...

  """

  Amount of residual error in Blender space unit for constraints that work on position

  """

  error_rotation: float = ...

  """

  Amount of residual error in radians for constraints that work on orientation

  """

  influence: float = ...

  """

  Amount of influence constraint will have on the final solution

  """

  is_proxy_local: bool = ...

  """

  Constraint was added in this proxy instance (i.e. did not belong to source Armature)

  """

  is_valid: bool = ...

  """

  Constraint has valid settings and can be evaluated

  """

  mute: bool = ...

  """

  Enable/Disable Constraint

  """

  name: str = ...

  """

  Constraint name

  """

  owner_space: str = ...

  """

  Space that owner is evaluated in

  * ``WORLD``
World Space, The constraint is applied relative to the world coordinate system.

  * ``POSE``
Pose Space, The constraint is applied in Pose Space, the object transformation is ignored.

  * ``LOCAL_WITH_PARENT``
Local With Parent, The constraint is applied relative to the rest pose local coordinate system of the bone, thus including the parent-induced transformation.

  * ``LOCAL``
Local Space, The constraint is applied relative to the local coordinate system of the object.

  """

  show_expanded: bool = ...

  """

  Constraint's panel is expanded in UI

  """

  target_space: str = ...

  """

  Space that target is evaluated in

  * ``WORLD``
World Space, The transformation of the target is evaluated relative to the world coordinate system.

  * ``POSE``
Pose Space, The transformation of the target is only evaluated in the Pose Space, the target armature object transformation is ignored.

  * ``LOCAL_WITH_PARENT``
Local With Parent, The transformation of the target bone is evaluated relative to its rest pose local coordinate system, thus including the parent-induced transformation.

  * ``LOCAL``
Local Space, The transformation of the target is evaluated relative to its local coordinate system.

  """

  type: str = ...

  """

  * ``CAMERA_SOLVER``
Camera Solver.

  * ``FOLLOW_TRACK``
Follow Track.

  * ``OBJECT_SOLVER``
Object Solver.

  * ``COPY_LOCATION``
Copy Location, Copy the location of a target (with an optional offset), so that they move together.

  * ``COPY_ROTATION``
Copy Rotation, Copy the rotation of a target (with an optional offset), so that they rotate together.

  * ``COPY_SCALE``
Copy Scale, Copy the scale factors of a target (with an optional offset), so that they are scaled by the same amount.

  * ``COPY_TRANSFORMS``
Copy Transforms, Copy all the transformations of a target, so that they move together.

  * ``LIMIT_DISTANCE``
Limit Distance, Restrict movements to within a certain distance of a target (at the time of constraint evaluation only).

  * ``LIMIT_LOCATION``
Limit Location, Restrict movement along each axis within given ranges.

  * ``LIMIT_ROTATION``
Limit Rotation, Restrict rotation along each axis within given ranges.

  * ``LIMIT_SCALE``
Limit Scale, Restrict scaling along each axis with given ranges.

  * ``MAINTAIN_VOLUME``
Maintain Volume, Compensate for scaling one axis by applying suitable scaling to the other two axes.

  * ``TRANSFORM``
Transformation, Use one transform property from target to control another (or same) property on owner.

  * ``TRANSFORM_CACHE``
Transform Cache, Look up the transformation matrix from an external file.

  * ``CLAMP_TO``
Clamp To, Restrict movements to lie along a curve by remapping location along curve's longest axis.

  * ``DAMPED_TRACK``
Damped Track, Point towards a target by performing the smallest rotation necessary.

  * ``IK``
Inverse Kinematics, Control a chain of bones by specifying the endpoint target (Bones only).

  * ``LOCKED_TRACK``
Locked Track, Rotate around the specified ('locked') axis to point towards a target.

  * ``SPLINE_IK``
Spline IK, Align chain of bones along a curve (Bones only).

  * ``STRETCH_TO``
Stretch To, Stretch along Y-Axis to point towards a target.

  * ``TRACK_TO``
Track To, Legacy tracking constraint prone to twisting artifacts.

  * ``ACTION``
Action, Use transform property of target to look up pose for owner from an Action.

  * ``ARMATURE``
Armature, Apply weight-blended transformation from multiple bones like the Armature modifier.

  * ``CHILD_OF``
Child Of, Make target the 'detachable' parent of owner.

  * ``FLOOR``
Floor, Use position (and optionally rotation) of target to define a 'wall' or 'floor' that the owner can not cross.

  * ``FOLLOW_PATH``
Follow Path, Use to animate an object/bone following a path.

  * ``PIVOT``
Pivot, Change pivot point for transforms (buggy).

  * ``SHRINKWRAP``
Shrinkwrap, Restrict movements to surface of target mesh.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ConstraintTarget(bpy_struct):

  """

  Target object for multi-target constraints

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ConstraintTargetBone(bpy_struct):

  """

  Target bone for multi-target constraints

  """

  subtarget: str = ...

  """

  Target armature bone

  """

  target: Object = ...

  """

  Target armature

  """

  weight: float = ...

  """

  Blending weight of this bone

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Context(bpy_struct):

  """

  Current windowmanager and data context

  """

  area: Area = ...

  blend_data: BlendData = ...

  collection: Collection = ...

  engine: str = ...

  gizmo_group: GizmoGroup = ...

  layer_collection: LayerCollection = ...

  mode: str = ...

  preferences: Preferences = ...

  region: Region = ...

  region_data: RegionView3D = ...

  scene: Scene = ...

  screen: Screen = ...

  space_data: Space = ...

  tool_settings: ToolSettings = ...

  view_layer: ViewLayer = ...

  window: Window = ...

  window_manager: WindowManager = ...

  workspace: WorkSpace = ...

  def evaluated_depsgraph_get(self) -> Depsgraph:

    """

    Get the dependency graph for the current scene and view layer, to access to data-blocks with animation and modifiers applied. If any data-blocks have been edited, the dependency graph will be updated. This invalidates all references to evaluated data-blocks from the dependency graph.

    """

    ...

  def copy(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurveMap(bpy_struct):

  """

  Curve in a curve mapping

  """

  points: typing.Union[CurveMapPoints, typing.Sequence[CurveMapPoint], typing.Mapping[str, CurveMapPoint], bpy_prop_collection] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurveMapPoint(bpy_struct):

  """

  Point of a curve used for a curve mapping

  """

  handle_type: str = ...

  """

  Curve interpolation at this point: Bezier or vector

  """

  location: typing.Tuple[float, float] = ...

  """

  X/Y coordinates of the curve point

  """

  select: bool = ...

  """

  Selection state of the curve point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurveMapPoints(bpy_struct):

  """

  Collection of Curve Map Points

  """

  def new(self, position: float, value: float) -> CurveMapPoint:

    """

    Add point to CurveMap

    """

    ...

  def remove(self, point: CurveMapPoint) -> None:

    """

    Delete point from CurveMap

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurveMapping(bpy_struct):

  """

  Curve mapping to map color, vector and scalar values to other values using a user defined curve

  """

  black_level: typing.Tuple[float, float, float] = ...

  """

  For RGB curves, the color that black is mapped to

  """

  clip_max_x: float = ...

  clip_max_y: float = ...

  clip_min_x: float = ...

  clip_min_y: float = ...

  curves: typing.Union[typing.Sequence[CurveMap], typing.Mapping[str, CurveMap], bpy_prop_collection] = ...

  extend: str = ...

  """

  Extrapolate the curve or extend it horizontally

  """

  tone: str = ...

  """

  Tone of the curve

  """

  use_clip: bool = ...

  """

  Force the curve view to fit a defined boundary

  """

  white_level: typing.Tuple[float, float, float] = ...

  """

  For RGB curves, the color that white is mapped to

  """

  def update(self) -> None:

    """

    Update curve mapping after making changes

    """

    ...

  def initialize(self) -> None:

    """

    Initialize curve

    """

    ...

  def evaluate(self, curve: CurveMap, position: float) -> float:

    """

    Evaluate curve at given location

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurvePaintSettings(bpy_struct):

  corner_angle: float = ...

  """

  Angles above this are considered corners

  """

  curve_type: str = ...

  """

  Type of curve to use for new strokes

  """

  depth_mode: str = ...

  """

  Method of projecting depth

  """

  error_threshold: int = ...

  """

  Allow deviation for a smoother, less precise line

  """

  fit_method: str = ...

  """

  Curve fitting method

  * ``REFIT``
Refit, Incrementally re-fit the curve (high quality).

  * ``SPLIT``
Split, Split the curve until the tolerance is met (fast).

  """

  radius_max: float = ...

  """

  Radius to use when the maximum pressure is applied (or when a tablet isn't used)

  """

  radius_min: float = ...

  """

  Minimum radius when the minimum pressure is applied (also the minimum when tapering)

  """

  radius_taper_end: float = ...

  """

  Taper factor for the radius of each point along the curve

  """

  radius_taper_start: float = ...

  """

  Taper factor for the radius of each point along the curve

  """

  surface_offset: float = ...

  """

  Offset the stroke from the surface

  """

  surface_plane: str = ...

  """

  Plane for projected stroke

  * ``NORMAL_VIEW``
Normal/View, Display perpendicular to the surface.

  * ``NORMAL_SURFACE``
Normal/Surface, Display aligned to the surface.

  * ``VIEW``
View, Display aligned to the viewport.

  """

  use_corners_detect: bool = ...

  """

  Detect corners and use non-aligned handles

  """

  use_offset_absolute: bool = ...

  """

  Apply a fixed offset (don't scale by the radius)

  """

  use_pressure_radius: bool = ...

  """

  Map tablet pressure to curve radius

  """

  use_stroke_endpoints: bool = ...

  """

  Use the start of the stroke for the depth

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurveProfile(bpy_struct):

  """

  Profile Path editor used to build a profile path

  """

  points: typing.Union[CurveProfilePoints, typing.Sequence[CurveProfilePoint], typing.Mapping[str, CurveProfilePoint], bpy_prop_collection] = ...

  """

  Profile control points

  """

  preset: str = ...

  """

  * ``LINE``
Line, Default.

  * ``SUPPORTS``
Support Loops, Loops on each side of the profile.

  * ``CORNICE``
Cornice Molding.

  * ``CROWN``
Crown Molding.

  * ``STEPS``
Steps, A number of steps defined by the segments.

  """

  segments: typing.Union[typing.Sequence[CurveProfilePoint], typing.Mapping[str, CurveProfilePoint], bpy_prop_collection] = ...

  """

  Segments sampled from control points

  """

  use_clip: bool = ...

  """

  Force the path view to fit a defined boundary

  """

  use_sample_even_lengths: bool = ...

  """

  Sample edges with even lengths

  """

  use_sample_straight_edges: bool = ...

  """

  Sample edges with vector handles

  """

  def update(self) -> None:

    """

    Refresh internal data, remove doubles and clip points

    """

    ...

  def initialize(self, totsegments: int) -> None:

    """

    Set the number of display segments and fill tables

    """

    ...

  def evaluate(self, length_portion: float) -> typing.Tuple[float, float]:

    """

    Evaluate the at the given portion of the path length

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurveProfilePoint(bpy_struct):

  """

  Point of a path used to define a profile

  """

  handle_type_1: str = ...

  """

  Path interpolation at this point

  """

  handle_type_2: str = ...

  """

  Path interpolation at this point

  """

  location: typing.Tuple[float, float] = ...

  """

  X/Y coordinates of the path point

  """

  select: bool = ...

  """

  Selection state of the path point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurveProfilePoints(bpy_struct):

  """

  Collection of Profile Points

  """

  def add(self, x: float, y: float) -> CurveProfilePoint:

    """

    Add point to the profile

    """

    ...

  def remove(self, point: CurveProfilePoint) -> None:

    """

    Delete point from the profile

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurveSplines(bpy_struct):

  """

  Collection of curve splines

  """

  active: Spline = ...

  """

  Active curve spline

  """

  def new(self, type: str) -> Spline:

    """

    Add a new spline to the curve

    """

    ...

  def remove(self, spline: Spline) -> None:

    """

    Remove a spline from a curve

    """

    ...

  def clear(self) -> None:

    """

    Remove all splines from a curve

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Depsgraph(bpy_struct):

  ids: typing.Union[typing.Sequence[ID], typing.Mapping[str, ID], bpy_prop_collection] = ...

  """

  All evaluated datablocks

  """

  mode: str = ...

  """

  Evaluation mode

  * ``VIEWPORT``
Viewport, Viewport non-rendered mode.

  * ``RENDER``
Render, Render.

  """

  object_instances: typing.Union[typing.Sequence[DepsgraphObjectInstance], typing.Mapping[str, DepsgraphObjectInstance], bpy_prop_collection] = ...

  """

  All object instances to display or render (WARNING: only use this as an iterator, never as a sequence, and do not keep any references to its items)

  """

  objects: typing.Union[typing.Sequence[Object], typing.Mapping[str, Object], bpy_prop_collection] = ...

  """

  Evaluated objects in the dependency graph

  """

  scene: Scene = ...

  """

  Original scene dependency graph is built for

  """

  scene_eval: Scene = ...

  """

  Original scene dependency graph is built for

  """

  updates: typing.Union[typing.Sequence[DepsgraphUpdate], typing.Mapping[str, DepsgraphUpdate], bpy_prop_collection] = ...

  """

  Updates to datablocks

  """

  view_layer: ViewLayer = ...

  """

  Original view layer dependency graph is built for

  """

  view_layer_eval: ViewLayer = ...

  """

  Original view layer dependency graph is built for

  """

  def debug_relations_graphviz(self, filename: str) -> None:

    """

    debug_relations_graphviz

    """

    ...

  def debug_stats_gnuplot(self, filename: str, output_filename: str) -> None:

    """

    debug_stats_gnuplot

    """

    ...

  def debug_tag_update(self) -> None:

    """

    debug_tag_update

    """

    ...

  def debug_stats(self) -> str:

    """

    Report the number of elements in the Dependency Graph

    """

    ...

  def update(self) -> None:

    """

    Re-evaluate any modified data-blocks, for example for animation or modifiers. This invalidates all references to evaluated data-blocks from this dependency graph.

    """

    ...

  def id_eval_get(self, id: ID) -> ID:

    """

    id_eval_get

    """

    ...

  def id_type_updated(self, id_type: str) -> bool:

    """

    id_type_updated

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DepsgraphObjectInstance(bpy_struct):

  """

  Extended information about dependency graph object iterator (WARNING: all data here is *evaluated* one, not original .blend IDs...)

  """

  instance_object: Object = ...

  """

  Evaluated object which is being instanced by this iterator

  """

  is_instance: bool = ...

  """

  Denotes if the object is generated by another object

  """

  matrix_world: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Generated transform matrix in world space

  """

  object: Object = ...

  """

  Evaluated object the iterator points to

  """

  orco: typing.Tuple[float, float, float] = ...

  """

  Generated coordinates in parent object space

  """

  parent: Object = ...

  """

  If the object is an instance, the parent object that generated it

  """

  particle_system: ParticleSystem = ...

  """

  Evaluated particle system that this object was instanced from

  """

  persistent_id: typing.Tuple[int, ...] = ...

  """

  Persistent identifier for inter-frame matching of objects with motion blur

  """

  random_id: int = ...

  """

  Random id for this instance, typically for randomized shading

  """

  show_particles: bool = ...

  """

  Particles part of the object should be visible in the render

  """

  show_self: bool = ...

  """

  The object geometry itself should be visible in the render

  """

  uv: typing.Tuple[float, float] = ...

  """

  UV coordinates in parent object space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DepsgraphUpdate(bpy_struct):

  """

  Information about ID that was updated

  """

  id: ID = ...

  """

  Updated datablock

  """

  is_updated_geometry: bool = ...

  """

  Object geometry is updated

  """

  is_updated_shading: bool = ...

  """

  Object shading is updated

  """

  is_updated_transform: bool = ...

  """

  Object transformation is updated

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DisplaySafeAreas(bpy_struct):

  """

  Safe areas used in 3D view and the sequencer

  """

  action: typing.Tuple[float, float] = ...

  """

  Safe area for general elements

  """

  action_center: typing.Tuple[float, float] = ...

  """

  Safe area for general elements in a different aspect ratio

  """

  title: typing.Tuple[float, float] = ...

  """

  Safe area for text and graphics

  """

  title_center: typing.Tuple[float, float] = ...

  """

  Safe area for text and graphics in a different aspect ratio

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DopeSheet(bpy_struct):

  """

  Settings for filtering the channels shown in animation editors

  """

  filter_collection: Collection = ...

  """

  Collection that included object should be a member of

  """

  filter_fcurve_name: str = ...

  """

  F-Curve live filtering string

  """

  filter_text: str = ...

  """

  Live filtering string

  """

  show_armatures: bool = ...

  """

  Include visualization of armature related animation data

  """

  show_cache_files: bool = ...

  """

  Include visualization of cache file related animation data

  """

  show_cameras: bool = ...

  """

  Include visualization of camera related animation data

  """

  show_curves: bool = ...

  """

  Include visualization of curve related animation data

  """

  show_datablock_filters: bool = ...

  """

  Show options for whether channels related to certain types of data are included

  """

  show_expanded_summary: bool = ...

  """

  Collapse summary when shown, so all other channels get hidden (Dope Sheet editors only)

  """

  show_gpencil: bool = ...

  """

  Include visualization of Grease Pencil related animation data and frames

  """

  show_hairs: bool = ...

  """

  Include visualization of hair related animation data

  """

  show_hidden: bool = ...

  """

  Include channels from objects/bone that are not visible

  """

  show_lattices: bool = ...

  """

  Include visualization of lattice related animation data

  """

  show_lights: bool = ...

  """

  Include visualization of light related animation data

  """

  show_linestyles: bool = ...

  """

  Include visualization of Line Style related Animation data

  """

  show_materials: bool = ...

  """

  Include visualization of material related animation data

  """

  show_meshes: bool = ...

  """

  Include visualization of mesh related animation data

  """

  show_metaballs: bool = ...

  """

  Include visualization of metaball related animation data

  """

  show_missing_nla: bool = ...

  """

  Include animation data-blocks with no NLA data (NLA editor only)

  """

  show_modifiers: bool = ...

  """

  Include visualization of animation data related to data-blocks linked to modifiers

  """

  show_movieclips: bool = ...

  """

  Include visualization of movie clip related animation data

  """

  show_nodes: bool = ...

  """

  Include visualization of node related animation data

  """

  show_only_errors: bool = ...

  """

  Only include F-Curves and drivers that are disabled or have errors

  """

  show_only_selected: bool = ...

  """

  Only include channels relating to selected objects and data

  """

  show_particles: bool = ...

  """

  Include visualization of particle related animation data

  """

  show_pointclouds: bool = ...

  """

  Include visualization of point cloud related animation data

  """

  show_scenes: bool = ...

  """

  Include visualization of scene related animation data

  """

  show_shapekeys: bool = ...

  """

  Include visualization of shape key related animation data

  """

  show_speakers: bool = ...

  """

  Include visualization of speaker related animation data

  """

  show_summary: bool = ...

  """

  Display an additional 'summary' line (Dope Sheet editors only)

  """

  show_textures: bool = ...

  """

  Include visualization of texture related animation data

  """

  show_transforms: bool = ...

  """

  Include visualization of object-level animation data (mostly transforms)

  """

  show_volumes: bool = ...

  """

  Include visualization of volume related animation data

  """

  show_worlds: bool = ...

  """

  Include visualization of world related animation data

  """

  source: ID = ...

  """

  ID-Block representing source data, usually ID_SCE (i.e. Scene)

  """

  use_datablock_sort: bool = ...

  """

  Alphabetically sorts data-blocks - mainly objects in the scene (disable to increase viewport speed)

  """

  use_filter_invert: bool = ...

  """

  Invert filter search

  """

  use_multi_word_filter: bool = ...

  """

  Perform fuzzy/multi-word matching (WARNING: May be slow)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Driver(bpy_struct):

  """

  Driver for the value of a setting based on an external value

  """

  expression: str = ...

  """

  Expression to use for Scripted Expression

  """

  is_simple_expression: bool = ...

  """

  The scripted expression can be evaluated without using the full python interpreter

  """

  is_valid: bool = ...

  """

  Driver could not be evaluated in past, so should be skipped

  """

  type: str = ...

  """

  Driver type

  """

  use_self: bool = ...

  """

  Include a 'self' variable in the name-space, so drivers can easily reference the data being modified (object, bone, etc...)

  """

  variables: typing.Union[ChannelDriverVariables, typing.Sequence[DriverVariable], typing.Mapping[str, DriverVariable], bpy_prop_collection] = ...

  """

  Properties acting as inputs for this driver

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DriverTarget(bpy_struct):

  """

  Source of input values for driver variables

  """

  bone_target: str = ...

  """

  Name of PoseBone to use as target

  """

  data_path: str = ...

  """

  RNA Path (from ID-block) to property used

  """

  id: ID = ...

  """

  ID-block that the specific property used can be found from (id_type property must be set first)

  """

  id_type: str = ...

  """

  Type of ID-block that can be used

  """

  rotation_mode: str = ...

  """

  Mode for calculating rotation channel values

  * ``AUTO``
Auto Euler, Euler using the rotation order of the target.

  * ``XYZ``
XYZ Euler, Euler using the XYZ rotation order.

  * ``XZY``
XZY Euler, Euler using the XZY rotation order.

  * ``YXZ``
YXZ Euler, Euler using the YXZ rotation order.

  * ``YZX``
YZX Euler, Euler using the YZX rotation order.

  * ``ZXY``
ZXY Euler, Euler using the ZXY rotation order.

  * ``ZYX``
ZYX Euler, Euler using the ZYX rotation order.

  * ``QUATERNION``
Quaternion, Quaternion rotation.

  * ``SWING_TWIST_X``
Swing and X Twist, Decompose into a swing rotation to aim the X axis, followed by twist around it.

  * ``SWING_TWIST_Y``
Swing and Y Twist, Decompose into a swing rotation to aim the Y axis, followed by twist around it.

  * ``SWING_TWIST_Z``
Swing and Z Twist, Decompose into a swing rotation to aim the Z axis, followed by twist around it.

  """

  transform_space: str = ...

  """

  Space in which transforms are used

  * ``WORLD_SPACE``
World Space, Transforms include effects of parenting/restpose and constraints.

  * ``TRANSFORM_SPACE``
Transform Space, Transforms don't include parenting/restpose or constraints.

  * ``LOCAL_SPACE``
Local Space, Transforms include effects of constraints but not parenting/restpose.

  """

  transform_type: str = ...

  """

  Driver variable type

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DriverVariable(bpy_struct):

  """

  Variable from some source/target for driver relationship

  """

  is_name_valid: bool = ...

  """

  Is this a valid name for a driver variable

  """

  name: str = ...

  """

  Name to use in scripted expressions/functions (no spaces or dots are allowed, and must start with a letter)

  """

  targets: typing.Union[typing.Sequence[DriverTarget], typing.Mapping[str, DriverTarget], bpy_prop_collection] = ...

  """

  Sources of input data for evaluating this variable

  """

  type: str = ...

  """

  Driver variable type

  * ``SINGLE_PROP``
Single Property, Use the value from some RNA property (Default).

  * ``TRANSFORMS``
Transform Channel, Final transformation value of object or bone.

  * ``ROTATION_DIFF``
Rotational Difference, Use the angle between two bones.

  * ``LOC_DIFF``
Distance, Distance between two bones or objects.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DynamicPaintBrushSettings(bpy_struct):

  """

  Brush settings

  """

  invert_proximity: bool = ...

  """

  Proximity falloff is applied inside the volume

  """

  paint_alpha: float = ...

  """

  Paint alpha

  """

  paint_color: typing.Tuple[float, float, float] = ...

  """

  Color of the paint

  """

  paint_distance: float = ...

  """

  Maximum distance from brush to mesh surface to affect paint

  """

  paint_ramp: ColorRamp = ...

  """

  Color ramp used to define proximity falloff

  """

  paint_source: str = ...

  paint_wetness: float = ...

  """

  Paint wetness, visible in wetmap (some effects only affect wet paint)

  """

  particle_system: ParticleSystem = ...

  """

  The particle system to paint with

  """

  proximity_falloff: str = ...

  """

  Proximity falloff type

  """

  ray_direction: str = ...

  """

  Ray direction to use for projection (if brush object is located in that direction it's painted)

  """

  smooth_radius: float = ...

  """

  Smooth falloff added after solid radius

  """

  smudge_strength: float = ...

  """

  Smudge effect strength

  """

  solid_radius: float = ...

  """

  Radius that will be painted solid

  """

  use_absolute_alpha: bool = ...

  """

  Only increase alpha value if paint alpha is higher than existing

  """

  use_negative_volume: bool = ...

  """

  Negate influence inside the volume

  """

  use_paint_erase: bool = ...

  """

  Erase / remove paint instead of adding it

  """

  use_particle_radius: bool = ...

  """

  Use radius from particle settings

  """

  use_proximity_project: bool = ...

  """

  Brush is projected to canvas from defined direction within brush proximity

  """

  use_proximity_ramp_alpha: bool = ...

  """

  Only read color ramp alpha

  """

  use_smudge: bool = ...

  """

  Make this brush to smudge existing paint as it moves

  """

  use_velocity_alpha: bool = ...

  """

  Multiply brush influence by velocity color ramp alpha

  """

  use_velocity_color: bool = ...

  """

  Replace brush color by velocity color ramp

  """

  use_velocity_depth: bool = ...

  """

  Multiply brush intersection depth (displace, waves) by velocity ramp alpha

  """

  velocity_max: float = ...

  """

  Velocity considered as maximum influence (Blender units per frame)

  """

  velocity_ramp: ColorRamp = ...

  """

  Color ramp used to define brush velocity effect

  """

  wave_clamp: float = ...

  """

  Maximum level of surface intersection used to influence waves (use 0.0 to disable)

  """

  wave_factor: float = ...

  """

  Multiplier for wave influence of this brush

  """

  wave_type: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DynamicPaintCanvasSettings(bpy_struct):

  """

  Dynamic Paint canvas settings

  """

  canvas_surfaces: typing.Union[DynamicPaintSurfaces, typing.Sequence[DynamicPaintSurface], typing.Mapping[str, DynamicPaintSurface], bpy_prop_collection] = ...

  """

  Paint surface list

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DynamicPaintSurface(bpy_struct):

  """

  A canvas surface layer

  """

  brush_collection: Collection = ...

  """

  Only use brush objects from this collection

  """

  brush_influence_scale: float = ...

  """

  Adjust influence brush objects have on this surface

  """

  brush_radius_scale: float = ...

  """

  Adjust radius of proximity brushes or particles for this surface

  """

  color_dry_threshold: float = ...

  """

  The wetness level when colors start to shift to the background

  """

  color_spread_speed: float = ...

  """

  How fast colors get mixed within wet paint

  """

  depth_clamp: float = ...

  """

  Maximum level of depth intersection in object space (use 0.0 to disable)

  """

  displace_factor: float = ...

  """

  Strength of displace when applied to the mesh

  """

  displace_type: str = ...

  dissolve_speed: int = ...

  """

  Approximately in how many frames should dissolve happen

  """

  drip_acceleration: float = ...

  """

  How much surface acceleration affects dripping

  """

  drip_velocity: float = ...

  """

  How much surface velocity affects dripping

  """

  dry_speed: int = ...

  """

  Approximately in how many frames should drying happen

  """

  effect_ui: str = ...

  effector_weights: EffectorWeights = ...

  frame_end: int = ...

  """

  Simulation end frame

  """

  frame_start: int = ...

  """

  Simulation start frame

  """

  frame_substeps: int = ...

  """

  Do extra frames between scene frames to ensure smooth motion

  """

  image_fileformat: str = ...

  image_output_path: str = ...

  """

  Directory to save the textures

  """

  image_resolution: int = ...

  """

  Output image resolution

  """

  init_color: typing.Tuple[float, float, float, float] = ...

  """

  Initial color of the surface

  """

  init_color_type: str = ...

  init_layername: str = ...

  init_texture: Texture = ...

  is_active: bool = ...

  """

  Toggle whether surface is processed or ignored

  """

  is_cache_user: bool = ...

  name: str = ...

  """

  Surface name

  """

  output_name_a: str = ...

  """

  Name used to save output from this surface

  """

  output_name_b: str = ...

  """

  Name used to save output from this surface

  """

  point_cache: PointCache = ...

  shrink_speed: float = ...

  """

  How fast shrink effect moves on the canvas surface

  """

  spread_speed: float = ...

  """

  How fast spread effect moves on the canvas surface

  """

  surface_format: str = ...

  """

  Surface Format

  """

  surface_type: str = ...

  """

  Surface Type

  """

  use_antialiasing: bool = ...

  """

  Use 5x multisampling to smooth paint edges

  """

  use_dissolve: bool = ...

  """

  Enable to make surface changes disappear over time

  """

  use_dissolve_log: bool = ...

  """

  Use logarithmic dissolve (makes high values to fade faster than low values)

  """

  use_drip: bool = ...

  """

  Process drip effect (drip wet paint to gravity direction)

  """

  use_dry_log: bool = ...

  """

  Use logarithmic drying (makes high values to dry faster than low values)

  """

  use_drying: bool = ...

  """

  Enable to make surface wetness dry over time

  """

  use_incremental_displace: bool = ...

  """

  New displace is added cumulatively on top of existing

  """

  use_output_a: bool = ...

  """

  Save this output layer

  """

  use_output_b: bool = ...

  """

  Save this output layer

  """

  use_premultiply: bool = ...

  """

  Multiply color by alpha (recommended for Blender input)

  """

  use_shrink: bool = ...

  """

  Process shrink effect (shrink paint areas)

  """

  use_spread: bool = ...

  """

  Process spread effect (spread wet paint around surface)

  """

  use_wave_open_border: bool = ...

  """

  Pass waves through mesh edges

  """

  uv_layer: str = ...

  """

  UV map name

  """

  wave_damping: float = ...

  """

  Wave damping factor

  """

  wave_smoothness: float = ...

  """

  Limit maximum steepness of wave slope between simulation points (use higher values for smoother waves at expense of reduced detail)

  """

  wave_speed: float = ...

  """

  Wave propagation speed

  """

  wave_spring: float = ...

  """

  Spring force that pulls water level back to zero

  """

  wave_timescale: float = ...

  """

  Wave time scaling factor

  """

  def output_exists(self, object: Object, index: int) -> bool:

    """

    Checks if surface output layer of given name exists

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DynamicPaintSurfaces(bpy_struct):

  """

  Collection of Dynamic Paint Canvas surfaces

  """

  active: DynamicPaintSurface = ...

  """

  Active Dynamic Paint surface being displayed

  """

  active_index: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class EditBone(bpy_struct):

  """

  Editmode bone in an Armature data-block

  """

  bbone_curveinx: float = ...

  """

  X-axis handle offset for start of the B-Bone's curve, adjusts curvature

  """

  bbone_curveiny: float = ...

  """

  Y-axis handle offset for start of the B-Bone's curve, adjusts curvature

  """

  bbone_curveoutx: float = ...

  """

  X-axis handle offset for end of the B-Bone's curve, adjusts curvature

  """

  bbone_curveouty: float = ...

  """

  Y-axis handle offset for end of the B-Bone's curve, adjusts curvature

  """

  bbone_custom_handle_end: EditBone = ...

  """

  Bone that serves as the end handle for the B-Bone curve

  """

  bbone_custom_handle_start: EditBone = ...

  """

  Bone that serves as the start handle for the B-Bone curve

  """

  bbone_easein: float = ...

  """

  Length of first Bezier Handle (for B-Bones only)

  """

  bbone_easeout: float = ...

  """

  Length of second Bezier Handle (for B-Bones only)

  """

  bbone_handle_type_end: str = ...

  """

  Selects how the end handle of the B-Bone is computed

  * ``AUTO``
Automatic, Use connected parent and children to compute the handle.

  * ``ABSOLUTE``
Absolute, Use the position of the specified bone to compute the handle.

  * ``RELATIVE``
Relative, Use the offset of the specified bone from rest pose to compute the handle.

  * ``TANGENT``
Tangent, Use the orientation of the specified bone to compute the handle, ignoring the location.

  """

  bbone_handle_type_start: str = ...

  """

  Selects how the start handle of the B-Bone is computed

  * ``AUTO``
Automatic, Use connected parent and children to compute the handle.

  * ``ABSOLUTE``
Absolute, Use the position of the specified bone to compute the handle.

  * ``RELATIVE``
Relative, Use the offset of the specified bone from rest pose to compute the handle.

  * ``TANGENT``
Tangent, Use the orientation of the specified bone to compute the handle, ignoring the location.

  """

  bbone_rollin: float = ...

  """

  Roll offset for the start of the B-Bone, adjusts twist

  """

  bbone_rollout: float = ...

  """

  Roll offset for the end of the B-Bone, adjusts twist

  """

  bbone_scaleinx: float = ...

  """

  X-axis scale factor for start of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_scaleiny: float = ...

  """

  Y-axis scale factor for start of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_scaleoutx: float = ...

  """

  X-axis scale factor for end of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_scaleouty: float = ...

  """

  Y-axis scale factor for end of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_segments: int = ...

  """

  Number of subdivisions of bone (for B-Bones only)

  """

  bbone_x: float = ...

  """

  B-Bone X size

  """

  bbone_z: float = ...

  """

  B-Bone Z size

  """

  envelope_distance: float = ...

  """

  Bone deformation distance (for Envelope deform only)

  """

  envelope_weight: float = ...

  """

  Bone deformation weight (for Envelope deform only)

  """

  head: typing.Tuple[float, float, float] = ...

  """

  Location of head end of the bone

  """

  head_radius: float = ...

  """

  Radius of head of bone (for Envelope deform only)

  """

  hide: bool = ...

  """

  Bone is not visible when in Edit Mode

  """

  hide_select: bool = ...

  """

  Bone is able to be selected

  """

  inherit_scale: str = ...

  """

  Specifies how the bone inherits scaling from the parent bone

  * ``FULL``
Full, Inherit all effects of parent scaling.

  * ``FIX_SHEAR``
Fix Shear, Inherit scaling, but remove shearing of the child in the rest orientation.

  * ``ALIGNED``
Aligned, Rotate non-uniform parent scaling to align with the child, applying parent X scale to child X axis, and so forth.

  * ``AVERAGE``
Average, Inherit uniform scaling representing the overall change in the volume of the parent.

  * ``NONE``
None, Completely ignore parent scaling.

  * ``NONE_LEGACY``
None (Legacy), Ignore parent scaling without compensating for parent shear. Replicates the effect of disabling the original Inherit Scale checkbox.

  """

  layers: typing.Tuple[bool, ...] = ...

  """

  Layers bone exists in

  """

  length: float = ...

  """

  Length of the bone. Changing moves the tail end

  """

  lock: bool = ...

  """

  Bone is not able to be transformed when in Edit Mode

  """

  matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Matrix combining loc/rot of the bone (head position, direction and roll), in armature space (does not include/support bone's length/size)

  """

  name: str = ...

  parent: EditBone = ...

  """

  Parent edit bone (in same Armature)

  """

  roll: float = ...

  """

  Bone rotation around head-tail axis

  """

  select: bool = ...

  select_head: bool = ...

  select_tail: bool = ...

  show_wire: bool = ...

  """

  Bone is always drawn as Wireframe regardless of viewport draw mode (useful for non-obstructive custom bone shapes)

  """

  tail: typing.Tuple[float, float, float] = ...

  """

  Location of tail end of the bone

  """

  tail_radius: float = ...

  """

  Radius of tail of bone (for Envelope deform only)

  """

  use_connect: bool = ...

  """

  When bone has a parent, bone's head is stuck to the parent's tail

  """

  use_cyclic_offset: bool = ...

  """

  When bone doesn't have a parent, it receives cyclic offset effects (Deprecated)

  """

  use_deform: bool = ...

  """

  Enable Bone to deform geometry

  """

  use_endroll_as_inroll: bool = ...

  """

  Add Roll Out of the Start Handle bone to the Roll In value

  """

  use_envelope_multiply: bool = ...

  """

  When deforming bone, multiply effects of Vertex Group weights with Envelope influence

  """

  use_inherit_rotation: bool = ...

  """

  Bone inherits rotation or scale from parent bone

  """

  use_inherit_scale: bool = ...

  """

  DEPRECATED: Bone inherits scaling from parent bone

  """

  use_local_location: bool = ...

  """

  Bone location is set in local space

  """

  use_relative_parent: bool = ...

  """

  Object children will use relative transform, like deform

  """

  basename: typing.Any = ...

  """

  The name of this bone before any '.' character

  (readonly)

  """

  center: typing.Any = ...

  """

  The midpoint between the head and the tail.

  (readonly)

  """

  children: typing.Any = ...

  """

  A list of all the bones children.

    Note: Takes ``O(len(bones))`` time.

  (readonly)

  """

  children_recursive: typing.Any = ...

  """

  A list of all children from this bone.

    Note: Takes ``O(len(bones)**2)`` time.

  (readonly)

  """

  children_recursive_basename: typing.Any = ...

  """

  Returns a chain of children with the same base name as this bone.
Only direct chains are supported, forks caused by multiple children
with matching base names will terminate the function
and not be returned.

  Note: Takes ``O(len(bones)**2)`` time.

  (readonly)

  """

  parent_recursive: typing.Any = ...

  """

  A list of parents, starting with the immediate parent

  (readonly)

  """

  vector: typing.Any = ...

  """

  The direction this bone is pointing.
Utility function for (tail - head)

  (readonly)

  """

  x_axis: typing.Any = ...

  """

  Vector pointing down the x-axis of the bone.

  (readonly)

  """

  y_axis: typing.Any = ...

  """

  Vector pointing down the y-axis of the bone.

  (readonly)

  """

  z_axis: typing.Any = ...

  """

  Vector pointing down the z-axis of the bone.

  (readonly)

  """

  def align_roll(self, vector: typing.Tuple[float, float, float]) -> None:

    """

    Align the bone to a localspace roll so the Z axis points in the direction of the vector given

    """

    ...

  def align_orientation(self, other: typing.Any) -> None:

    """

    Align this bone to another by moving its tail and settings its roll
the length of the other bone is not used.

    """

    ...

  def parent_index(self, parent_test: typing.Any) -> None:

    """

    The same as 'bone in other_bone.parent_recursive'
but saved generating a list.

    """

    ...

  def transform(self, matrix: mathutils.Matrix, scale: bool = True, roll: bool = True) -> None:

    """

    Transform the the bones head, tail, roll and envelope
(when the matrix has a scale component).

    """

    ...

  def translate(self, vec: typing.Any) -> None:

    """

    Utility function to add *vec* to the head and tail of this bone

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class EffectorWeights(bpy_struct):

  """

  Effector weights for physics simulation

  """

  all: float = ...

  """

  All effector's weight

  """

  apply_to_hair_growing: bool = ...

  """

  Use force fields when growing hair

  """

  boid: float = ...

  """

  Boid effector weight

  """

  charge: float = ...

  """

  Charge effector weight

  """

  collection: Collection = ...

  """

  Limit effectors to this collection

  """

  curve_guide: float = ...

  """

  Curve guide effector weight

  """

  drag: float = ...

  """

  Drag effector weight

  """

  force: float = ...

  """

  Force effector weight

  """

  gravity: float = ...

  """

  Global gravity weight

  """

  harmonic: float = ...

  """

  Harmonic effector weight

  """

  lennardjones: float = ...

  """

  Lennard-Jones effector weight

  """

  magnetic: float = ...

  """

  Magnetic effector weight

  """

  smokeflow: float = ...

  """

  Fluid Flow effector weight

  """

  texture: float = ...

  """

  Texture effector weight

  """

  turbulence: float = ...

  """

  Turbulence effector weight

  """

  vortex: float = ...

  """

  Vortex effector weight

  """

  wind: float = ...

  """

  Wind effector weight

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class EnumPropertyItem(bpy_struct):

  """

  Definition of a choice in an RNA enum property

  """

  description: str = ...

  """

  Description of the item's purpose

  """

  icon: str = ...

  """

  Icon of the item

  """

  identifier: str = ...

  """

  Unique name used in the code and scripting

  """

  name: str = ...

  """

  Human readable name

  """

  value: int = ...

  """

  Value of the item

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Event(bpy_struct):

  """

  Window Manager Event

  """

  alt: bool = ...

  """

  True when the Alt/Option key is held

  """

  ascii: str = ...

  """

  Single ASCII character for this event

  """

  ctrl: bool = ...

  """

  True when the Ctrl key is held

  """

  is_mouse_absolute: bool = ...

  """

  The last motion event was an absolute input

  """

  is_repeat: bool = ...

  """

  The event is generated by holding a key down

  """

  is_tablet: bool = ...

  """

  The event has tablet data

  """

  mouse_prev_x: int = ...

  """

  The window relative horizontal location of the mouse

  """

  mouse_prev_y: int = ...

  """

  The window relative vertical location of the mouse

  """

  mouse_region_x: int = ...

  """

  The region relative horizontal location of the mouse

  """

  mouse_region_y: int = ...

  """

  The region relative vertical location of the mouse

  """

  mouse_x: int = ...

  """

  The window relative horizontal location of the mouse

  """

  mouse_y: int = ...

  """

  The window relative vertical location of the mouse

  """

  oskey: bool = ...

  """

  True when the Cmd key is held

  """

  pressure: float = ...

  """

  The pressure of the tablet or 1.0 if no tablet present

  """

  shift: bool = ...

  """

  True when the Shift key is held

  """

  tilt: typing.Tuple[float, float] = ...

  """

  The pressure of the tablet or zeroes if no tablet present

  """

  type: str = ...

  """

  * ``NONE``
Undocumented.

  * ``LEFTMOUSE``
Left Mouse, LMB.

  * ``MIDDLEMOUSE``
Middle Mouse, MMB.

  * ``RIGHTMOUSE``
Right Mouse, RMB.

  * ``BUTTON4MOUSE``
Button4 Mouse, MB4.

  * ``BUTTON5MOUSE``
Button5 Mouse, MB5.

  * ``BUTTON6MOUSE``
Button6 Mouse, MB6.

  * ``BUTTON7MOUSE``
Button7 Mouse, MB7.

  * ``PEN``
Pen.

  * ``ERASER``
Eraser.

  * ``MOUSEMOVE``
Mouse Move, MsMov.

  * ``INBETWEEN_MOUSEMOVE``
In-between Move, MsSubMov.

  * ``TRACKPADPAN``
Mouse/Trackpad Pan, MsPan.

  * ``TRACKPADZOOM``
Mouse/Trackpad Zoom, MsZoom.

  * ``MOUSEROTATE``
Mouse/Trackpad Rotate, MsRot.

  * ``MOUSESMARTZOOM``
Mouse/Trackpad Smart Zoom, MsSmartZoom.

  * ``WHEELUPMOUSE``
Wheel Up, WhUp.

  * ``WHEELDOWNMOUSE``
Wheel Down, WhDown.

  * ``WHEELINMOUSE``
Wheel In, WhIn.

  * ``WHEELOUTMOUSE``
Wheel Out, WhOut.

  * ``EVT_TWEAK_L``
Tweak Left, TwkL.

  * ``EVT_TWEAK_M``
Tweak Middle, TwkM.

  * ``EVT_TWEAK_R``
Tweak Right, TwkR.

  * ``A``
A.

  * ``B``
B.

  * ``C``
C.

  * ``D``
D.

  * ``E``
E.

  * ``F``
F.

  * ``G``
G.

  * ``H``
H.

  * ``I``
I.

  * ``J``
J.

  * ``K``
K.

  * ``L``
L.

  * ``M``
M.

  * ``N``
N.

  * ``O``
O.

  * ``P``
P.

  * ``Q``
Q.

  * ``R``
R.

  * ``S``
S.

  * ``T``
T.

  * ``U``
U.

  * ``V``
V.

  * ``W``
W.

  * ``X``
X.

  * ``Y``
Y.

  * ``Z``
Z.

  * ``ZERO``
0.

  * ``ONE``
1.

  * ``TWO``
2.

  * ``THREE``
3.

  * ``FOUR``
4.

  * ``FIVE``
5.

  * ``SIX``
6.

  * ``SEVEN``
7.

  * ``EIGHT``
8.

  * ``NINE``
9.

  * ``LEFT_CTRL``
Left Ctrl, CtrlL.

  * ``LEFT_ALT``
Left Alt, AltL.

  * ``LEFT_SHIFT``
Left Shift, ShiftL.

  * ``RIGHT_ALT``
Right Alt, AltR.

  * ``RIGHT_CTRL``
Right Ctrl, CtrlR.

  * ``RIGHT_SHIFT``
Right Shift, ShiftR.

  * ``OSKEY``
OS Key, Cmd.

  * ``APP``
Application, App.

  * ``GRLESS``
Grless.

  * ``ESC``
Esc.

  * ``TAB``
Tab.

  * ``RET``
Return, Enter.

  * ``SPACE``
Spacebar, Space.

  * ``LINE_FEED``
Line Feed.

  * ``BACK_SPACE``
Backspace, BkSpace.

  * ``DEL``
Delete, Del.

  * ``SEMI_COLON``
;.

  * ``PERIOD``
..

  * ``COMMA``
,.

  * ``QUOTE``
".

  * ``ACCENT_GRAVE``
`.

  * ``MINUS``
-.

  * ``PLUS``
+.

  * ``SLASH``
/.

  * ``BACK_SLASH``
\.

  * ``EQUAL``
=.

  * ``LEFT_BRACKET``
[.

  * ``RIGHT_BRACKET``
].

  * ``LEFT_ARROW``
Left Arrow, ←.

  * ``DOWN_ARROW``
Down Arrow, ↓.

  * ``RIGHT_ARROW``
Right Arrow, →.

  * ``UP_ARROW``
Up Arrow, ↑.

  * ``NUMPAD_2``
Numpad 2, Pad2.

  * ``NUMPAD_4``
Numpad 4, Pad4.

  * ``NUMPAD_6``
Numpad 6, Pad6.

  * ``NUMPAD_8``
Numpad 8, Pad8.

  * ``NUMPAD_1``
Numpad 1, Pad1.

  * ``NUMPAD_3``
Numpad 3, Pad3.

  * ``NUMPAD_5``
Numpad 5, Pad5.

  * ``NUMPAD_7``
Numpad 7, Pad7.

  * ``NUMPAD_9``
Numpad 9, Pad9.

  * ``NUMPAD_PERIOD``
Numpad ., Pad..

  * ``NUMPAD_SLASH``
Numpad /, Pad/.

  * ``NUMPAD_ASTERIX``
Numpad *, Pad*.

  * ``NUMPAD_0``
Numpad 0, Pad0.

  * ``NUMPAD_MINUS``
Numpad -, Pad-.

  * ``NUMPAD_ENTER``
Numpad Enter, PadEnter.

  * ``NUMPAD_PLUS``
Numpad +, Pad+.

  * ``F1``
F1.

  * ``F2``
F2.

  * ``F3``
F3.

  * ``F4``
F4.

  * ``F5``
F5.

  * ``F6``
F6.

  * ``F7``
F7.

  * ``F8``
F8.

  * ``F9``
F9.

  * ``F10``
F10.

  * ``F11``
F11.

  * ``F12``
F12.

  * ``F13``
F13.

  * ``F14``
F14.

  * ``F15``
F15.

  * ``F16``
F16.

  * ``F17``
F17.

  * ``F18``
F18.

  * ``F19``
F19.

  * ``F20``
F20.

  * ``F21``
F21.

  * ``F22``
F22.

  * ``F23``
F23.

  * ``F24``
F24.

  * ``PAUSE``
Pause.

  * ``INSERT``
Insert, Ins.

  * ``HOME``
Home.

  * ``PAGE_UP``
Page Up, PgUp.

  * ``PAGE_DOWN``
Page Down, PgDown.

  * ``END``
End.

  * ``MEDIA_PLAY``
Media Play/Pause, >/||.

  * ``MEDIA_STOP``
Media Stop, Stop.

  * ``MEDIA_FIRST``
Media First, |<<.

  * ``MEDIA_LAST``
Media Last, >>|.

  * ``TEXTINPUT``
Text Input, TxtIn.

  * ``WINDOW_DEACTIVATE``
Window Deactivate.

  * ``TIMER``
Timer, Tmr.

  * ``TIMER0``
Timer 0, Tmr0.

  * ``TIMER1``
Timer 1, Tmr1.

  * ``TIMER2``
Timer 2, Tmr2.

  * ``TIMER_JOBS``
Timer Jobs, TmrJob.

  * ``TIMER_AUTOSAVE``
Timer Autosave, TmrSave.

  * ``TIMER_REPORT``
Timer Report, TmrReport.

  * ``TIMERREGION``
Timer Region, TmrReg.

  * ``NDOF_MOTION``
NDOF Motion, NdofMov.

  * ``NDOF_BUTTON_MENU``
NDOF Menu, NdofMenu.

  * ``NDOF_BUTTON_FIT``
NDOF Fit, NdofFit.

  * ``NDOF_BUTTON_TOP``
NDOF Top, Ndof↑.

  * ``NDOF_BUTTON_BOTTOM``
NDOF Bottom, Ndof↓.

  * ``NDOF_BUTTON_LEFT``
NDOF Left, Ndof←.

  * ``NDOF_BUTTON_RIGHT``
NDOF Right, Ndof→.

  * ``NDOF_BUTTON_FRONT``
NDOF Front, NdofFront.

  * ``NDOF_BUTTON_BACK``
NDOF Back, NdofBack.

  * ``NDOF_BUTTON_ISO1``
NDOF Isometric 1, NdofIso1.

  * ``NDOF_BUTTON_ISO2``
NDOF Isometric 2, NdofIso2.

  * ``NDOF_BUTTON_ROLL_CW``
NDOF Roll CW, NdofRCW.

  * ``NDOF_BUTTON_ROLL_CCW``
NDOF Roll CCW, NdofRCCW.

  * ``NDOF_BUTTON_SPIN_CW``
NDOF Spin CW, NdofSCW.

  * ``NDOF_BUTTON_SPIN_CCW``
NDOF Spin CCW, NdofSCCW.

  * ``NDOF_BUTTON_TILT_CW``
NDOF Tilt CW, NdofTCW.

  * ``NDOF_BUTTON_TILT_CCW``
NDOF Tilt CCW, NdofTCCW.

  * ``NDOF_BUTTON_ROTATE``
NDOF Rotate, NdofRot.

  * ``NDOF_BUTTON_PANZOOM``
NDOF Pan/Zoom, NdofPanZoom.

  * ``NDOF_BUTTON_DOMINANT``
NDOF Dominant, NdofDom.

  * ``NDOF_BUTTON_PLUS``
NDOF Plus, Ndof+.

  * ``NDOF_BUTTON_MINUS``
NDOF Minus, Ndof-.

  * ``NDOF_BUTTON_ESC``
NDOF Esc, NdofEsc.

  * ``NDOF_BUTTON_ALT``
NDOF Alt, NdofAlt.

  * ``NDOF_BUTTON_SHIFT``
NDOF Shift, NdofShift.

  * ``NDOF_BUTTON_CTRL``
NDOF Ctrl, NdofCtrl.

  * ``NDOF_BUTTON_1``
NDOF Button 1, NdofB1.

  * ``NDOF_BUTTON_2``
NDOF Button 2, NdofB2.

  * ``NDOF_BUTTON_3``
NDOF Button 3, NdofB3.

  * ``NDOF_BUTTON_4``
NDOF Button 4, NdofB4.

  * ``NDOF_BUTTON_5``
NDOF Button 5, NdofB5.

  * ``NDOF_BUTTON_6``
NDOF Button 6, NdofB6.

  * ``NDOF_BUTTON_7``
NDOF Button 7, NdofB7.

  * ``NDOF_BUTTON_8``
NDOF Button 8, NdofB8.

  * ``NDOF_BUTTON_9``
NDOF Button 9, NdofB9.

  * ``NDOF_BUTTON_10``
NDOF Button 10, NdofB10.

  * ``NDOF_BUTTON_A``
NDOF Button A, NdofBA.

  * ``NDOF_BUTTON_B``
NDOF Button B, NdofBB.

  * ``NDOF_BUTTON_C``
NDOF Button C, NdofBC.

  * ``ACTIONZONE_AREA``
ActionZone Area, AZone Area.

  * ``ACTIONZONE_REGION``
ActionZone Region, AZone Region.

  * ``ACTIONZONE_FULLSCREEN``
ActionZone Fullscreen, AZone FullScr.

  """

  unicode: str = ...

  """

  Single unicode character for this event

  """

  value: str = ...

  """

  The type of event, only applies to some

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FCurve(bpy_struct):

  """

  F-Curve defining values of a period of time

  """

  array_index: int = ...

  """

  Index to the specific property affected by F-Curve if applicable

  """

  auto_smoothing: str = ...

  """

  Algorithm used to compute automatic handles

  * ``NONE``
None, Automatic handles only take immediately adjacent keys into account.

  * ``CONT_ACCEL``
Continuous Acceleration, Automatic handles are adjusted to avoid jumps in acceleration, resulting in smoother curves. However, key changes may affect interpolation over a larger stretch of the curve.

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Color of the F-Curve in the Graph Editor

  """

  color_mode: str = ...

  """

  Method used to determine color of F-Curve in Graph Editor

  * ``AUTO_RAINBOW``
Auto Rainbow, Cycle through the rainbow, trying to give each curve a unique color.

  * ``AUTO_RGB``
Auto XYZ to RGB, Use axis colors for transform and color properties, and auto-rainbow for the rest.

  * ``AUTO_YRGB``
Auto WXYZ to YRGB, Use axis colors for XYZ parts of transform, and yellow for the 'W' channel.

  * ``CUSTOM``
User Defined, Use custom hand-picked color for F-Curve.

  """

  data_path: str = ...

  """

  RNA Path to property affected by F-Curve

  """

  driver: Driver = ...

  """

  Channel Driver (only set for Driver F-Curves)

  """

  extrapolation: str = ...

  """

  Method used for evaluating value of F-Curve outside first and last keyframes

  * ``CONSTANT``
Constant, Hold values of endpoint keyframes.

  * ``LINEAR``
Linear, Use slope of curve leading in/out of endpoint keyframes.

  """

  group: ActionGroup = ...

  """

  Action Group that this F-Curve belongs to

  """

  hide: bool = ...

  """

  F-Curve and its keyframes are hidden in the Graph Editor graphs

  """

  is_empty: bool = ...

  """

  True if the curve contributes no animation due to lack of keyframes or useful modifiers, and should be deleted

  """

  is_valid: bool = ...

  """

  False when F-Curve could not be evaluated in past, so should be skipped when evaluating

  """

  keyframe_points: typing.Union[FCurveKeyframePoints, typing.Sequence[Keyframe], typing.Mapping[str, Keyframe], bpy_prop_collection] = ...

  """

  User-editable keyframes

  """

  lock: bool = ...

  """

  F-Curve's settings cannot be edited

  """

  modifiers: typing.Union[FCurveModifiers, typing.Sequence[FModifier], typing.Mapping[str, FModifier], bpy_prop_collection] = ...

  """

  Modifiers affecting the shape of the F-Curve

  """

  mute: bool = ...

  """

  Disable F-Curve Modifier evaluation

  """

  sampled_points: typing.Union[typing.Sequence[FCurveSample], typing.Mapping[str, FCurveSample], bpy_prop_collection] = ...

  """

  Sampled animation data

  """

  select: bool = ...

  """

  F-Curve is selected for editing

  """

  def evaluate(self, frame: float) -> float:

    """

    Evaluate F-Curve

    """

    ...

  def update(self) -> None:

    """

    Ensure keyframes are sorted in chronological order and handles are set correctly

    """

    ...

  def range(self) -> typing.Tuple[float, float]:

    """

    Get the time extents for F-Curve

    """

    ...

  def update_autoflags(self, data: typing.Any) -> None:

    """

    Update FCurve flags set automatically from affected property (currently, integer/discrete flags set when the property is not a float)

    """

    ...

  def convert_to_samples(self, start: int, end: int) -> None:

    """

    Convert current FCurve from keyframes to sample points, if necessary

    """

    ...

  def convert_to_keyframes(self, start: int, end: int) -> None:

    """

    Convert current FCurve from sample points to keyframes (linear interpolation), if necessary

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FCurveKeyframePoints(bpy_struct):

  """

  Collection of keyframe points

  """

  def insert(self, frame: float, value: float, options: typing.Set[str] = {}, keyframe_type: str = 'KEYFRAME') -> Keyframe:

    """

    Add a keyframe point to a F-Curve

    """

    ...

  def add(self, count: int) -> None:

    """

    Add a keyframe point to a F-Curve

    """

    ...

  def remove(self, keyframe: Keyframe, fast: bool = False) -> None:

    """

    Remove keyframe from an F-Curve

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FCurveModifiers(bpy_struct):

  """

  Collection of F-Curve Modifiers

  """

  active: FModifier = ...

  """

  Active F-Curve Modifier

  """

  def new(self, type: str) -> FModifier:

    """

    Add a constraint to this object

    """

    ...

  def remove(self, modifier: FModifier) -> None:

    """

    Remove a modifier from this F-Curve

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FCurveSample(bpy_struct):

  """

  Sample point for F-Curve

  """

  co: typing.Tuple[float, float] = ...

  """

  Point coordinates

  """

  select: bool = ...

  """

  Selection status

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FFmpegSettings(bpy_struct):

  """

  FFmpeg related settings for the scene

  """

  audio_bitrate: int = ...

  """

  Audio bitrate (kb/s)

  """

  audio_channels: str = ...

  """

  Audio channel count

  * ``MONO``
Mono, Set audio channels to mono.

  * ``STEREO``
Stereo, Set audio channels to stereo.

  * ``SURROUND4``
4 Channels, Set audio channels to 4 channels.

  * ``SURROUND51``
5.1 Surround, Set audio channels to 5.1 surround sound.

  * ``SURROUND71``
7.1 Surround, Set audio channels to 7.1 surround sound.

  """

  audio_codec: str = ...

  """

  FFmpeg audio codec to use

  * ``NONE``
No Audio, Disables audio output, for video-only renders.

  * ``AAC``
AAC.

  * ``AC3``
AC3.

  * ``FLAC``
FLAC.

  * ``MP2``
MP2.

  * ``MP3``
MP3.

  * ``OPUS``
Opus.

  * ``PCM``
PCM.

  * ``VORBIS``
Vorbis.

  """

  audio_mixrate: int = ...

  """

  Audio samplerate(samples/s)

  """

  audio_volume: float = ...

  """

  Audio volume

  """

  buffersize: int = ...

  """

  Rate control: buffer size (kb)

  """

  codec: str = ...

  """

  FFmpeg codec to use for video output

  * ``NONE``
No Video, Disables video output, for audio-only renders.

  * ``DNXHD``
DNxHD.

  * ``DV``
DV.

  * ``FFV1``
FFmpeg video codec #1.

  * ``FLASH``
Flash Video.

  * ``H264``
H.264.

  * ``HUFFYUV``
HuffYUV.

  * ``MPEG1``
MPEG-1.

  * ``MPEG2``
MPEG-2.

  * ``MPEG4``
MPEG-4 (divx).

  * ``PNG``
PNG.

  * ``QTRLE``
QT rle / QT Animation.

  * ``THEORA``
Theora.

  * ``WEBM``
WEBM / VP9.

  """

  constant_rate_factor: str = ...

  """

  Constant Rate Factor (CRF); tradeoff between video quality and file size

  * ``NONE``
Constant Bitrate, Configure constant bit rate, rather than constant output quality.

  * ``LOSSLESS``
Lossless.

  * ``PERC_LOSSLESS``
Perceptually lossless.

  * ``HIGH``
High quality.

  * ``MEDIUM``
Medium quality.

  * ``LOW``
Low quality.

  * ``VERYLOW``
Very low quality.

  * ``LOWEST``
Lowest quality.

  """

  ffmpeg_preset: str = ...

  """

  Tradeoff between encoding speed and compression ratio

  * ``BEST``
Slowest, Recommended if you have lots of time and want the best compression efficiency.

  * ``GOOD``
Good, The default and recommended for most applications.

  * ``REALTIME``
Realtime, Recommended for fast encoding.

  """

  format: str = ...

  """

  Output file container

  """

  gopsize: int = ...

  """

  Distance between key frames, also known as GOP size; influences file size and seekability

  """

  max_b_frames: int = ...

  """

  Maximum number of B-frames between non-B-frames; influences file size and seekability

  """

  maxrate: int = ...

  """

  Rate control: max rate (kb/s)

  """

  minrate: int = ...

  """

  Rate control: min rate (kb/s)

  """

  muxrate: int = ...

  """

  Mux rate (bits/s(!))

  """

  packetsize: int = ...

  """

  Mux packet size (byte)

  """

  use_autosplit: bool = ...

  """

  Autosplit output at 2GB boundary

  """

  use_lossless_output: bool = ...

  """

  Use lossless output for video streams

  """

  use_max_b_frames: bool = ...

  """

  Set a maximum number of B-frames

  """

  video_bitrate: int = ...

  """

  Video bitrate (kb/s)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifier(bpy_struct):

  """

  Modifier for values of F-Curve

  """

  active: bool = ...

  """

  F-Curve Modifier is the one being edited

  """

  blend_in: float = ...

  """

  Number of frames from start frame for influence to take effect

  """

  blend_out: float = ...

  """

  Number of frames from end frame for influence to fade out

  """

  frame_end: float = ...

  """

  Frame that modifier's influence ends (if Restrict Frame Range is in use)

  """

  frame_start: float = ...

  """

  Frame that modifier's influence starts (if Restrict Frame Range is in use)

  """

  influence: float = ...

  """

  Amount of influence F-Curve Modifier will have when not fading in/out

  """

  is_valid: bool = ...

  """

  F-Curve Modifier has invalid settings and will not be evaluated

  """

  mute: bool = ...

  """

  Disable F-Curve Modifier evaluation

  """

  show_expanded: bool = ...

  """

  F-Curve Modifier's panel is expanded in UI

  """

  type: str = ...

  """

  F-Curve Modifier Type

  * ``NULL``
Invalid.

  * ``GENERATOR``
Generator, Generate a curve using a factorized or expanded polynomial.

  * ``FNGENERATOR``
Built-In Function, Generate a curve using standard math functions such as sin and cos.

  * ``ENVELOPE``
Envelope, Reshape F-Curve values - e.g. change amplitude of movements.

  * ``CYCLES``
Cycles, Cyclic extend/repeat keyframe sequence.

  * ``NOISE``
Noise, Add pseudo-random noise on top of F-Curves.

  * ``LIMITS``
Limits, Restrict maximum and minimum values of F-Curve.

  * ``STEPPED``
Stepped Interpolation, Snap values to nearest grid-step - e.g. for a stop-motion look.

  """

  use_influence: bool = ...

  """

  F-Curve Modifier's effects will be tempered by a default factor

  """

  use_restricted_range: bool = ...

  """

  F-Curve Modifier is only applied for the specified frame range to help mask off effects in order to chain them

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifierEnvelopeControlPoint(bpy_struct):

  """

  Control point for envelope F-Modifier

  """

  frame: float = ...

  """

  Frame this control-point occurs on

  """

  max: float = ...

  """

  Upper bound of envelope at this control-point

  """

  min: float = ...

  """

  Lower bound of envelope at this control-point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifierEnvelopeControlPoints(bpy_struct):

  """

  Control points defining the shape of the envelope

  """

  def add(self, frame: float) -> FModifierEnvelopeControlPoint:

    """

    Add a control point to a FModifierEnvelope

    """

    ...

  def remove(self, point: FModifierEnvelopeControlPoint) -> None:

    """

    Remove a control-point from an FModifierEnvelope

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FaceMap(bpy_struct):

  """

  Group of faces, each face can only be part of one map

  """

  index: int = ...

  """

  Index number of the face map

  """

  name: str = ...

  """

  Face map name

  """

  select: bool = ...

  """

  Face-map selection state (for tools to use)

  """

  def add(self, index: typing.Tuple[int]) -> None:

    """

    Add vertices to the group

    """

    ...

  def remove(self, index: typing.Tuple[int]) -> None:

    """

    Remove a vertex from the group

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FaceMaps(bpy_struct):

  """

  Collection of face maps

  """

  active: FaceMap = ...

  """

  Face maps of the object

  """

  active_index: int = ...

  """

  Active index in face map array

  """

  def new(self, name: str = 'Map') -> FaceMap:

    """

    Add face map to object

    """

    ...

  def remove(self, group: FaceMap) -> None:

    """

    Delete vertex group from object

    """

    ...

  def clear(self) -> None:

    """

    Delete all vertex groups from object

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FieldSettings(bpy_struct):

  """

  Field settings for an object in physics simulation

  """

  apply_to_location: bool = ...

  """

  Affect particle's location

  """

  apply_to_rotation: bool = ...

  """

  Affect particle's dynamic rotation

  """

  distance_max: float = ...

  """

  Maximum distance for the field to work

  """

  distance_min: float = ...

  """

  Minimum distance for the field's fall-off

  """

  falloff_power: float = ...

  """

  How quickly strength falls off with distance from the force field

  """

  falloff_type: str = ...

  flow: float = ...

  """

  Convert effector force into air flow velocity

  """

  guide_clump_amount: float = ...

  """

  Amount of clumping

  """

  guide_clump_shape: float = ...

  """

  Shape of clumping

  """

  guide_free: float = ...

  """

  Guide-free time from particle life's end

  """

  guide_kink_amplitude: float = ...

  """

  The amplitude of the offset

  """

  guide_kink_axis: str = ...

  """

  Which axis to use for offset

  """

  guide_kink_frequency: float = ...

  """

  The frequency of the offset (1/total length)

  """

  guide_kink_shape: float = ...

  """

  Adjust the offset to the beginning/end

  """

  guide_kink_type: str = ...

  """

  Type of periodic offset on the curve

  """

  guide_minimum: float = ...

  """

  The distance from which particles are affected fully

  """

  harmonic_damping: float = ...

  """

  Damping of the harmonic force

  """

  inflow: float = ...

  """

  Inwards component of the vortex force

  """

  linear_drag: float = ...

  """

  Drag component proportional to velocity

  """

  noise: float = ...

  """

  Amount of noise for the force strength

  """

  quadratic_drag: float = ...

  """

  Drag component proportional to the square of velocity

  """

  radial_falloff: float = ...

  """

  Radial falloff power (real gravitational falloff = 2)

  """

  radial_max: float = ...

  """

  Maximum radial distance for the field to work

  """

  radial_min: float = ...

  """

  Minimum radial distance for the field's fall-off

  """

  rest_length: float = ...

  """

  Rest length of the harmonic force

  """

  seed: int = ...

  """

  Seed of the noise

  """

  shape: str = ...

  """

  Which direction is used to calculate the effector force

  * ``POINT``
Point, Field originates from the object center.

  * ``LINE``
Line, Field originates from the local Z axis of the object.

  * ``PLANE``
Plane, Field originates from the local XY plane of the object.

  * ``SURFACE``
Surface, Field originates from the surface of the object.

  * ``POINTS``
Every Point, Field originates from all of the vertices of the object.

  """

  size: float = ...

  """

  Size of the turbulence

  """

  source_object: Object = ...

  """

  Select domain object of the smoke simulation

  """

  strength: float = ...

  """

  Strength of force field

  """

  texture: Texture = ...

  """

  Texture to use as force

  """

  texture_mode: str = ...

  """

  How the texture effect is calculated (RGB & Curl need a RGB texture, else Gradient will be used instead)

  """

  texture_nabla: float = ...

  """

  Defines size of derivative offset used for calculating gradient and curl

  """

  type: str = ...

  """

  Type of field

  * ``NONE``
None.

  * ``FORCE``
Force, Radial field toward the center of object.

  * ``WIND``
Wind, Constant force along the force object's local Z axis.

  * ``VORTEX``
Vortex, Spiraling force that twists the force object's local Z axis.

  * ``MAGNET``
Magnetic, Forcefield depends on the speed of the particles.

  * ``HARMONIC``
Harmonic, The source of this force field is the zero point of a harmonic oscillator.

  * ``CHARGE``
Charge, Spherical forcefield based on the charge of particles, only influences other charge force fields.

  * ``LENNARDJ``
Lennard-Jones, Forcefield based on the Lennard-Jones potential.

  * ``TEXTURE``
Texture, Force field based on a texture.

  * ``GUIDE``
Curve Guide, Create a force along a curve object.

  * ``BOID``
Boid, Create a force that acts as a boid's predators or target.

  * ``TURBULENCE``
Turbulence, Create turbulence with a noise field.

  * ``DRAG``
Drag, Create a force that dampens motion.

  * ``FLUID_FLOW``
Fluid Flow, Create a force based on fluid simulation velocities.

  """

  use_2d_force: bool = ...

  """

  Apply force only in 2D

  """

  use_absorption: bool = ...

  """

  Force gets absorbed by collision objects

  """

  use_global_coords: bool = ...

  """

  Use effector/global coordinates for turbulence

  """

  use_gravity_falloff: bool = ...

  """

  Multiply force by 1/distance²

  """

  use_guide_path_add: bool = ...

  """

  Based on distance/falloff it adds a portion of the entire path

  """

  use_guide_path_weight: bool = ...

  """

  Use curve weights to influence the particle influence along the curve

  """

  use_max_distance: bool = ...

  """

  Use a maximum distance for the field to work

  """

  use_min_distance: bool = ...

  """

  Use a minimum distance for the field's fall-off

  """

  use_multiple_springs: bool = ...

  """

  Every point is effected by multiple springs

  """

  use_object_coords: bool = ...

  """

  Use object/global coordinates for texture

  """

  use_radial_max: bool = ...

  """

  Use a maximum radial distance for the field to work

  """

  use_radial_min: bool = ...

  """

  Use a minimum radial distance for the field's fall-off

  """

  use_root_coords: bool = ...

  """

  Texture coordinates from root particle locations

  """

  use_smoke_density: bool = ...

  """

  Adjust force strength based on smoke density

  """

  wind_factor: float = ...

  """

  How much the force is reduced when acting parallel to a surface, e.g. cloth

  """

  z_direction: str = ...

  """

  Effect in full or only positive/negative Z direction

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FileBrowserFSMenuEntry(bpy_struct):

  """

  File Select Parameters

  """

  icon: int = ...

  is_valid: bool = ...

  """

  Whether this path is currently reachable

  """

  name: str = ...

  path: str = ...

  use_save: bool = ...

  """

  Whether this path is saved in bookmarks, or generated from OS

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FileSelectIDFilter(bpy_struct):

  """

  Which ID types to show/hide, when browsing a library

  """

  category_animation: bool = ...

  """

  Show animation data

  """

  category_environment: bool = ...

  """

  Show worlds, lights, cameras and speakers

  """

  category_geometry: bool = ...

  """

  Show meshes, curves, lattice, armatures and metaballs data

  """

  category_image: bool = ...

  """

  Show images, movie clips, sounds and masks

  """

  category_misc: bool = ...

  """

  Show other data types

  """

  category_object: bool = ...

  """

  Show objects and collections

  """

  category_scene: bool = ...

  """

  Show scenes

  """

  category_shading: bool = ...

  """

  Show materials, nodetrees, textures and Freestyle's linestyles

  """

  filter_action: bool = ...

  """

  Show Action data-blocks

  """

  filter_armature: bool = ...

  """

  Show Armature data-blocks

  """

  filter_brush: bool = ...

  """

  Show Brushes data-blocks

  """

  filter_cachefile: bool = ...

  """

  Show Cache File data-blocks

  """

  filter_camera: bool = ...

  """

  Show Camera data-blocks

  """

  filter_curve: bool = ...

  """

  Show Curve data-blocks

  """

  filter_font: bool = ...

  """

  Show Font data-blocks

  """

  filter_grease_pencil: bool = ...

  """

  Show Grease pencil data-blocks

  """

  filter_group: bool = ...

  """

  Show Collection data-blocks

  """

  filter_hair: bool = ...

  """

  Show/hide Hair data-blocks

  """

  filter_image: bool = ...

  """

  Show Image data-blocks

  """

  filter_lattice: bool = ...

  """

  Show Lattice data-blocks

  """

  filter_light: bool = ...

  """

  Show Light data-blocks

  """

  filter_light_probe: bool = ...

  """

  Show Light Probe data-blocks

  """

  filter_linestyle: bool = ...

  """

  Show Freestyle's Line Style data-blocks

  """

  filter_mask: bool = ...

  """

  Show Mask data-blocks

  """

  filter_material: bool = ...

  """

  Show Material data-blocks

  """

  filter_mesh: bool = ...

  """

  Show Mesh data-blocks

  """

  filter_metaball: bool = ...

  """

  Show Metaball data-blocks

  """

  filter_movie_clip: bool = ...

  """

  Show Movie Clip data-blocks

  """

  filter_node_tree: bool = ...

  """

  Show Node Tree data-blocks

  """

  filter_object: bool = ...

  """

  Show Object data-blocks

  """

  filter_paint_curve: bool = ...

  """

  Show Paint Curve data-blocks

  """

  filter_palette: bool = ...

  """

  Show Palette data-blocks

  """

  filter_particle_settings: bool = ...

  """

  Show Particle Settings data-blocks

  """

  filter_pointcloud: bool = ...

  """

  Show/hide Point Cloud data-blocks

  """

  filter_scene: bool = ...

  """

  Show Scene data-blocks

  """

  filter_simulation: bool = ...

  """

  Show Simulation data-blocks

  """

  filter_sound: bool = ...

  """

  Show Sound data-blocks

  """

  filter_speaker: bool = ...

  """

  Show Speaker data-blocks

  """

  filter_text: bool = ...

  """

  Show Text data-blocks

  """

  filter_texture: bool = ...

  """

  Show Texture data-blocks

  """

  filter_volume: bool = ...

  """

  Show/hide Volume data-blocks

  """

  filter_work_space: bool = ...

  """

  Show workspace data-blocks

  """

  filter_world: bool = ...

  """

  Show World data-blocks

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FileSelectParams(bpy_struct):

  """

  File Select Parameters

  """

  directory: str = ...

  """

  Directory displayed in the file browser

  """

  display_size: str = ...

  """

  Change the size of the display (width of columns or thumbnails size)

  """

  display_type: str = ...

  """

  Display mode for the file list

  * ``LIST_VERTICAL``
Vertical List, Display files as a vertical list.

  * ``LIST_HORIZONTAL``
Horizontal List, Display files as a horizontal list.

  * ``THUMBNAIL``
Thumbnails, Display files as thumbnails.

  """

  filename: str = ...

  """

  Active file in the file browser

  """

  filter_glob: str = ...

  """

  UNIX shell-like filename patterns matching, supports wildcards ('*') and list of patterns separated by ';'

  """

  filter_id: FileSelectIDFilter = ...

  """

  Which ID types to show/hide, when browsing a library

  """

  filter_search: str = ...

  """

  Filter by name, supports '*' wildcard

  """

  recursion_level: str = ...

  """

  Numbers of dirtree levels to show simultaneously

  * ``NONE``
None, Only list current directory's content, with no recursion.

  * ``BLEND``
Blend File, List .blend files' content.

  * ``ALL_1``
One Level, List all sub-directories' content, one level of recursion.

  * ``ALL_2``
Two Levels, List all sub-directories' content, two levels of recursion.

  * ``ALL_3``
Three Levels, List all sub-directories' content, three levels of recursion.

  """

  show_details_datetime: bool = ...

  """

  Draw a column listing the date and time of modification for each file

  """

  show_details_size: bool = ...

  """

  Draw a column listing the size of each file

  """

  show_hidden: bool = ...

  """

  Show hidden dot files

  """

  sort_method: str = ...

  """

  * ``FILE_SORT_ALPHA``
Name, Sort the file list alphabetically.

  * ``FILE_SORT_EXTENSION``
Extension, Sort the file list by extension/type.

  * ``FILE_SORT_TIME``
Modified Date, Sort files by modification time.

  * ``FILE_SORT_SIZE``
Size, Sort files by size.

  """

  title: str = ...

  """

  Title for the file browser

  """

  use_filter: bool = ...

  """

  Enable filtering of files

  """

  use_filter_backup: bool = ...

  """

  Show .blend1, .blend2, etc. files

  """

  use_filter_blender: bool = ...

  """

  Show .blend files

  """

  use_filter_blendid: bool = ...

  """

  Show .blend files items (objects, materials, etc.)

  """

  use_filter_folder: bool = ...

  """

  Show folders

  """

  use_filter_font: bool = ...

  """

  Show font files

  """

  use_filter_image: bool = ...

  """

  Show image files

  """

  use_filter_movie: bool = ...

  """

  Show movie files

  """

  use_filter_script: bool = ...

  """

  Show script files

  """

  use_filter_sound: bool = ...

  """

  Show sound files

  """

  use_filter_text: bool = ...

  """

  Show text files

  """

  use_filter_volume: bool = ...

  """

  Show 3D volume files

  """

  use_library_browsing: bool = ...

  """

  Whether we may browse blender files' content or not

  """

  use_sort_invert: bool = ...

  """

  Sort items descending, from highest value to lowest

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FloatAttributeValue(bpy_struct):

  """

  Floating point value in geometry attribute

  """

  value: float = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FloatColorAttributeValue(bpy_struct):

  """

  Color value in geometry attribute

  """

  color: typing.Tuple[float, float, float, float] = ...

  """

  RGBA color in scene linear color space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FloatVectorAttributeValue(bpy_struct):

  """

  Vector value in geometry attribute

  """

  vector: typing.Tuple[float, float, float] = ...

  """

  3D vector

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FluidDomainSettings(bpy_struct):

  """

  Fluid domain settings

  """

  adapt_margin: int = ...

  """

  Margin added around fluid to minimize boundary interference

  """

  adapt_threshold: float = ...

  """

  Minimum amount of fluid a cell can contain before it is considered empty

  """

  additional_res: int = ...

  """

  Maximum number of additional cells

  """

  alpha: float = ...

  """

  Buoyant force based on smoke density (higher value results in faster rising smoke)

  """

  beta: float = ...

  """

  Buoyant force based on smoke heat (higher value results in faster rising smoke)

  """

  burning_rate: float = ...

  """

  Speed of the burning reaction (higher value results in smaller flames)

  """

  cache_data_format: str = ...

  """

  Select the file format to be used for caching volumetric data

  """

  cache_directory: str = ...

  """

  Directory that contains fluid cache files

  """

  cache_frame_end: int = ...

  """

  Frame on which the simulation stops. This is the last frame that will be baked

  """

  cache_frame_offset: int = ...

  """

  Frame offset that is used when loading the simulation from the cache. It is not considered when baking the simulation, only when loading it

  """

  cache_frame_pause_data: int = ...

  cache_frame_pause_guide: int = ...

  cache_frame_pause_mesh: int = ...

  cache_frame_pause_noise: int = ...

  cache_frame_pause_particles: int = ...

  cache_frame_start: int = ...

  """

  Frame on which the simulation starts. This is the first frame that will be baked

  """

  cache_mesh_format: str = ...

  """

  Select the file format to be used for caching surface data

  """

  cache_noise_format: str = ...

  """

  Select the file format to be used for caching noise data

  """

  cache_particle_format: str = ...

  """

  Select the file format to be used for caching particle data

  """

  cache_resumable: bool = ...

  """

  Additional data will be saved so that the bake jobs can be resumed after pausing. Because more data will be written to disk it is recommended to avoid enabling this option when baking at high resolutions

  """

  cache_type: str = ...

  """

  Change the cache type of the simulation

  * ``REPLAY``
Replay, Use the timeline to bake the scene.

  * ``MODULAR``
Modular, Bake every stage of the simulation separately.

  * ``ALL``
All, Bake all simulation settings at once.

  """

  cell_size: typing.Tuple[float, float, float] = ...

  """

  Cell Size

  """

  cfl_condition: float = ...

  """

  Maximal velocity per cell (higher value results in greater timesteps)

  """

  clipping: float = ...

  """

  Value under which voxels are considered empty space to optimize rendering

  """

  color_grid: typing.Tuple[float, ...] = ...

  """

  Smoke color grid

  """

  color_ramp: ColorRamp = ...

  color_ramp_field: str = ...

  """

  Simulation field to color map

  """

  color_ramp_field_scale: float = ...

  """

  Multiplier for scaling the selected field to color map

  """

  delete_in_obstacle: bool = ...

  """

  Delete fluid inside obstacles

  """

  density_grid: typing.Tuple[float, ...] = ...

  """

  Smoke density grid

  """

  display_interpolation: str = ...

  """

  Interpolation method to use for smoke/fire volumes in solid mode

  * ``LINEAR``
Linear, Good smoothness and speed.

  * ``CUBIC``
Cubic, Smoothed high quality interpolation, but slower.

  * ``CLOSEST``
Closest, No interpolation.

  """

  display_thickness: float = ...

  """

  Thickness of smoke drawing in the viewport

  """

  dissolve_speed: int = ...

  """

  Determine how quickly the smoke dissolves (lower value makes smoke disappear faster)

  """

  domain_resolution: typing.Tuple[int, int, int] = ...

  """

  Smoke Grid Resolution

  """

  domain_type: str = ...

  """

  Change domain type of the simulation

  * ``GAS``
Gas, Create domain for gases.

  * ``LIQUID``
Liquid, Create domain for liquids.

  """

  effector_group: Collection = ...

  """

  Limit effectors to this collection

  """

  effector_weights: EffectorWeights = ...

  export_manta_script: bool = ...

  """

  Generate and export Mantaflow script from current domain settings during bake. This is only needed if you plan to analyze the cache (e.g. view grids, velocity vectors, particles) in Mantaflow directly (outside of Blender) after baking the simulation

  """

  flame_grid: typing.Tuple[float, ...] = ...

  """

  Smoke flame grid

  """

  flame_ignition: float = ...

  """

  Minimum temperature of the flames (higher value results in faster rising flames)

  """

  flame_max_temp: float = ...

  """

  Maximum temperature of the flames (higher value results in faster rising flames)

  """

  flame_smoke: float = ...

  """

  Amount of smoke created by burning fuel

  """

  flame_smoke_color: typing.Tuple[float, float, float] = ...

  """

  Color of smoke emitted from burning fuel

  """

  flame_vorticity: float = ...

  """

  Additional vorticity for the flames

  """

  flip_ratio: float = ...

  """

  PIC/FLIP Ratio. A value of 1.0 will result in a completely FLIP based simulation. Use a lower value for simulations which should produce smaller splashes

  """

  fluid_group: Collection = ...

  """

  Limit fluid objects to this collection

  """

  force_collection: Collection = ...

  """

  Limit forces to this collection

  """

  fractions_distance: float = ...

  """

  Determines how far apart fluid and obstacle are (higher values will result in fluid being further away from obstacles, smaller values will let fluid move towards the inside of obstacles)

  """

  fractions_threshold: float = ...

  """

  Determines how much fluid is allowed in an obstacle cell (higher values will tag a boundary cell as an obstacle easier and reduce the boundary smoothening effect)

  """

  gravity: typing.Tuple[float, float, float] = ...

  """

  Gravity in X, Y and Z direction

  """

  gridlines_cell_filter: str = ...

  """

  Cell type to be highlighted

  * ``NONE``
None, Highlight the cells regardless of their type.

  * ``FLUID``
Fluid, Highlight only the cells of type Fluid.

  * ``OBSTACLE``
Obstacle, Highlight only the cells of type Obstacle.

  * ``EMPTY``
Empty, Highlight only the cells of type Empty.

  * ``INFLOW``
Inflow, Highlight only the cells of type Inflow.

  * ``OUTFLOW``
Outflow, Highlight only the cells of type Outflow.

  """

  gridlines_color_field: str = ...

  """

  Simulation field to color map onto gridlines

  * ``NONE``
None, None.

  * ``FLAGS``
Flags, Flag grid of the fluid domain.

  * ``RANGE``
Highlight Range, Highlight the voxels with values of the color mapped field within the range.

  """

  gridlines_lower_bound: float = ...

  """

  Lower bound of the highlighting range

  """

  gridlines_range_color: typing.Tuple[float, float, float, float] = ...

  """

  Color used to highlight the range

  """

  gridlines_upper_bound: float = ...

  """

  Upper bound of the highlighting range

  """

  guide_alpha: float = ...

  """

  Guiding weight (higher value results in greater lag)

  """

  guide_beta: int = ...

  """

  Guiding size (higher value results in larger vortices)

  """

  guide_parent: Object = ...

  """

  Use velocities from this object for the guiding effect (object needs to have fluid modifier and be of type domain))

  """

  guide_source: str = ...

  """

  Choose where to get guiding velocities from

  * ``DOMAIN``
Domain, Use a fluid domain for guiding (domain needs to be baked already so that velocities can be extracted). Guiding domain can be of any type (i.e. gas or liquid).

  * ``EFFECTOR``
Effector, Use guiding (effector) objects to create fluid guiding (guiding objects should be animated and baked once set up completely).

  """

  guide_vel_factor: float = ...

  """

  Guiding velocity factor (higher value results in greater guiding velocities)

  """

  has_cache_baked_any: bool = ...

  has_cache_baked_data: bool = ...

  has_cache_baked_guide: bool = ...

  has_cache_baked_mesh: bool = ...

  has_cache_baked_noise: bool = ...

  has_cache_baked_particles: bool = ...

  heat_grid: typing.Tuple[float, ...] = ...

  """

  Smoke heat grid

  """

  highres_sampling: str = ...

  """

  Method for sampling the high resolution flow

  """

  is_cache_baking_any: bool = ...

  is_cache_baking_data: bool = ...

  is_cache_baking_guide: bool = ...

  is_cache_baking_mesh: bool = ...

  is_cache_baking_noise: bool = ...

  is_cache_baking_particles: bool = ...

  mesh_concave_lower: float = ...

  """

  Lower mesh concavity bound (high values tend to smoothen and fill out concave regions)

  """

  mesh_concave_upper: float = ...

  """

  Upper mesh concavity bound (high values tend to smoothen and fill out concave regions)

  """

  mesh_generator: str = ...

  """

  Which particle level set generator to use

  * ``IMPROVED``
Final, Use improved particle level set (slower but more precise and with mesh smoothening options).

  * ``UNION``
Preview, Use union particle level set (faster but lower quality).

  """

  mesh_particle_radius: float = ...

  """

  Particle radius factor (higher value results in larger (meshed) particles). Needs to be adjusted after changing the mesh scale

  """

  mesh_scale: int = ...

  """

  The mesh simulation is scaled up by this factor (compared to the base resolution of the domain). For best meshing, it is recommended to adjust the mesh particle radius alongside this value

  """

  mesh_smoothen_neg: int = ...

  """

  Negative mesh smoothening

  """

  mesh_smoothen_pos: int = ...

  """

  Positive mesh smoothening

  """

  mesh_vertices: typing.Union[typing.Sequence[FluidDomainVertexVelocity], typing.Mapping[str, FluidDomainVertexVelocity], bpy_prop_collection] = ...

  """

  Vertices of the fluid mesh generated by simulation

  """

  noise_pos_scale: float = ...

  """

  Scale of noise (higher value results in larger vortices)

  """

  noise_scale: int = ...

  """

  The noise simulation is scaled up by this factor (compared to the base resolution of the domain)

  """

  noise_strength: float = ...

  """

  Strength of noise

  """

  noise_time_anim: float = ...

  """

  Animation time of noise

  """

  noise_type: str = ...

  """

  Noise method which is used during the high-res simulation

  """

  openvdb_cache_compress_type: str = ...

  """

  Compression method to be used

  * ``ZIP``
Zip, Effective but slow compression.

  * ``BLOSC``
Blosc, Multithreaded compression, similar in size and quality as 'Zip'.

  * ``NONE``
None, Do not use any compression.

  """

  openvdb_data_depth: str = ...

  """

  Bit depth for fluid particles and grids (lower bit values reduce file size)

  """

  particle_band_width: float = ...

  """

  Particle (narrow) band width (higher value results in thicker band and more particles)

  """

  particle_max: int = ...

  """

  Maximum number of particles per cell (ensures that each cell has at most this amount of particles)

  """

  particle_min: int = ...

  """

  Minimum number of particles per cell (ensures that each cell has at least this amount of particles)

  """

  particle_number: int = ...

  """

  Particle number factor (higher value results in more particles)

  """

  particle_radius: float = ...

  """

  Particle radius factor. Increase this value if the simulation appears to leak volume, decrease it if the simulation seems to gain volume

  """

  particle_randomness: float = ...

  """

  Randomness factor for particle sampling

  """

  particle_scale: int = ...

  """

  The particle simulation is scaled up by this factor (compared to the base resolution of the domain)

  """

  resolution_max: int = ...

  """

  Resolution used for the fluid domain. Value corresponds to the longest domain side (resolution for other domain sides is calculated automatically)

  """

  show_gridlines: bool = ...

  """

  Show gridlines

  """

  show_velocity: bool = ...

  """

  Visualize vector fields

  """

  simulation_method: str = ...

  """

  Change the underlying simulation method

  * ``FLIP``
FLIP, Use FLIP as the simulation method.

  """

  slice_axis: str = ...

  """

  * ``AUTO``
Auto, Adjust slice direction according to the view direction.

  * ``X``
X, Slice along the X axis.

  * ``Y``
Y, Slice along the Y axis.

  * ``Z``
Z, Slice along the Z axis.

  """

  slice_depth: float = ...

  """

  Position of the slice

  """

  slice_per_voxel: float = ...

  """

  How many slices per voxel should be generated

  """

  sndparticle_boundary: str = ...

  """

  How particles that left the domain are treated

  * ``DELETE``
Delete, Delete secondary particles that are inside obstacles or left the domain.

  * ``PUSHOUT``
Push Out, Push secondary particles that left the domain back into the domain.

  """

  sndparticle_bubble_buoyancy: float = ...

  """

  Amount of buoyancy force that rises bubbles (high value results in bubble movement mainly upwards)

  """

  sndparticle_bubble_drag: float = ...

  """

  Amount of drag force that moves bubbles along with the fluid (high value results in bubble movement mainly along with the fluid)

  """

  sndparticle_combined_export: str = ...

  """

  Determines which particle systems are created from secondary particles

  * ``OFF``
Off, Create a separate particle system for every secondary particle type.

  * ``SPRAY_FOAM``
Spray + Foam, Spray and foam particles are saved in the same particle system.

  * ``SPRAY_BUBBLES``
Spray + Bubbles, Spray and bubble particles are saved in the same particle system.

  * ``FOAM_BUBBLES``
Foam + Bubbles, Foam and bubbles particles are saved in the same particle system.

  * ``SPRAY_FOAM_BUBBLES``
Spray + Foam + Bubbles, Create one particle system that contains all three secondary particle types.

  """

  sndparticle_life_max: float = ...

  """

  Highest possible particle lifetime

  """

  sndparticle_life_min: float = ...

  """

  Lowest possible particle lifetime

  """

  sndparticle_potential_max_energy: float = ...

  """

  Upper clamping threshold that indicates the fluid speed where cells no longer emit more particles (higher value results in generally less particles)

  """

  sndparticle_potential_max_trappedair: float = ...

  """

  Upper clamping threshold for marking fluid cells where air is trapped (higher value results in less marked cells)

  """

  sndparticle_potential_max_wavecrest: float = ...

  """

  Upper clamping threshold for marking fluid cells as wave crests (higher value results in less marked cells)

  """

  sndparticle_potential_min_energy: float = ...

  """

  Lower clamping threshold that indicates the fluid speed where cells start to emit particles (lower values result in generally more particles)

  """

  sndparticle_potential_min_trappedair: float = ...

  """

  Lower clamping threshold for marking fluid cells where air is trapped (lower value results in more marked cells)

  """

  sndparticle_potential_min_wavecrest: float = ...

  """

  Lower clamping threshold for marking fluid cells as wave crests (lower value results in more marked cells)

  """

  sndparticle_potential_radius: int = ...

  """

  Radius to compute potential for each cell (higher values are slower but create smoother potential grids)

  """

  sndparticle_sampling_trappedair: int = ...

  """

  Maximum number of particles generated per trapped air cell per frame

  """

  sndparticle_sampling_wavecrest: int = ...

  """

  Maximum number of particles generated per wave crest cell per frame

  """

  sndparticle_update_radius: int = ...

  """

  Radius to compute position update for each particle (higher values are slower but particles move less chaotic)

  """

  start_point: typing.Tuple[float, float, float] = ...

  """

  Start point

  """

  surface_tension: float = ...

  """

  Surface tension of liquid (higher value results in greater hydrophobic behaviour)

  """

  sys_particle_maximum: int = ...

  """

  Maximum number of fluid particles that are allowed in this simulation

  """

  temperature_grid: typing.Tuple[float, ...] = ...

  """

  Smoke temperature grid, range 0..1 represents 0..1000K

  """

  time_scale: float = ...

  """

  Adjust simulation speed

  """

  timesteps_max: int = ...

  """

  Maximum number of simulation steps to perform for one frame

  """

  timesteps_min: int = ...

  """

  Minimum number of simulation steps to perform for one frame

  """

  use_adaptive_domain: bool = ...

  """

  Adapt simulation resolution and size to fluid

  """

  use_adaptive_timesteps: bool = ...

  use_bubble_particles: bool = ...

  """

  Create bubble particle system

  """

  use_collision_border_back: bool = ...

  """

  Enable collisions with back domain border

  """

  use_collision_border_bottom: bool = ...

  """

  Enable collisions with bottom domain border

  """

  use_collision_border_front: bool = ...

  """

  Enable collisions with front domain border

  """

  use_collision_border_left: bool = ...

  """

  Enable collisions with left domain border

  """

  use_collision_border_right: bool = ...

  """

  Enable collisions with right domain border

  """

  use_collision_border_top: bool = ...

  """

  Enable collisions with top domain border

  """

  use_color_ramp: bool = ...

  """

  Render a simulation field while mapping its voxels values to the colors of a ramp or using a predefined color code

  """

  use_diffusion: bool = ...

  """

  Enable fluid diffusion settings (e.g. viscosity, surface tension)

  """

  use_dissolve_smoke: bool = ...

  """

  Let smoke disappear over time

  """

  use_dissolve_smoke_log: bool = ...

  """

  Dissolve smoke in a logarithmic fashion. Dissolves quickly at first, but lingers longer

  """

  use_flip_particles: bool = ...

  """

  Create liquid particle system

  """

  use_foam_particles: bool = ...

  """

  Create foam particle system

  """

  use_fractions: bool = ...

  """

  Fractional obstacles improve and smoothen the fluid-obstacle boundary

  """

  use_guide: bool = ...

  """

  Enable fluid guiding

  """

  use_mesh: bool = ...

  """

  Enable fluid mesh (using amplification)

  """

  use_noise: bool = ...

  """

  Enable fluid noise (using amplification)

  """

  use_slice: bool = ...

  """

  Perform a single slice of the domain object

  """

  use_speed_vectors: bool = ...

  """

  Caches velocities of mesh vertices. These will be used (automatically) when rendering with motion blur enabled

  """

  use_spray_particles: bool = ...

  """

  Create spray particle system

  """

  use_tracer_particles: bool = ...

  """

  Create tracer particle system

  """

  vector_display_type: str = ...

  """

  * ``NEEDLE``
Needle, Display vectors as needles.

  * ``STREAMLINE``
Streamlines, Display vectors as streamlines.

  * ``MAC``
MAC Grid, Display vector field as MAC grid.

  """

  vector_field: str = ...

  """

  Vector field to be represented by the display vectors

  * ``FLUID_VELOCITY``
Fluid Velocity, Velocity field of the fluid domain.

  * ``GUIDE_VELOCITY``
Guide Velocity, Guide velocity field of the fluid domain.

  * ``FORCE``
Force, Force field of the fluid domain.

  """

  vector_scale: float = ...

  """

  Multiplier for scaling the vectors

  """

  vector_scale_with_magnitude: bool = ...

  """

  Scale vectors with their magnitudes

  """

  vector_show_mac_x: bool = ...

  """

  Show X-component of MAC Grid

  """

  vector_show_mac_y: bool = ...

  """

  Show Y-component of MAC Grid

  """

  vector_show_mac_z: bool = ...

  """

  Show Z-component of MAC Grid

  """

  velocity_grid: typing.Tuple[float, ...] = ...

  """

  Smoke velocity grid

  """

  viscosity_base: float = ...

  """

  Viscosity setting: value that is multiplied by 10 to the power of (exponent*-1)

  """

  viscosity_exponent: int = ...

  """

  Negative exponent for the viscosity value (to simplify entering small values e.g. 5*10^-6)

  """

  vorticity: float = ...

  """

  Amount of turbulence and rotation in smoke

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FluidDomainVertexVelocity(bpy_struct):

  """

  Velocity of a simulated fluid mesh

  """

  velocity: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FluidEffectorSettings(bpy_struct):

  """

  Smoke collision settings

  """

  effector_type: str = ...

  """

  Change type of effector in the simulation

  * ``COLLISION``
Collision, Create collision object.

  * ``GUIDE``
Guide, Create guide object.

  """

  guide_mode: str = ...

  """

  How to create guiding velocities

  * ``MAXIMUM``
Maximize, Compare velocities from previous frame with new velocities from current frame and keep the maximum.

  * ``MINIMUM``
Minimize, Compare velocities from previous frame with new velocities from current frame and keep the minimum.

  * ``OVERRIDE``
Override, Always write new guide velocities for every frame (each frame only contains current velocities from guiding objects).

  * ``AVERAGED``
Averaged, Take average of velocities from previous frame and new velocities from current frame.

  """

  subframes: int = ...

  """

  Number of additional samples to take between frames to improve quality of fast moving effector objects

  """

  surface_distance: float = ...

  """

  Additional distance around mesh surface to consider as effector

  """

  use_effector: bool = ...

  """

  Control when to apply the effector

  """

  use_plane_init: bool = ...

  """

  Treat this object as a planar, unclosed mesh

  """

  velocity_factor: float = ...

  """

  Multiplier of obstacle velocity

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FluidFlowSettings(bpy_struct):

  """

  Fluid flow settings

  """

  density: float = ...

  density_vertex_group: str = ...

  """

  Name of vertex group which determines surface emission rate

  """

  flow_behavior: str = ...

  """

  Change flow behavior in the simulation

  * ``INFLOW``
Inflow, Add fluid to simulation.

  * ``OUTFLOW``
Outflow, Delete fluid from simulation.

  * ``GEOMETRY``
Geometry, Only use given geometry for fluid.

  """

  flow_source: str = ...

  """

  Change how fluid is emitted

  """

  flow_type: str = ...

  """

  Change type of fluid in the simulation

  * ``SMOKE``
Smoke, Add smoke.

  * ``BOTH``
Fire + Smoke, Add fire and smoke.

  * ``FIRE``
Fire, Add fire.

  * ``LIQUID``
Liquid, Add liquid.

  """

  fuel_amount: float = ...

  noise_texture: Texture = ...

  """

  Texture that controls emission strength

  """

  particle_size: float = ...

  """

  Particle size in simulation cells

  """

  particle_system: ParticleSystem = ...

  """

  Particle systems emitted from the object

  """

  smoke_color: typing.Tuple[float, float, float] = ...

  """

  Color of smoke

  """

  subframes: int = ...

  """

  Number of additional samples to take between frames to improve quality of fast moving flows

  """

  surface_distance: float = ...

  """

  Controls fluid emission from the mesh surface (higher value results in emission further away from the mesh surface

  """

  temperature: float = ...

  """

  Temperature difference to ambient temperature

  """

  texture_map_type: str = ...

  """

  Texture mapping type

  * ``AUTO``
Generated, Generated coordinates centered to flow object.

  * ``UV``
UV, Use UV layer for texture coordinates.

  """

  texture_offset: float = ...

  """

  Z-offset of texture mapping

  """

  texture_size: float = ...

  """

  Size of texture mapping

  """

  use_absolute: bool = ...

  """

  Only allow given density value in emitter area and will not add up

  """

  use_inflow: bool = ...

  """

  Control when to apply fluid flow

  """

  use_initial_velocity: bool = ...

  """

  Fluid has some initial velocity when it is emitted

  """

  use_particle_size: bool = ...

  """

  Set particle size in simulation cells or use nearest cell

  """

  use_plane_init: bool = ...

  """

  Treat this object as a planar and unclosed mesh. Fluid will only be emitted from the mesh surface and based on the surface emission value

  """

  use_texture: bool = ...

  """

  Use a texture to control emission strength

  """

  uv_layer: str = ...

  """

  UV map name

  """

  velocity_coord: typing.Tuple[float, float, float] = ...

  """

  Additional initial velocity in X, Y and Z direction (added to source velocity)

  """

  velocity_factor: float = ...

  """

  Multiplier of source velocity passed to fluid (source velocity is non-zero only if object is moving)

  """

  velocity_normal: float = ...

  """

  Amount of normal directional velocity

  """

  velocity_random: float = ...

  """

  Amount of random velocity

  """

  volume_density: float = ...

  """

  Controls fluid emission from within the mesh (higher value results in greater emissions from inside the mesh)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FreestyleLineSet(bpy_struct):

  """

  Line set for associating lines and style parameters

  """

  collection: Collection = ...

  """

  A collection of objects based on which feature edges are selected

  """

  collection_negation: str = ...

  """

  Specify either inclusion or exclusion of feature edges belonging to a collection of objects

  * ``INCLUSIVE``
Inclusive, Select feature edges belonging to some object in the group.

  * ``EXCLUSIVE``
Exclusive, Select feature edges not belonging to any object in the group.

  """

  edge_type_combination: str = ...

  """

  Specify a logical combination of selection conditions on feature edge types

  * ``OR``
Logical OR, Select feature edges satisfying at least one of edge type conditions.

  * ``AND``
Logical AND, Select feature edges satisfying all edge type conditions.

  """

  edge_type_negation: str = ...

  """

  Specify either inclusion or exclusion of feature edges selected by edge types

  * ``INCLUSIVE``
Inclusive, Select feature edges satisfying the given edge type conditions.

  * ``EXCLUSIVE``
Exclusive, Select feature edges not satisfying the given edge type conditions.

  """

  exclude_border: bool = ...

  """

  Exclude border edges

  """

  exclude_contour: bool = ...

  """

  Exclude contours

  """

  exclude_crease: bool = ...

  """

  Exclude crease edges

  """

  exclude_edge_mark: bool = ...

  """

  Exclude edge marks

  """

  exclude_external_contour: bool = ...

  """

  Exclude external contours

  """

  exclude_material_boundary: bool = ...

  """

  Exclude edges at material boundaries

  """

  exclude_ridge_valley: bool = ...

  """

  Exclude ridges and valleys

  """

  exclude_silhouette: bool = ...

  """

  Exclude silhouette edges

  """

  exclude_suggestive_contour: bool = ...

  """

  Exclude suggestive contours

  """

  face_mark_condition: str = ...

  """

  Specify a feature edge selection condition based on face marks

  * ``ONE``
One Face, Select a feature edge if either of its adjacent faces is marked.

  * ``BOTH``
Both Faces, Select a feature edge if both of its adjacent faces are marked.

  """

  face_mark_negation: str = ...

  """

  Specify either inclusion or exclusion of feature edges selected by face marks

  * ``INCLUSIVE``
Inclusive, Select feature edges satisfying the given face mark conditions.

  * ``EXCLUSIVE``
Exclusive, Select feature edges not satisfying the given face mark conditions.

  """

  linestyle: FreestyleLineStyle = ...

  """

  Line style settings

  """

  name: str = ...

  """

  Line set name

  """

  qi_end: int = ...

  """

  Last QI value of the QI range

  """

  qi_start: int = ...

  """

  First QI value of the QI range

  """

  select_border: bool = ...

  """

  Select border edges (open mesh edges)

  """

  select_by_collection: bool = ...

  """

  Select feature edges based on a collection of objects

  """

  select_by_edge_types: bool = ...

  """

  Select feature edges based on edge types

  """

  select_by_face_marks: bool = ...

  """

  Select feature edges by face marks

  """

  select_by_image_border: bool = ...

  """

  Select feature edges by image border (less memory consumption)

  """

  select_by_visibility: bool = ...

  """

  Select feature edges based on visibility

  """

  select_contour: bool = ...

  """

  Select contours (outer silhouettes of each object)

  """

  select_crease: bool = ...

  """

  Select crease edges (those between two faces making an angle smaller than the Crease Angle)

  """

  select_edge_mark: bool = ...

  """

  Select edge marks (edges annotated by Freestyle edge marks)

  """

  select_external_contour: bool = ...

  """

  Select external contours (outer silhouettes of occluding and occluded objects)

  """

  select_material_boundary: bool = ...

  """

  Select edges at material boundaries

  """

  select_ridge_valley: bool = ...

  """

  Select ridges and valleys (boundary lines between convex and concave areas of surface)

  """

  select_silhouette: bool = ...

  """

  Select silhouettes (edges at the boundary of visible and hidden faces)

  """

  select_suggestive_contour: bool = ...

  """

  Select suggestive contours (almost silhouette/contour edges)

  """

  show_render: bool = ...

  """

  Enable or disable this line set during stroke rendering

  """

  visibility: str = ...

  """

  Determine how to use visibility for feature edge selection

  * ``VISIBLE``
Visible, Select visible feature edges.

  * ``HIDDEN``
Hidden, Select hidden feature edges.

  * ``RANGE``
QI Range, Select feature edges within a range of quantitative invisibility (QI) values.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FreestyleModuleSettings(bpy_struct):

  """

  Style module configuration for specifying a style module

  """

  script: Text = ...

  """

  Python script to define a style module

  """

  use: bool = ...

  """

  Enable or disable this style module during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FreestyleModules(bpy_struct):

  """

  A list of style modules (to be applied from top to bottom)

  """

  def new(self) -> FreestyleModuleSettings:

    """

    Add a style module to scene render layer Freestyle settings

    """

    ...

  def remove(self, module: FreestyleModuleSettings) -> None:

    """

    Remove a style module from scene render layer Freestyle settings

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FreestyleSettings(bpy_struct):

  """

  Freestyle settings for a ViewLayer data-block

  """

  as_render_pass: bool = ...

  """

  Renders Freestyle output to a separate pass instead of overlaying it on the Combined pass

  """

  crease_angle: float = ...

  """

  Angular threshold for detecting crease edges

  """

  kr_derivative_epsilon: float = ...

  """

  Kr derivative epsilon for computing suggestive contours

  """

  linesets: typing.Union[Linesets, typing.Sequence[FreestyleLineSet], typing.Mapping[str, FreestyleLineSet], bpy_prop_collection] = ...

  mode: str = ...

  """

  Select the Freestyle control mode

  * ``SCRIPT``
Python Scripting Mode, Advanced mode for using style modules written in Python.

  * ``EDITOR``
Parameter Editor Mode, Basic mode for interactive style parameter editing.

  """

  modules: typing.Union[FreestyleModules, typing.Sequence[FreestyleModuleSettings], typing.Mapping[str, FreestyleModuleSettings], bpy_prop_collection] = ...

  """

  A list of style modules (to be applied from top to bottom)

  """

  sphere_radius: float = ...

  """

  Sphere radius for computing curvatures

  """

  use_advanced_options: bool = ...

  """

  Enable advanced edge detection options (sphere radius and Kr derivative epsilon)

  """

  use_culling: bool = ...

  """

  If enabled, out-of-view edges are ignored

  """

  use_material_boundaries: bool = ...

  """

  Enable material boundaries

  """

  use_ridges_and_valleys: bool = ...

  """

  Enable ridges and valleys

  """

  use_smoothness: bool = ...

  """

  Take face smoothness into account in view map calculation

  """

  use_suggestive_contours: bool = ...

  """

  Enable suggestive contours

  """

  use_view_map_cache: bool = ...

  """

  Keep the computed view map and avoid recalculating it if mesh geometry is unchanged

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Function(bpy_struct):

  """

  RNA function definition

  """

  description: str = ...

  """

  Description of the Function's purpose

  """

  identifier: str = ...

  """

  Unique name used in the code and scripting

  """

  is_registered: bool = ...

  """

  Function is registered as callback as part of type registration

  """

  is_registered_optional: bool = ...

  """

  Function is optionally registered as callback part of type registration

  """

  parameters: typing.Union[typing.Sequence[Property], typing.Mapping[str, Property], bpy_prop_collection] = ...

  """

  Parameters for the function

  """

  use_self: bool = ...

  """

  Function does not pass its self as an argument (becomes a static method in python)

  """

  use_self_type: bool = ...

  """

  Function passes its self type as an argument (becomes a class method in python if use_self is false)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilFrame(bpy_struct):

  """

  Collection of related sketches on a particular frame

  """

  frame_number: int = ...

  """

  The frame on which this sketch appears

  """

  is_edited: bool = ...

  """

  Frame is being edited (painted on)

  """

  keyframe_type: str = ...

  """

  Type of keyframe

  * ``KEYFRAME``
Keyframe, Normal keyframe - e.g. for key poses.

  * ``BREAKDOWN``
Breakdown, A breakdown pose - e.g. for transitions between key poses.

  * ``MOVING_HOLD``
Moving Hold, A keyframe that is part of a moving hold.

  * ``EXTREME``
Extreme, An 'extreme' pose, or some other purpose as needed.

  * ``JITTER``
Jitter, A filler or baked keyframe for keying on ones, or some other purpose as needed.

  """

  select: bool = ...

  """

  Frame is selected for editing in the Dope Sheet

  """

  strokes: typing.Union[GPencilStrokes, typing.Sequence[GPencilStroke], typing.Mapping[str, GPencilStroke], bpy_prop_collection] = ...

  """

  Freehand curves defining the sketch on this frame

  """

  def clear(self) -> None:

    """

    Remove all the grease pencil frame data

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilFrames(bpy_struct):

  """

  Collection of grease pencil frames

  """

  def new(self, frame_number: int, active: bool = False) -> GPencilFrame:

    """

    Add a new grease pencil frame

    """

    ...

  def remove(self, frame: GPencilFrame) -> None:

    """

    Remove a grease pencil frame

    """

    ...

  def copy(self, source: GPencilFrame) -> GPencilFrame:

    """

    Copy a grease pencil frame

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilInterpolateSettings(bpy_struct):

  """

  Settings for Grease Pencil interpolation tools

  """

  amplitude: float = ...

  """

  Amount to boost elastic bounces for 'elastic' easing

  """

  back: float = ...

  """

  Amount of overshoot for 'back' easing

  """

  easing: str = ...

  """

  Which ends of the segment between the preceding and following grease pencil frames easing interpolation is applied to

  * ``AUTO``
Automatic Easing, Easing type is chosen automatically based on what the type of interpolation used (e.g. 'Ease In' for transitional types, and 'Ease Out' for dynamic effects).

  * ``EASE_IN``
Ease In, Only on the end closest to the next keyframe.

  * ``EASE_OUT``
Ease Out, Only on the end closest to the first keyframe.

  * ``EASE_IN_OUT``
Ease In and Out, Segment between both keyframes.

  """

  interpolate_all_layers: bool = ...

  """

  Interpolate all layers, not only active

  """

  interpolate_selected_only: bool = ...

  """

  Interpolate only selected strokes in the original frame

  """

  interpolation_curve: CurveMapping = ...

  """

  Custom curve to control 'sequence' interpolation between Grease Pencil frames

  """

  period: float = ...

  """

  Time between bounces for elastic easing

  """

  step: int = ...

  """

  Number of frames between generated interpolated frames

  """

  type: str = ...

  """

  Interpolation method to use the next time 'Interpolate Sequence' is run

  * ``LINEAR``
Linear, Straight-line interpolation between A and B (i.e. no ease in/out).

  * ``CUSTOM``
Custom, Custom interpolation defined using a curve map.

  * ``SINE``
Sinusoidal, Sinusoidal easing (weakest, almost linear but with a slight curvature).

  * ``QUAD``
Quadratic, Quadratic easing.

  * ``CUBIC``
Cubic, Cubic easing.

  * ``QUART``
Quartic, Quartic easing.

  * ``QUINT``
Quintic, Quintic easing.

  * ``EXPO``
Exponential, Exponential easing (dramatic).

  * ``CIRC``
Circular, Circular easing (strongest and most dynamic).

  * ``BACK``
Back, Cubic easing with overshoot and settle.

  * ``BOUNCE``
Bounce, Exponentially decaying parabolic bounce, like when objects collide.

  * ``ELASTIC``
Elastic, Exponentially decaying sine wave, like an elastic band.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilLayer(bpy_struct):

  """

  Collection of related sketches

  """

  active_frame: GPencilFrame = ...

  """

  Frame currently being displayed for this layer

  """

  annotation_hide: bool = ...

  """

  Set annotation Visibility

  """

  annotation_onion_after_color: typing.Tuple[float, float, float] = ...

  """

  Base color for ghosts after the active frame

  """

  annotation_onion_after_range: int = ...

  """

  Maximum number of frames to show after current frame

  """

  annotation_onion_before_color: typing.Tuple[float, float, float] = ...

  """

  Base color for ghosts before the active frame

  """

  annotation_onion_before_range: int = ...

  """

  Maximum number of frames to show before current frame

  """

  blend_mode: str = ...

  """

  Blend mode

  """

  channel_color: typing.Tuple[float, float, float] = ...

  """

  Custom color for animation channel in Dopesheet

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Color for all strokes in this layer

  """

  frames: typing.Union[GPencilFrames, typing.Sequence[GPencilFrame], typing.Mapping[str, GPencilFrame], bpy_prop_collection] = ...

  """

  Sketches for this layer on different frames

  """

  hide: bool = ...

  """

  Set layer Visibility

  """

  info: str = ...

  """

  Layer name

  """

  is_parented: bool = ...

  """

  True when the layer parent object is set

  """

  is_ruler: bool = ...

  """

  This is a special ruler layer

  """

  line_change: int = ...

  """

  Thickness change to apply to current strokes (in pixels)

  """

  lock: bool = ...

  """

  Protect layer from further editing and/or frame changes

  """

  lock_frame: bool = ...

  """

  Lock current frame displayed by layer

  """

  lock_material: bool = ...

  """

  Avoids editing locked materials in the layer

  """

  mask_layers: typing.Union[GreasePencilMaskLayers, typing.Sequence[GPencilLayerMask], typing.Mapping[str, GPencilLayerMask], bpy_prop_collection] = ...

  """

  List of Masking Layers

  """

  matrix_inverse: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Parent inverse transformation matrix

  """

  opacity: float = ...

  """

  Layer Opacity

  """

  parent: Object = ...

  """

  Parent Object

  """

  parent_bone: str = ...

  """

  Name of parent bone in case of a bone parenting relation

  """

  parent_type: str = ...

  """

  Type of parent relation

  * ``OBJECT``
Object, The layer is parented to an object.

  * ``ARMATURE``
Armature.

  * ``BONE``
Bone, The layer is parented to a bone.

  """

  pass_index: int = ...

  """

  Index number for the "Layer Index" pass

  """

  select: bool = ...

  """

  Layer is selected for editing in the Dope Sheet

  """

  show_in_front: bool = ...

  """

  Make the layer draw in front of objects

  """

  show_points: bool = ...

  """

  Draw the points which make up the strokes (for debugging purposes)

  """

  thickness: int = ...

  """

  Thickness of annotation strokes

  """

  tint_color: typing.Tuple[float, float, float] = ...

  """

  Color for tinting stroke colors

  """

  tint_factor: float = ...

  """

  Factor of tinting color

  """

  use_annotation_onion_skinning: bool = ...

  """

  Display annotation onion skins before and after the current frame

  """

  use_lights: bool = ...

  """

  Enable the use of lights on stroke and fill materials

  """

  use_mask_layer: bool = ...

  """

  Mask pixels from underlying layers drawing

  """

  use_onion_skinning: bool = ...

  """

  Display onion skins before and after the current frame

  """

  use_solo_mode: bool = ...

  """

  In Paint mode display only layers with keyframe in current frame

  """

  vertex_paint_opacity: float = ...

  """

  Vertex Paint mix factor

  """

  viewlayer_render: str = ...

  """

  Only include Layer in this View Layer render output (leave blank to include always)

  """

  def clear(self) -> None:

    """

    Remove all the grease pencil layer data

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilLayerMask(bpy_struct):

  """

  List of Mask Layers

  """

  hide: bool = ...

  """

  Set mask Visibility

  """

  invert: bool = ...

  """

  Invert mask

  """

  name: str = ...

  """

  Mask layer name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilSculptGuide(bpy_struct):

  """

  Guides for drawing

  """

  angle: float = ...

  """

  Direction of lines

  """

  angle_snap: float = ...

  """

  Angle snapping

  """

  location: typing.Tuple[float, float, float] = ...

  """

  Custom reference point for guides

  """

  reference_object: Object = ...

  """

  Object used for reference point

  """

  reference_point: str = ...

  """

  Type of speed guide

  * ``CURSOR``
Cursor, Use cursor as reference point.

  * ``CUSTOM``
Custom, Use custom reference point.

  * ``OBJECT``
Object, Use object as reference point.

  """

  spacing: float = ...

  """

  Guide spacing

  """

  type: str = ...

  """

  Type of speed guide

  * ``CIRCULAR``
Circular, Use single point to create rings.

  * ``RADIAL``
Radial, Use single point as direction.

  * ``PARALLEL``
Parallel, Parallel lines.

  * ``GRID``
Grid, Grid allows horizontal and vertical lines.

  * ``ISO``
Isometric, Grid allows isometric and vertical lines.

  """

  use_guide: bool = ...

  """

  Enable speed guides

  """

  use_snapping: bool = ...

  """

  Enable snapping to guides angle or spacing options

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilSculptSettings(bpy_struct):

  """

  General properties for Grease Pencil stroke sculpting tools

  """

  guide: GPencilSculptGuide = ...

  intersection_threshold: float = ...

  """

  Threshold for stroke intersections

  """

  lock_axis: str = ...

  """

  * ``VIEW``
View, Align strokes to current view plane.

  * ``AXIS_Y``
Front (X-Z), Project strokes to plane locked to Y.

  * ``AXIS_X``
Side (Y-Z), Project strokes to plane locked to X.

  * ``AXIS_Z``
Top (X-Y), Project strokes to plane locked to Z.

  * ``CURSOR``
Cursor, Align strokes to current 3D cursor orientation.

  """

  multiframe_falloff_curve: CurveMapping = ...

  """

  Custom curve to control falloff of brush effect by Grease Pencil frames

  """

  thickness_primitive_curve: CurveMapping = ...

  """

  Custom curve to control primitive thickness

  """

  use_multiframe_falloff: bool = ...

  """

  Use falloff effect when edit in multiframe mode to compute brush effect by frame

  """

  use_scale_thickness: bool = ...

  """

  Scale the stroke thickness when transforming strokes

  """

  use_thickness_curve: bool = ...

  """

  Use curve to define primitive stroke thickness

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilStroke(bpy_struct):

  """

  Freehand curve defining part of a sketch

  """

  aspect: typing.Tuple[float, float] = ...

  bound_box_max: typing.Tuple[float, float, float] = ...

  bound_box_min: typing.Tuple[float, float, float] = ...

  display_mode: str = ...

  """

  Coordinate space that stroke is in

  * ``SCREEN``
Screen, Stroke is in screen-space.

  * ``3DSPACE``
3D Space, Stroke is in 3D-space.

  * ``2DSPACE``
2D Space, Stroke is in 2D-space.

  * ``2DIMAGE``
2D Image, Stroke is in 2D-space (but with special 'image' scaling).

  """

  end_cap_mode: str = ...

  """

  Stroke end extreme cap style

  """

  groups: typing.Union[typing.Sequence[GpencilVertexGroupElement], typing.Mapping[str, GpencilVertexGroupElement], bpy_prop_collection] = ...

  """

  Weights for the vertex groups this vertex is member of

  """

  hardness: float = ...

  """

  Amount of gradient along section of stroke

  """

  is_nofill_stroke: bool = ...

  """

  Special stroke to use as boundary for filling areas

  """

  line_width: int = ...

  """

  Thickness of stroke (in pixels)

  """

  material_index: int = ...

  """

  Index of material used in this stroke

  """

  points: typing.Union[GPencilStrokePoints, typing.Sequence[GPencilStrokePoint], typing.Mapping[str, GPencilStrokePoint], bpy_prop_collection] = ...

  """

  Stroke data points

  """

  select: bool = ...

  """

  Stroke is selected for viewport editing

  """

  start_cap_mode: str = ...

  """

  Stroke start extreme cap style

  """

  triangles: typing.Union[typing.Sequence[GPencilTriangle], typing.Mapping[str, GPencilTriangle], bpy_prop_collection] = ...

  """

  Triangulation data for HQ fill

  """

  use_cyclic: bool = ...

  """

  Enable cyclic drawing, closing the stroke

  """

  uv_rotation: float = ...

  """

  Rotation of the UV

  """

  uv_scale: float = ...

  """

  Scale of the UV

  """

  uv_translation: typing.Tuple[float, float] = ...

  """

  Translation of default UV position

  """

  vertex_color_fill: typing.Tuple[float, float, float, float] = ...

  """

  Color used to mix with fill color to get final color

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilStrokePoint(bpy_struct):

  """

  Data point for freehand stroke curve

  """

  co: typing.Tuple[float, float, float] = ...

  pressure: float = ...

  """

  Pressure of tablet at point when drawing it

  """

  select: bool = ...

  """

  Point is selected for viewport editing

  """

  strength: float = ...

  """

  Color intensity (alpha factor)

  """

  uv_factor: float = ...

  """

  Internal UV factor

  """

  uv_fill: typing.Tuple[float, float] = ...

  """

  Internal UV factor for filling

  """

  uv_rotation: float = ...

  """

  Internal UV factor for dot mode

  """

  vertex_color: typing.Tuple[float, float, float, float] = ...

  """

  Color used to mix with point color to get final color

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilStrokePoints(bpy_struct):

  """

  Collection of grease pencil stroke points

  """

  def add(self, count: int, pressure: float = 1.0, strength: float = 1.0) -> None:

    """

    Add a new grease pencil stroke point

    """

    ...

  def pop(self, index: int = -1) -> None:

    """

    Remove a grease pencil stroke point

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilStrokes(bpy_struct):

  """

  Collection of grease pencil stroke

  """

  def new(self) -> GPencilStroke:

    """

    Add a new grease pencil stroke

    """

    ...

  def remove(self, stroke: GPencilStroke) -> None:

    """

    Remove a grease pencil stroke

    """

    ...

  def close(self, stroke: GPencilStroke) -> None:

    """

    Close a grease pencil stroke adding geometry

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPencilTriangle(bpy_struct):

  """

  Triangulation data for Grease Pencil fills

  """

  v1: int = ...

  """

  First triangle vertex index

  """

  v2: int = ...

  """

  Second triangle vertex index

  """

  v3: int = ...

  """

  Third triangle vertex index

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Gizmo(bpy_struct):

  """

  Collection of gizmos

  """

  alpha: float = ...

  alpha_highlight: float = ...

  bl_idname: str = ...

  color: typing.Tuple[float, float, float] = ...

  color_highlight: typing.Tuple[float, float, float] = ...

  group: GizmoGroup = ...

  """

  Gizmo group this gizmo is a member of

  """

  hide: bool = ...

  hide_keymap: bool = ...

  """

  Ignore the key-map for this gizmo

  """

  hide_select: bool = ...

  is_highlight: bool = ...

  is_modal: bool = ...

  line_width: float = ...

  matrix_basis: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  matrix_offset: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  matrix_space: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  matrix_world: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  properties: GizmoProperties = ...

  scale_basis: float = ...

  select: bool = ...

  select_bias: float = ...

  """

  Depth bias used for selection

  """

  use_draw_hover: bool = ...

  use_draw_modal: bool = ...

  """

  Draw while dragging

  """

  use_draw_offset_scale: bool = ...

  """

  Scale the offset matrix (use to apply screen-space offset)

  """

  use_draw_scale: bool = ...

  """

  Use scale when calculating the matrix

  """

  use_draw_value: bool = ...

  """

  Show an indicator for the current value while dragging

  """

  use_event_handle_all: bool = ...

  """

  When highlighted, do not pass events through to be handled by other keymaps

  """

  use_grab_cursor: bool = ...

  use_operator_tool_properties: bool = ...

  """

  Merge active tool properties on activation (does not overwrite existing)

  """

  use_select_background: bool = ...

  """

  Don't write into the depth buffer

  """

  use_tooltip: bool = ...

  """

  Use tool-tips when hovering over this gizmo

  """

  def draw(self, context: Context) -> None:

    ...

  def draw_select(self, context: Context, select_id: int = 0) -> None:

    ...

  def test_select(self, context: Context, location: typing.Tuple[int, int]) -> int:

    ...

  def modal(self, context: Context, event: Event, tweak: typing.Set[str]) -> typing.Set[str]:

    ...

  def setup(self) -> None:

    ...

  def invoke(self, context: Context, event: Event) -> typing.Set[str]:

    ...

  def exit(self, context: Context, cancel: bool) -> None:

    ...

  def select_refresh(self) -> None:

    ...

  def draw_preset_box(self, matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]], select_id: int = -1) -> None:

    """

    Draw a box

    """

    ...

  def draw_preset_arrow(self, matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]], axis: str = 'POS_Z', select_id: int = -1) -> None:

    """

    Draw a box

    """

    ...

  def draw_preset_circle(self, matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]], axis: str = 'POS_Z', select_id: int = -1) -> None:

    """

    Draw a box

    """

    ...

  def draw_preset_facemap(self, object: Object, face_map: int, select_id: int = -1) -> None:

    """

    Draw the face-map of a mesh object

    """

    ...

  def target_set_prop(self, target: str, data: typing.Any, property: str, index: int = -1) -> None:

    ...

  def target_set_operator(self, operator: str, index: int = 0) -> OperatorProperties:

    """

    Operator to run when activating the gizmo (overrides property targets)

    """

    ...

  def target_is_valid(self, property: str) -> bool:

    ...

  def draw_custom_shape(self, shape: typing.Any) -> None:

    """

    Draw a shape created form :class:`bpy.types.Gizmo.draw_custom_shape`.

    """

    ...

  @staticmethod

  def new_custom_shape(type: str, verts: typing.Sequence[typing.Any]) -> typing.Any:

    """

    Create a new shape that can be passed to :class:`bpy.types.Gizmo.draw_custom_shape`.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def target_get_range(self, target: typing.Any) -> typing.Tuple[typing.Any, ...]:

    """

    Get the range for this target property.

    """

    ...

  def target_get_value(self, target: str) -> typing.Any:

    """

    Get the value of this target property.

    """

    ...

  def target_set_handler(self, target: typing.Any, get: typing.Callable, set: typing.Callable, range: typing.Callable = None) -> None:

    """

    Assigns callbacks to a gizmos property.

    """

    ...

  def target_set_value(self, target: str) -> None:

    """

    Set the value of this target property.

    """

    ...

class GizmoGroup(bpy_struct):

  """

  Storage of an operator being executed, or registered after execution

  """

  bl_idname: str = ...

  bl_label: str = ...

  bl_options: typing.Set[str] = ...

  """

  Options for this operator type

  * ``3D``
3D, Use in 3D viewport.

  * ``SCALE``
Scale, Scale to respect zoom (otherwise zoom independent draw size).

  * ``DEPTH_3D``
Depth 3D, Supports culled depth by other objects in the view.

  * ``SELECT``
Select, Supports selection.

  * ``PERSISTENT``
Persistent.

  * ``SHOW_MODAL_ALL``
Show Modal All, Show all while interacting.

  * ``TOOL_INIT``
Tool Init, Postpone running until tool operator run (when used with a tool).

  * ``VR_REDRAWS``
VR Redraws, The gizmos are made for use with virtual reality sessions and require special redraw management.

  """

  bl_owner_id: str = ...

  bl_region_type: str = ...

  """

  The region where the panel is going to be used in

  """

  bl_space_type: str = ...

  """

  The space where the panel is going to be used in

  * ``EMPTY``
Empty.

  * ``VIEW_3D``
3D Viewport, Manipulate objects in a 3D environment.

  * ``IMAGE_EDITOR``
UV/Image Editor, View and edit images and UV Maps.

  * ``NODE_EDITOR``
Node Editor, Editor for node-based shading and compositing tools.

  * ``SEQUENCE_EDITOR``
Video Sequencer, Video editing tools.

  * ``CLIP_EDITOR``
Movie Clip Editor, Motion tracking tools.

  * ``DOPESHEET_EDITOR``
Dope Sheet, Adjust timing of keyframes.

  * ``GRAPH_EDITOR``
Graph Editor, Edit drivers and keyframe interpolation.

  * ``NLA_EDITOR``
Nonlinear Animation, Combine and layer Actions.

  * ``TEXT_EDITOR``
Text Editor, Edit scripts and in-file documentation.

  * ``CONSOLE``
Python Console, Interactive programmatic console for advanced editing and script development.

  * ``INFO``
Info, Log of operations, warnings and error messages.

  * ``TOPBAR``
Top Bar, Global bar at the top of the screen for global per-window settings.

  * ``STATUSBAR``
Status Bar, Global bar at the bottom of the screen for general status information.

  * ``OUTLINER``
Outliner, Overview of scene graph and all available data-blocks.

  * ``PROPERTIES``
Properties, Edit properties of active object and related data-blocks.

  * ``FILE_BROWSER``
File Browser, Browse for files and assets.

  * ``PREFERENCES``
Preferences, Edit persistent configuration settings.

  """

  gizmos: typing.Union[Gizmos, typing.Sequence[Gizmo], typing.Mapping[str, Gizmo], bpy_prop_collection] = ...

  """

  List of gizmos in the Gizmo Map

  """

  has_reports: bool = ...

  """

  GizmoGroup has a set of reports (warnings and errors) from last execution

  """

  name: str = ...

  @classmethod

  def poll(cls, context: Context) -> bool:

    """

    Test if the gizmo group can be called or not

    """

    ...

  @classmethod

  def setup_keymap(cls, keyconfig: KeyConfig) -> KeyMap:

    """

    Initialize keymaps for this gizmo group, use fallback keymap when not present

    """

    ...

  def setup(self, context: Context) -> None:

    """

    Create gizmos function for the gizmo group

    """

    ...

  def refresh(self, context: Context) -> None:

    """

    Refresh data (called on common state changes such as selection)

    """

    ...

  def draw_prepare(self, context: Context) -> None:

    """

    Run before each redraw

    """

    ...

  def invoke_prepare(self, context: Context, gizmo: Gizmo) -> None:

    """

    Run before invoke

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GizmoGroupProperties(bpy_struct):

  """

  Input properties of a Gizmo Group

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GizmoProperties(bpy_struct):

  """

  Input properties of an Gizmo

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Gizmos(bpy_struct):

  """

  Collection of gizmos

  """

  def new(self, type: str) -> Gizmo:

    """

    Add gizmo

    """

    ...

  def remove(self, gizmo: Gizmo) -> None:

    """

    Delete gizmo

    """

    ...

  def clear(self) -> None:

    """

    Delete all gizmos

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GpencilModifier(bpy_struct):

  """

  Modifier affecting the grease pencil object

  """

  name: str = ...

  """

  Modifier name

  """

  show_expanded: bool = ...

  """

  Set modifier expanded in the user interface

  """

  show_in_editmode: bool = ...

  """

  Display modifier in Edit mode

  """

  show_render: bool = ...

  """

  Use modifier during render

  """

  show_viewport: bool = ...

  """

  Display modifier in viewport

  """

  type: str = ...

  """

  * ``GP_ARRAY``
Array, Create array of duplicate instances.

  * ``GP_BUILD``
Build, Create duplication of strokes.

  * ``GP_MIRROR``
Mirror, Duplicate strokes like a mirror.

  * ``GP_MULTIPLY``
Multiple Strokes, Produce multiple strokes along one stroke.

  * ``GP_SIMPLIFY``
Simplify, Simplify stroke reducing number of points.

  * ``GP_SUBDIV``
Subdivide, Subdivide stroke adding more control points.

  * ``GP_ARMATURE``
Armature, Deform stroke points using armature object.

  * ``GP_HOOK``
Hook, Deform stroke points using objects.

  * ``GP_LATTICE``
Lattice, Deform strokes using lattice.

  * ``GP_NOISE``
Noise, Add noise to strokes.

  * ``GP_OFFSET``
Offset, Change stroke location, rotation or scale.

  * ``GP_SMOOTH``
Smooth, Smooth stroke.

  * ``GP_THICK``
Thickness, Change stroke thickness.

  * ``GP_TIME``
Time Offset, Offset keyframes.

  * ``GP_COLOR``
Hue/Saturation, Apply changes to stroke colors.

  * ``GP_OPACITY``
Opacity, Opacity of the strokes.

  * ``GP_TEXTURE``
Texture Mapping, Change stroke uv texture values.

  * ``GP_TINT``
Tint, Tint strokes with new color.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GpencilVertexGroupElement(bpy_struct):

  """

  Weight value of a vertex in a vertex group

  """

  group: int = ...

  weight: float = ...

  """

  Vertex Weight

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GreasePencilGrid(bpy_struct):

  """

  Settings for grid and canvas in 3D viewport

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Color for grid lines

  """

  lines: int = ...

  """

  Number of subdivisions in each side of symmetry line

  """

  offset: typing.Tuple[float, float] = ...

  """

  Offset of the canvas

  """

  scale: typing.Tuple[float, float] = ...

  """

  Grid scale

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GreasePencilLayers(bpy_struct):

  """

  Collection of grease pencil layers

  """

  active: GPencilLayer = ...

  """

  Active grease pencil layer

  """

  active_index: int = ...

  """

  Index of active grease pencil layer

  """

  active_note: str = ...

  """

  Note/Layer to add annotation strokes to

  """

  def new(self, name: str, set_active: bool = True) -> GPencilLayer:

    """

    Add a new grease pencil layer

    """

    ...

  def remove(self, layer: GPencilLayer) -> None:

    """

    Remove a grease pencil layer

    """

    ...

  def move(self, layer: GPencilLayer, type: str) -> None:

    """

    Move a grease pencil layer in the layer stack

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GreasePencilMaskLayers(bpy_struct):

  """

  Collection of grease pencil masking layers

  """

  active_mask_index: int = ...

  """

  Active index in layer mask array

  """

  def add(self, layer: GPencilLayer) -> None:

    """

    Add a layer to mask list

    """

    ...

  def remove(self, mask: GPencilLayerMask) -> None:

    """

    Remove a layer from mask list

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Header(bpy_struct):

  """

  Editor header containing UI elements

  """

  bl_idname: str = ...

  """

  If this is set, the header gets a custom ID, otherwise it takes the name of the class used to define the panel; for example, if the class name is "OBJECT_HT_hello", and bl_idname is not set by the script, then bl_idname = "OBJECT_HT_hello"

  """

  bl_region_type: str = ...

  """

  The region where the header is going to be used in (defaults to header region)

  """

  bl_space_type: str = ...

  """

  The space where the header is going to be used in

  * ``EMPTY``
Empty.

  * ``VIEW_3D``
3D Viewport, Manipulate objects in a 3D environment.

  * ``IMAGE_EDITOR``
UV/Image Editor, View and edit images and UV Maps.

  * ``NODE_EDITOR``
Node Editor, Editor for node-based shading and compositing tools.

  * ``SEQUENCE_EDITOR``
Video Sequencer, Video editing tools.

  * ``CLIP_EDITOR``
Movie Clip Editor, Motion tracking tools.

  * ``DOPESHEET_EDITOR``
Dope Sheet, Adjust timing of keyframes.

  * ``GRAPH_EDITOR``
Graph Editor, Edit drivers and keyframe interpolation.

  * ``NLA_EDITOR``
Nonlinear Animation, Combine and layer Actions.

  * ``TEXT_EDITOR``
Text Editor, Edit scripts and in-file documentation.

  * ``CONSOLE``
Python Console, Interactive programmatic console for advanced editing and script development.

  * ``INFO``
Info, Log of operations, warnings and error messages.

  * ``TOPBAR``
Top Bar, Global bar at the top of the screen for global per-window settings.

  * ``STATUSBAR``
Status Bar, Global bar at the bottom of the screen for general status information.

  * ``OUTLINER``
Outliner, Overview of scene graph and all available data-blocks.

  * ``PROPERTIES``
Properties, Edit properties of active object and related data-blocks.

  * ``FILE_BROWSER``
File Browser, Browse for files and assets.

  * ``PREFERENCES``
Preferences, Edit persistent configuration settings.

  """

  layout: UILayout = ...

  """

  Structure of the header in the UI

  """

  def draw(self, context: Context) -> None:

    """

    Draw UI elements into the header UI layout

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Histogram(bpy_struct):

  """

  Statistical view of the levels of color in an image

  """

  mode: str = ...

  """

  Channels to display when drawing the histogram

  * ``LUMA``
Luma, Luma.

  * ``RGB``
RGB, Red Green Blue.

  * ``R``
R, Red.

  * ``G``
G, Green.

  * ``B``
B, Blue.

  * ``A``
A, Alpha.

  """

  show_line: bool = ...

  """

  Display lines rather than filled shapes

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ID(bpy_struct):

  """

  Base type for data-blocks, defining a unique name, linking from other libraries and garbage collection

  """

  is_embedded_data: bool = ...

  """

  This data-block is not an independent one, but is actually a sub-data of another ID (typical example: root node trees or master collections)

  """

  is_evaluated: bool = ...

  """

  Whether this ID is runtime-only, evaluated data-block, or actual data from .blend file

  """

  is_library_indirect: bool = ...

  """

  Is this ID block linked indirectly

  """

  library: Library = ...

  """

  Library file the data-block is linked from

  """

  name: str = ...

  """

  Unique data-block ID name

  """

  name_full: str = ...

  """

  Unique data-block ID name, including library one is any

  """

  original: ID = ...

  """

  Actual data-block from .blend file (Main database) that generated that evaluated one

  """

  override_library: IDOverrideLibrary = ...

  """

  Library override data

  """

  preview: ImagePreview = ...

  """

  Preview image and icon of this data-block (None if not supported for this type of data)

  """

  tag: bool = ...

  """

  Tools can use this to tag data for their own purposes (initial state is undefined)

  """

  use_fake_user: bool = ...

  """

  Save this data-block even if it has no users

  """

  users: int = ...

  """

  Number of times this data-block is referenced

  """

  def evaluated_get(self, depsgraph: Depsgraph) -> ID:

    """

    Get corresponding evaluated ID from the given dependency graph

    """

    ...

  def copy(self) -> ID:

    """

    Create a copy of this data-block (not supported for all data-blocks)

    """

    ...

  def override_create(self, remap_local_usages: bool = False) -> ID:

    """

    Create an overridden local copy of this linked data-block (not supported for all data-blocks)

    """

    ...

  def user_clear(self) -> None:

    """

    Clear the user count of a data-block so its not saved, on reload the data will be removed

    This function is for advanced use only, misuse can crash blender since the user
count is used to prevent data being removed when it is used.

    .. code::


      # This example shows what _not_ to do, and will crash blender.
      import bpy

      # object which is in the scene.
      obj = bpy.data.objects["Cube"]

      # without this, removal would raise an error.
      obj.user_clear()

      # runs without an exception
      # but will crash on redraw.
      bpy.data.objects.remove(obj)

    """

    ...

  def user_remap(self, new_id: ID) -> None:

    """

    Replace all usage in the .blend file of this ID by new given one

    """

    ...

  def make_local(self, clear_proxy: bool = True) -> ID:

    """

    Make this datablock local, return local one (may be a copy of the original, in case it is also indirectly used)

    """

    ...

  def user_of_id(self, id: ID) -> int:

    """

    Count the number of times that ID uses/references given one

    """

    ...

  def animation_data_create(self) -> AnimData:

    """

    Create animation data to this ID, note that not all ID types support this

    """

    ...

  def animation_data_clear(self) -> None:

    """

    Clear animation on this this ID

    """

    ...

  def update_tag(self, refresh: typing.Set[str] = {}) -> None:

    """

    Tag the ID to update its display data, e.g. when calling :class:`bpy.types.Scene.update`

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IDMaterials(bpy_struct):

  """

  Collection of materials

  """

  def append(self, material: Material) -> None:

    """

    Add a new material to the data-block

    """

    ...

  def pop(self, index: int = -1) -> Material:

    """

    Remove a material from the data-block

    """

    ...

  def clear(self) -> None:

    """

    Remove all materials from the data-block

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IDOverrideLibrary(bpy_struct):

  """

  Struct gathering all data needed by overridden linked IDs

  """

  properties: typing.Union[typing.Sequence[IDOverrideLibraryProperty], typing.Mapping[str, IDOverrideLibraryProperty], bpy_prop_collection] = ...

  """

  List of overridden properties

  """

  reference: ID = ...

  """

  Linked ID used as reference by this override

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IDOverrideLibraryProperty(bpy_struct):

  """

  Description of an overridden property

  """

  operations: typing.Union[typing.Sequence[IDOverrideLibraryPropertyOperation], typing.Mapping[str, IDOverrideLibraryPropertyOperation], bpy_prop_collection] = ...

  """

  List of overriding operations for a property

  """

  rna_path: str = ...

  """

  RNA path leading to that property, from owning ID

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IDOverrideLibraryPropertyOperation(bpy_struct):

  """

  Description of an override operation over an overridden property

  """

  flag: str = ...

  """

  Optional flags (NOT USED)

  * ``MANDATORY``
Mandatory, For templates, prevents the user from removing pre-defined operation (NOT USED).

  * ``LOCKED``
Locked, Prevents the user from modifying that override operation (NOT USED).

  """

  operation: str = ...

  """

  What override operation is performed

  * ``NOOP``
No-Op, Does nothing, prevents adding actual overrides (NOT USED).

  * ``REPLACE``
Replace, Replace value of reference by overriding one.

  * ``DIFF_ADD``
Differential, Stores and apply difference between reference and local value (NOT USED).

  * ``DIFF_SUB``
Differential, Stores and apply difference between reference and local value (NOT USED).

  * ``FACT_MULTIPLY``
Factor, Stores and apply multiplication factor between reference and local value (NOT USED).

  * ``INSERT_AFTER``
Insert After, Insert a new item into collection after the one referenced in subitem_reference_name or _index.

  * ``INSERT_BEFORE``
Insert Before, Insert a new item into collection after the one referenced in subitem_reference_name or _index (NOT USED).

  """

  subitem_local_index: int = ...

  """

  Used to handle insertions into collection

  """

  subitem_local_name: str = ...

  """

  Used to handle insertions into collection

  """

  subitem_reference_index: int = ...

  """

  Used to handle insertions into collection

  """

  subitem_reference_name: str = ...

  """

  Used to handle insertions into collection

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IDPropertyWrapPtr(bpy_struct):

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IKParam(bpy_struct):

  """

  Base type for IK solver parameters

  """

  ik_solver: str = ...

  """

  IK solver for which these parameters are defined

  * ``LEGACY``
Standard, Original IK solver.

  * ``ITASC``
iTaSC, Multi constraint, stateful IK solver.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ImageFormatSettings(bpy_struct):

  """

  Settings for image formats

  """

  cineon_black: int = ...

  """

  Log conversion reference blackpoint

  """

  cineon_gamma: float = ...

  """

  Log conversion gamma

  """

  cineon_white: int = ...

  """

  Log conversion reference whitepoint

  """

  color_depth: str = ...

  """

  Bit depth per channel

  * ``8``
8, 8 bit color channels.

  * ``10``
10, 10 bit color channels.

  * ``12``
12, 12 bit color channels.

  * ``16``
16, 16 bit color channels.

  * ``32``
32, 32 bit color channels.

  """

  color_mode: str = ...

  """

  Choose BW for saving grayscale images, RGB for saving red, green and blue channels, and RGBA for saving red, green, blue and alpha channels

  * ``BW``
BW, Images get saved in 8 bits grayscale (only PNG, JPEG, TGA, TIF).

  * ``RGB``
RGB, Images are saved with RGB (color) data.

  * ``RGBA``
RGBA, Images are saved with RGB and Alpha data (if supported).

  """

  compression: int = ...

  """

  Amount of time to determine best compression: 0 = no compression with fast file output, 100 = maximum lossless compression with slow file output

  """

  display_settings: ColorManagedDisplaySettings = ...

  """

  Settings of device saved image would be displayed on

  """

  exr_codec: str = ...

  """

  Codec settings for OpenEXR

  """

  file_format: str = ...

  """

  File format to save the rendered images as

  * ``BMP``
BMP, Output image in bitmap format.

  * ``IRIS``
Iris, Output image in (old!) SGI IRIS format.

  * ``PNG``
PNG, Output image in PNG format.

  * ``JPEG``
JPEG, Output image in JPEG format.

  * ``JPEG2000``
JPEG 2000, Output image in JPEG 2000 format.

  * ``TARGA``
Targa, Output image in Targa format.

  * ``TARGA_RAW``
Targa Raw, Output image in uncompressed Targa format.

  * ``CINEON``
Cineon, Output image in Cineon format.

  * ``DPX``
DPX, Output image in DPX format.

  * ``OPEN_EXR_MULTILAYER``
OpenEXR MultiLayer, Output image in multilayer OpenEXR format.

  * ``OPEN_EXR``
OpenEXR, Output image in OpenEXR format.

  * ``HDR``
Radiance HDR, Output image in Radiance HDR format.

  * ``TIFF``
TIFF, Output image in TIFF format.

  * ``AVI_JPEG``
AVI JPEG, Output video in AVI JPEG format.

  * ``AVI_RAW``
AVI Raw, Output video in AVI Raw format.

  * ``FFMPEG``
FFmpeg video, The most versatile way to output video files.

  """

  jpeg2k_codec: str = ...

  """

  Codec settings for Jpeg2000

  """

  quality: int = ...

  """

  Quality for image formats that support lossy compression

  """

  stereo_3d_format: Stereo3dFormat = ...

  """

  Settings for stereo 3d

  """

  tiff_codec: str = ...

  """

  Compression mode for TIFF

  """

  use_cineon_log: bool = ...

  """

  Convert to logarithmic color space

  """

  use_jpeg2k_cinema_48: bool = ...

  """

  Use Openjpeg Cinema Preset (48fps)

  """

  use_jpeg2k_cinema_preset: bool = ...

  """

  Use Openjpeg Cinema Preset

  """

  use_jpeg2k_ycc: bool = ...

  """

  Save luminance-chrominance-chrominance channels instead of RGB colors

  """

  use_preview: bool = ...

  """

  When rendering animations, save JPG preview images in same directory

  """

  use_zbuffer: bool = ...

  """

  Save the z-depth per pixel (32 bit unsigned int z-buffer)

  """

  view_settings: ColorManagedViewSettings = ...

  """

  Color management settings applied on image before saving

  """

  views_format: str = ...

  """

  Format of multiview media

  * ``INDIVIDUAL``
Individual, Individual files for each view with the prefix as defined by the scene views.

  * ``STEREO_3D``
Stereo 3D, Single file with an encoded stereo pair.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ImagePackedFile(bpy_struct):

  filepath: str = ...

  packed_file: PackedFile = ...

  def save(self) -> None:

    """

    Save the packed file to its filepath

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ImagePreview(bpy_struct):

  """

  Preview image and icon

  """

  icon_id: int = ...

  """

  Unique integer identifying this preview as an icon (zero means invalid)

  """

  icon_pixels: int = ...

  """

  Icon pixels, as bytes (always RGBA 32bits)

  """

  icon_pixels_float: float = ...

  """

  Icon pixels components, as floats (RGBA concatenated values)

  """

  icon_size: typing.Tuple[int, int] = ...

  """

  Width and height in pixels

  """

  image_pixels: int = ...

  """

  Image pixels, as bytes (always RGBA 32bits)

  """

  image_pixels_float: float = ...

  """

  Image pixels components, as floats (RGBA concatenated values)

  """

  image_size: typing.Tuple[int, int] = ...

  """

  Width and height in pixels

  """

  is_icon_custom: bool = ...

  """

  True if this preview icon has been modified by py script,and is no more auto-generated by Blender

  """

  is_image_custom: bool = ...

  """

  True if this preview image has been modified by py script,and is no more auto-generated by Blender

  """

  def reload(self) -> None:

    """

    Reload the preview from its source path

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ImageUser(bpy_struct):

  """

  Parameters defining how an Image data-block is used by another data-block

  """

  frame_current: int = ...

  """

  Current frame number in image sequence or movie

  """

  frame_duration: int = ...

  """

  Number of images of a movie to use

  """

  frame_offset: int = ...

  """

  Offset the number of the frame to use in the animation

  """

  frame_start: int = ...

  """

  Global starting frame of the movie/sequence, assuming first picture has a #1

  """

  multilayer_layer: int = ...

  """

  Layer in multilayer image

  """

  multilayer_pass: int = ...

  """

  Pass in multilayer image

  """

  multilayer_view: int = ...

  """

  View in multilayer image

  """

  tile: int = ...

  """

  Tile in tiled image

  """

  use_auto_refresh: bool = ...

  """

  Always refresh image on frame changes

  """

  use_cyclic: bool = ...

  """

  Cycle the images in the movie

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IntAttributeValue(bpy_struct):

  """

  Integer value in geometry attribute

  """

  value: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyConfig(bpy_struct):

  """

  Input configuration, including keymaps

  """

  is_user_defined: bool = ...

  """

  Indicates that a keyconfig was defined by the user

  """

  keymaps: typing.Union[KeyMaps, typing.Sequence[KeyMap], typing.Mapping[str, KeyMap], bpy_prop_collection] = ...

  """

  Key maps configured as part of this configuration

  """

  name: str = ...

  """

  Name of the key configuration

  """

  preferences: KeyConfigPreferences = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyConfigPreferences(bpy_struct):

  bl_idname: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyConfigurations(bpy_struct):

  """

  Collection of KeyConfigs

  """

  active: KeyConfig = ...

  """

  Active key configuration (preset)

  """

  addon: KeyConfig = ...

  """

  Key configuration that can be extended by add-ons, and is added to the active configuration when handling events

  """

  default: KeyConfig = ...

  """

  Default builtin key configuration

  """

  user: KeyConfig = ...

  """

  Final key configuration that combines keymaps from the active and add-on configurations, and can be edited by the user

  """

  def new(self, name: str) -> KeyConfig:

    """

    new

    """

    ...

  def remove(self, keyconfig: KeyConfig) -> None:

    """

    remove

    """

    ...

  def find_item_from_operator(self, idname: str, context: str = 'INVOKE_DEFAULT', properties: OperatorProperties = None, include: typing.Set[str] = {'ACTIONZONE', 'KEYBOARD', 'MOUSE', 'NDOF', 'TWEAK'}, exclude: typing.Set[str] = {}) -> None:

    """

    find_item_from_operator

    """

    ...

  def update(self) -> None:

    """

    update

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyMap(bpy_struct):

  """

  Input configuration, including keymaps

  """

  bl_owner_id: str = ...

  """

  Internal owner

  """

  is_modal: bool = ...

  """

  Indicates that a keymap is used for translate modal events for an operator

  """

  is_user_modified: bool = ...

  """

  Keymap is defined by the user

  """

  keymap_items: typing.Union[KeyMapItems, typing.Sequence[KeyMapItem], typing.Mapping[str, KeyMapItem], bpy_prop_collection] = ...

  """

  Items in the keymap, linking an operator to an input event

  """

  name: str = ...

  """

  Name of the key map

  """

  region_type: str = ...

  """

  Optional region type keymap is associated with

  """

  show_expanded_children: bool = ...

  """

  Children expanded in the user interface

  """

  show_expanded_items: bool = ...

  """

  Expanded in the user interface

  """

  space_type: str = ...

  """

  Optional space type keymap is associated with

  * ``EMPTY``
Empty.

  * ``VIEW_3D``
3D Viewport, Manipulate objects in a 3D environment.

  * ``IMAGE_EDITOR``
UV/Image Editor, View and edit images and UV Maps.

  * ``NODE_EDITOR``
Node Editor, Editor for node-based shading and compositing tools.

  * ``SEQUENCE_EDITOR``
Video Sequencer, Video editing tools.

  * ``CLIP_EDITOR``
Movie Clip Editor, Motion tracking tools.

  * ``DOPESHEET_EDITOR``
Dope Sheet, Adjust timing of keyframes.

  * ``GRAPH_EDITOR``
Graph Editor, Edit drivers and keyframe interpolation.

  * ``NLA_EDITOR``
Nonlinear Animation, Combine and layer Actions.

  * ``TEXT_EDITOR``
Text Editor, Edit scripts and in-file documentation.

  * ``CONSOLE``
Python Console, Interactive programmatic console for advanced editing and script development.

  * ``INFO``
Info, Log of operations, warnings and error messages.

  * ``TOPBAR``
Top Bar, Global bar at the top of the screen for global per-window settings.

  * ``STATUSBAR``
Status Bar, Global bar at the bottom of the screen for general status information.

  * ``OUTLINER``
Outliner, Overview of scene graph and all available data-blocks.

  * ``PROPERTIES``
Properties, Edit properties of active object and related data-blocks.

  * ``FILE_BROWSER``
File Browser, Browse for files and assets.

  * ``PREFERENCES``
Preferences, Edit persistent configuration settings.

  """

  def active(self) -> KeyMap:

    """

    active

    """

    ...

  def restore_to_default(self) -> None:

    """

    restore_to_default

    """

    ...

  def restore_item_to_default(self, item: KeyMapItem) -> None:

    """

    restore_item_to_default

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyMapItem(bpy_struct):

  """

  Item in a Key Map

  """

  active: bool = ...

  """

  Activate or deactivate item

  """

  alt: bool = ...

  """

  Alt key pressed

  """

  any: bool = ...

  """

  Any modifier keys pressed

  """

  ctrl: bool = ...

  """

  Control key pressed

  """

  id: int = ...

  """

  ID of the item

  """

  idname: str = ...

  """

  Identifier of operator to call on input event

  """

  is_user_defined: bool = ...

  """

  Is this keymap item user defined (doesn't just replace a builtin item)

  """

  is_user_modified: bool = ...

  """

  Is this keymap item modified by the user

  """

  key_modifier: str = ...

  """

  Regular key pressed as a modifier

  * ``NONE``
Undocumented.

  * ``LEFTMOUSE``
Left Mouse, LMB.

  * ``MIDDLEMOUSE``
Middle Mouse, MMB.

  * ``RIGHTMOUSE``
Right Mouse, RMB.

  * ``BUTTON4MOUSE``
Button4 Mouse, MB4.

  * ``BUTTON5MOUSE``
Button5 Mouse, MB5.

  * ``BUTTON6MOUSE``
Button6 Mouse, MB6.

  * ``BUTTON7MOUSE``
Button7 Mouse, MB7.

  * ``PEN``
Pen.

  * ``ERASER``
Eraser.

  * ``MOUSEMOVE``
Mouse Move, MsMov.

  * ``INBETWEEN_MOUSEMOVE``
In-between Move, MsSubMov.

  * ``TRACKPADPAN``
Mouse/Trackpad Pan, MsPan.

  * ``TRACKPADZOOM``
Mouse/Trackpad Zoom, MsZoom.

  * ``MOUSEROTATE``
Mouse/Trackpad Rotate, MsRot.

  * ``MOUSESMARTZOOM``
Mouse/Trackpad Smart Zoom, MsSmartZoom.

  * ``WHEELUPMOUSE``
Wheel Up, WhUp.

  * ``WHEELDOWNMOUSE``
Wheel Down, WhDown.

  * ``WHEELINMOUSE``
Wheel In, WhIn.

  * ``WHEELOUTMOUSE``
Wheel Out, WhOut.

  * ``EVT_TWEAK_L``
Tweak Left, TwkL.

  * ``EVT_TWEAK_M``
Tweak Middle, TwkM.

  * ``EVT_TWEAK_R``
Tweak Right, TwkR.

  * ``A``
A.

  * ``B``
B.

  * ``C``
C.

  * ``D``
D.

  * ``E``
E.

  * ``F``
F.

  * ``G``
G.

  * ``H``
H.

  * ``I``
I.

  * ``J``
J.

  * ``K``
K.

  * ``L``
L.

  * ``M``
M.

  * ``N``
N.

  * ``O``
O.

  * ``P``
P.

  * ``Q``
Q.

  * ``R``
R.

  * ``S``
S.

  * ``T``
T.

  * ``U``
U.

  * ``V``
V.

  * ``W``
W.

  * ``X``
X.

  * ``Y``
Y.

  * ``Z``
Z.

  * ``ZERO``
0.

  * ``ONE``
1.

  * ``TWO``
2.

  * ``THREE``
3.

  * ``FOUR``
4.

  * ``FIVE``
5.

  * ``SIX``
6.

  * ``SEVEN``
7.

  * ``EIGHT``
8.

  * ``NINE``
9.

  * ``LEFT_CTRL``
Left Ctrl, CtrlL.

  * ``LEFT_ALT``
Left Alt, AltL.

  * ``LEFT_SHIFT``
Left Shift, ShiftL.

  * ``RIGHT_ALT``
Right Alt, AltR.

  * ``RIGHT_CTRL``
Right Ctrl, CtrlR.

  * ``RIGHT_SHIFT``
Right Shift, ShiftR.

  * ``OSKEY``
OS Key, Cmd.

  * ``APP``
Application, App.

  * ``GRLESS``
Grless.

  * ``ESC``
Esc.

  * ``TAB``
Tab.

  * ``RET``
Return, Enter.

  * ``SPACE``
Spacebar, Space.

  * ``LINE_FEED``
Line Feed.

  * ``BACK_SPACE``
Backspace, BkSpace.

  * ``DEL``
Delete, Del.

  * ``SEMI_COLON``
;.

  * ``PERIOD``
..

  * ``COMMA``
,.

  * ``QUOTE``
".

  * ``ACCENT_GRAVE``
`.

  * ``MINUS``
-.

  * ``PLUS``
+.

  * ``SLASH``
/.

  * ``BACK_SLASH``
\.

  * ``EQUAL``
=.

  * ``LEFT_BRACKET``
[.

  * ``RIGHT_BRACKET``
].

  * ``LEFT_ARROW``
Left Arrow, ←.

  * ``DOWN_ARROW``
Down Arrow, ↓.

  * ``RIGHT_ARROW``
Right Arrow, →.

  * ``UP_ARROW``
Up Arrow, ↑.

  * ``NUMPAD_2``
Numpad 2, Pad2.

  * ``NUMPAD_4``
Numpad 4, Pad4.

  * ``NUMPAD_6``
Numpad 6, Pad6.

  * ``NUMPAD_8``
Numpad 8, Pad8.

  * ``NUMPAD_1``
Numpad 1, Pad1.

  * ``NUMPAD_3``
Numpad 3, Pad3.

  * ``NUMPAD_5``
Numpad 5, Pad5.

  * ``NUMPAD_7``
Numpad 7, Pad7.

  * ``NUMPAD_9``
Numpad 9, Pad9.

  * ``NUMPAD_PERIOD``
Numpad ., Pad..

  * ``NUMPAD_SLASH``
Numpad /, Pad/.

  * ``NUMPAD_ASTERIX``
Numpad *, Pad*.

  * ``NUMPAD_0``
Numpad 0, Pad0.

  * ``NUMPAD_MINUS``
Numpad -, Pad-.

  * ``NUMPAD_ENTER``
Numpad Enter, PadEnter.

  * ``NUMPAD_PLUS``
Numpad +, Pad+.

  * ``F1``
F1.

  * ``F2``
F2.

  * ``F3``
F3.

  * ``F4``
F4.

  * ``F5``
F5.

  * ``F6``
F6.

  * ``F7``
F7.

  * ``F8``
F8.

  * ``F9``
F9.

  * ``F10``
F10.

  * ``F11``
F11.

  * ``F12``
F12.

  * ``F13``
F13.

  * ``F14``
F14.

  * ``F15``
F15.

  * ``F16``
F16.

  * ``F17``
F17.

  * ``F18``
F18.

  * ``F19``
F19.

  * ``F20``
F20.

  * ``F21``
F21.

  * ``F22``
F22.

  * ``F23``
F23.

  * ``F24``
F24.

  * ``PAUSE``
Pause.

  * ``INSERT``
Insert, Ins.

  * ``HOME``
Home.

  * ``PAGE_UP``
Page Up, PgUp.

  * ``PAGE_DOWN``
Page Down, PgDown.

  * ``END``
End.

  * ``MEDIA_PLAY``
Media Play/Pause, >/||.

  * ``MEDIA_STOP``
Media Stop, Stop.

  * ``MEDIA_FIRST``
Media First, |<<.

  * ``MEDIA_LAST``
Media Last, >>|.

  * ``TEXTINPUT``
Text Input, TxtIn.

  * ``WINDOW_DEACTIVATE``
Window Deactivate.

  * ``TIMER``
Timer, Tmr.

  * ``TIMER0``
Timer 0, Tmr0.

  * ``TIMER1``
Timer 1, Tmr1.

  * ``TIMER2``
Timer 2, Tmr2.

  * ``TIMER_JOBS``
Timer Jobs, TmrJob.

  * ``TIMER_AUTOSAVE``
Timer Autosave, TmrSave.

  * ``TIMER_REPORT``
Timer Report, TmrReport.

  * ``TIMERREGION``
Timer Region, TmrReg.

  * ``NDOF_MOTION``
NDOF Motion, NdofMov.

  * ``NDOF_BUTTON_MENU``
NDOF Menu, NdofMenu.

  * ``NDOF_BUTTON_FIT``
NDOF Fit, NdofFit.

  * ``NDOF_BUTTON_TOP``
NDOF Top, Ndof↑.

  * ``NDOF_BUTTON_BOTTOM``
NDOF Bottom, Ndof↓.

  * ``NDOF_BUTTON_LEFT``
NDOF Left, Ndof←.

  * ``NDOF_BUTTON_RIGHT``
NDOF Right, Ndof→.

  * ``NDOF_BUTTON_FRONT``
NDOF Front, NdofFront.

  * ``NDOF_BUTTON_BACK``
NDOF Back, NdofBack.

  * ``NDOF_BUTTON_ISO1``
NDOF Isometric 1, NdofIso1.

  * ``NDOF_BUTTON_ISO2``
NDOF Isometric 2, NdofIso2.

  * ``NDOF_BUTTON_ROLL_CW``
NDOF Roll CW, NdofRCW.

  * ``NDOF_BUTTON_ROLL_CCW``
NDOF Roll CCW, NdofRCCW.

  * ``NDOF_BUTTON_SPIN_CW``
NDOF Spin CW, NdofSCW.

  * ``NDOF_BUTTON_SPIN_CCW``
NDOF Spin CCW, NdofSCCW.

  * ``NDOF_BUTTON_TILT_CW``
NDOF Tilt CW, NdofTCW.

  * ``NDOF_BUTTON_TILT_CCW``
NDOF Tilt CCW, NdofTCCW.

  * ``NDOF_BUTTON_ROTATE``
NDOF Rotate, NdofRot.

  * ``NDOF_BUTTON_PANZOOM``
NDOF Pan/Zoom, NdofPanZoom.

  * ``NDOF_BUTTON_DOMINANT``
NDOF Dominant, NdofDom.

  * ``NDOF_BUTTON_PLUS``
NDOF Plus, Ndof+.

  * ``NDOF_BUTTON_MINUS``
NDOF Minus, Ndof-.

  * ``NDOF_BUTTON_ESC``
NDOF Esc, NdofEsc.

  * ``NDOF_BUTTON_ALT``
NDOF Alt, NdofAlt.

  * ``NDOF_BUTTON_SHIFT``
NDOF Shift, NdofShift.

  * ``NDOF_BUTTON_CTRL``
NDOF Ctrl, NdofCtrl.

  * ``NDOF_BUTTON_1``
NDOF Button 1, NdofB1.

  * ``NDOF_BUTTON_2``
NDOF Button 2, NdofB2.

  * ``NDOF_BUTTON_3``
NDOF Button 3, NdofB3.

  * ``NDOF_BUTTON_4``
NDOF Button 4, NdofB4.

  * ``NDOF_BUTTON_5``
NDOF Button 5, NdofB5.

  * ``NDOF_BUTTON_6``
NDOF Button 6, NdofB6.

  * ``NDOF_BUTTON_7``
NDOF Button 7, NdofB7.

  * ``NDOF_BUTTON_8``
NDOF Button 8, NdofB8.

  * ``NDOF_BUTTON_9``
NDOF Button 9, NdofB9.

  * ``NDOF_BUTTON_10``
NDOF Button 10, NdofB10.

  * ``NDOF_BUTTON_A``
NDOF Button A, NdofBA.

  * ``NDOF_BUTTON_B``
NDOF Button B, NdofBB.

  * ``NDOF_BUTTON_C``
NDOF Button C, NdofBC.

  * ``ACTIONZONE_AREA``
ActionZone Area, AZone Area.

  * ``ACTIONZONE_REGION``
ActionZone Region, AZone Region.

  * ``ACTIONZONE_FULLSCREEN``
ActionZone Fullscreen, AZone FullScr.

  """

  map_type: str = ...

  """

  Type of event mapping

  """

  name: str = ...

  """

  Name of operator (translated) to call on input event

  """

  oskey: bool = ...

  """

  Operating system key pressed

  """

  properties: OperatorProperties = ...

  """

  Properties to set when the operator is called

  """

  propvalue: str = ...

  """

  The value this event translates to in a modal keymap

  """

  repeat: bool = ...

  """

  Active on key-repeat events (when a key is held)

  """

  shift: bool = ...

  """

  Shift key pressed

  """

  show_expanded: bool = ...

  """

  Show key map event and property details in the user interface

  """

  type: str = ...

  """

  Type of event

  * ``NONE``
Undocumented.

  * ``LEFTMOUSE``
Left Mouse, LMB.

  * ``MIDDLEMOUSE``
Middle Mouse, MMB.

  * ``RIGHTMOUSE``
Right Mouse, RMB.

  * ``BUTTON4MOUSE``
Button4 Mouse, MB4.

  * ``BUTTON5MOUSE``
Button5 Mouse, MB5.

  * ``BUTTON6MOUSE``
Button6 Mouse, MB6.

  * ``BUTTON7MOUSE``
Button7 Mouse, MB7.

  * ``PEN``
Pen.

  * ``ERASER``
Eraser.

  * ``MOUSEMOVE``
Mouse Move, MsMov.

  * ``INBETWEEN_MOUSEMOVE``
In-between Move, MsSubMov.

  * ``TRACKPADPAN``
Mouse/Trackpad Pan, MsPan.

  * ``TRACKPADZOOM``
Mouse/Trackpad Zoom, MsZoom.

  * ``MOUSEROTATE``
Mouse/Trackpad Rotate, MsRot.

  * ``MOUSESMARTZOOM``
Mouse/Trackpad Smart Zoom, MsSmartZoom.

  * ``WHEELUPMOUSE``
Wheel Up, WhUp.

  * ``WHEELDOWNMOUSE``
Wheel Down, WhDown.

  * ``WHEELINMOUSE``
Wheel In, WhIn.

  * ``WHEELOUTMOUSE``
Wheel Out, WhOut.

  * ``EVT_TWEAK_L``
Tweak Left, TwkL.

  * ``EVT_TWEAK_M``
Tweak Middle, TwkM.

  * ``EVT_TWEAK_R``
Tweak Right, TwkR.

  * ``A``
A.

  * ``B``
B.

  * ``C``
C.

  * ``D``
D.

  * ``E``
E.

  * ``F``
F.

  * ``G``
G.

  * ``H``
H.

  * ``I``
I.

  * ``J``
J.

  * ``K``
K.

  * ``L``
L.

  * ``M``
M.

  * ``N``
N.

  * ``O``
O.

  * ``P``
P.

  * ``Q``
Q.

  * ``R``
R.

  * ``S``
S.

  * ``T``
T.

  * ``U``
U.

  * ``V``
V.

  * ``W``
W.

  * ``X``
X.

  * ``Y``
Y.

  * ``Z``
Z.

  * ``ZERO``
0.

  * ``ONE``
1.

  * ``TWO``
2.

  * ``THREE``
3.

  * ``FOUR``
4.

  * ``FIVE``
5.

  * ``SIX``
6.

  * ``SEVEN``
7.

  * ``EIGHT``
8.

  * ``NINE``
9.

  * ``LEFT_CTRL``
Left Ctrl, CtrlL.

  * ``LEFT_ALT``
Left Alt, AltL.

  * ``LEFT_SHIFT``
Left Shift, ShiftL.

  * ``RIGHT_ALT``
Right Alt, AltR.

  * ``RIGHT_CTRL``
Right Ctrl, CtrlR.

  * ``RIGHT_SHIFT``
Right Shift, ShiftR.

  * ``OSKEY``
OS Key, Cmd.

  * ``APP``
Application, App.

  * ``GRLESS``
Grless.

  * ``ESC``
Esc.

  * ``TAB``
Tab.

  * ``RET``
Return, Enter.

  * ``SPACE``
Spacebar, Space.

  * ``LINE_FEED``
Line Feed.

  * ``BACK_SPACE``
Backspace, BkSpace.

  * ``DEL``
Delete, Del.

  * ``SEMI_COLON``
;.

  * ``PERIOD``
..

  * ``COMMA``
,.

  * ``QUOTE``
".

  * ``ACCENT_GRAVE``
`.

  * ``MINUS``
-.

  * ``PLUS``
+.

  * ``SLASH``
/.

  * ``BACK_SLASH``
\.

  * ``EQUAL``
=.

  * ``LEFT_BRACKET``
[.

  * ``RIGHT_BRACKET``
].

  * ``LEFT_ARROW``
Left Arrow, ←.

  * ``DOWN_ARROW``
Down Arrow, ↓.

  * ``RIGHT_ARROW``
Right Arrow, →.

  * ``UP_ARROW``
Up Arrow, ↑.

  * ``NUMPAD_2``
Numpad 2, Pad2.

  * ``NUMPAD_4``
Numpad 4, Pad4.

  * ``NUMPAD_6``
Numpad 6, Pad6.

  * ``NUMPAD_8``
Numpad 8, Pad8.

  * ``NUMPAD_1``
Numpad 1, Pad1.

  * ``NUMPAD_3``
Numpad 3, Pad3.

  * ``NUMPAD_5``
Numpad 5, Pad5.

  * ``NUMPAD_7``
Numpad 7, Pad7.

  * ``NUMPAD_9``
Numpad 9, Pad9.

  * ``NUMPAD_PERIOD``
Numpad ., Pad..

  * ``NUMPAD_SLASH``
Numpad /, Pad/.

  * ``NUMPAD_ASTERIX``
Numpad *, Pad*.

  * ``NUMPAD_0``
Numpad 0, Pad0.

  * ``NUMPAD_MINUS``
Numpad -, Pad-.

  * ``NUMPAD_ENTER``
Numpad Enter, PadEnter.

  * ``NUMPAD_PLUS``
Numpad +, Pad+.

  * ``F1``
F1.

  * ``F2``
F2.

  * ``F3``
F3.

  * ``F4``
F4.

  * ``F5``
F5.

  * ``F6``
F6.

  * ``F7``
F7.

  * ``F8``
F8.

  * ``F9``
F9.

  * ``F10``
F10.

  * ``F11``
F11.

  * ``F12``
F12.

  * ``F13``
F13.

  * ``F14``
F14.

  * ``F15``
F15.

  * ``F16``
F16.

  * ``F17``
F17.

  * ``F18``
F18.

  * ``F19``
F19.

  * ``F20``
F20.

  * ``F21``
F21.

  * ``F22``
F22.

  * ``F23``
F23.

  * ``F24``
F24.

  * ``PAUSE``
Pause.

  * ``INSERT``
Insert, Ins.

  * ``HOME``
Home.

  * ``PAGE_UP``
Page Up, PgUp.

  * ``PAGE_DOWN``
Page Down, PgDown.

  * ``END``
End.

  * ``MEDIA_PLAY``
Media Play/Pause, >/||.

  * ``MEDIA_STOP``
Media Stop, Stop.

  * ``MEDIA_FIRST``
Media First, |<<.

  * ``MEDIA_LAST``
Media Last, >>|.

  * ``TEXTINPUT``
Text Input, TxtIn.

  * ``WINDOW_DEACTIVATE``
Window Deactivate.

  * ``TIMER``
Timer, Tmr.

  * ``TIMER0``
Timer 0, Tmr0.

  * ``TIMER1``
Timer 1, Tmr1.

  * ``TIMER2``
Timer 2, Tmr2.

  * ``TIMER_JOBS``
Timer Jobs, TmrJob.

  * ``TIMER_AUTOSAVE``
Timer Autosave, TmrSave.

  * ``TIMER_REPORT``
Timer Report, TmrReport.

  * ``TIMERREGION``
Timer Region, TmrReg.

  * ``NDOF_MOTION``
NDOF Motion, NdofMov.

  * ``NDOF_BUTTON_MENU``
NDOF Menu, NdofMenu.

  * ``NDOF_BUTTON_FIT``
NDOF Fit, NdofFit.

  * ``NDOF_BUTTON_TOP``
NDOF Top, Ndof↑.

  * ``NDOF_BUTTON_BOTTOM``
NDOF Bottom, Ndof↓.

  * ``NDOF_BUTTON_LEFT``
NDOF Left, Ndof←.

  * ``NDOF_BUTTON_RIGHT``
NDOF Right, Ndof→.

  * ``NDOF_BUTTON_FRONT``
NDOF Front, NdofFront.

  * ``NDOF_BUTTON_BACK``
NDOF Back, NdofBack.

  * ``NDOF_BUTTON_ISO1``
NDOF Isometric 1, NdofIso1.

  * ``NDOF_BUTTON_ISO2``
NDOF Isometric 2, NdofIso2.

  * ``NDOF_BUTTON_ROLL_CW``
NDOF Roll CW, NdofRCW.

  * ``NDOF_BUTTON_ROLL_CCW``
NDOF Roll CCW, NdofRCCW.

  * ``NDOF_BUTTON_SPIN_CW``
NDOF Spin CW, NdofSCW.

  * ``NDOF_BUTTON_SPIN_CCW``
NDOF Spin CCW, NdofSCCW.

  * ``NDOF_BUTTON_TILT_CW``
NDOF Tilt CW, NdofTCW.

  * ``NDOF_BUTTON_TILT_CCW``
NDOF Tilt CCW, NdofTCCW.

  * ``NDOF_BUTTON_ROTATE``
NDOF Rotate, NdofRot.

  * ``NDOF_BUTTON_PANZOOM``
NDOF Pan/Zoom, NdofPanZoom.

  * ``NDOF_BUTTON_DOMINANT``
NDOF Dominant, NdofDom.

  * ``NDOF_BUTTON_PLUS``
NDOF Plus, Ndof+.

  * ``NDOF_BUTTON_MINUS``
NDOF Minus, Ndof-.

  * ``NDOF_BUTTON_ESC``
NDOF Esc, NdofEsc.

  * ``NDOF_BUTTON_ALT``
NDOF Alt, NdofAlt.

  * ``NDOF_BUTTON_SHIFT``
NDOF Shift, NdofShift.

  * ``NDOF_BUTTON_CTRL``
NDOF Ctrl, NdofCtrl.

  * ``NDOF_BUTTON_1``
NDOF Button 1, NdofB1.

  * ``NDOF_BUTTON_2``
NDOF Button 2, NdofB2.

  * ``NDOF_BUTTON_3``
NDOF Button 3, NdofB3.

  * ``NDOF_BUTTON_4``
NDOF Button 4, NdofB4.

  * ``NDOF_BUTTON_5``
NDOF Button 5, NdofB5.

  * ``NDOF_BUTTON_6``
NDOF Button 6, NdofB6.

  * ``NDOF_BUTTON_7``
NDOF Button 7, NdofB7.

  * ``NDOF_BUTTON_8``
NDOF Button 8, NdofB8.

  * ``NDOF_BUTTON_9``
NDOF Button 9, NdofB9.

  * ``NDOF_BUTTON_10``
NDOF Button 10, NdofB10.

  * ``NDOF_BUTTON_A``
NDOF Button A, NdofBA.

  * ``NDOF_BUTTON_B``
NDOF Button B, NdofBB.

  * ``NDOF_BUTTON_C``
NDOF Button C, NdofBC.

  * ``ACTIONZONE_AREA``
ActionZone Area, AZone Area.

  * ``ACTIONZONE_REGION``
ActionZone Region, AZone Region.

  * ``ACTIONZONE_FULLSCREEN``
ActionZone Fullscreen, AZone FullScr.

  """

  value: str = ...

  def compare(self, item: KeyMapItem) -> bool:

    """

    compare

    """

    ...

  def to_string(self, compact: bool = False) -> str:

    """

    to_string

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyMapItems(bpy_struct):

  """

  Collection of keymap items

  """

  def new(self, idname: str, type: str, value: str, any: bool = False, shift: bool = False, ctrl: bool = False, alt: bool = False, oskey: bool = False, key_modifier: str = 'NONE', repeat: bool = True, head: bool = False) -> KeyMapItem:

    """

    new

    """

    ...

  def new_modal(self, propvalue: str, type: str, value: str, any: bool = False, shift: bool = False, ctrl: bool = False, alt: bool = False, oskey: bool = False, key_modifier: str = 'NONE', repeat: bool = True) -> KeyMapItem:

    """

    new_modal

    """

    ...

  def new_from_item(self, item: KeyMapItem, head: bool = False) -> KeyMapItem:

    """

    new_from_item

    """

    ...

  def remove(self, item: KeyMapItem) -> None:

    """

    remove

    """

    ...

  def from_id(self, id: int) -> KeyMapItem:

    """

    from_id

    """

    ...

  def find_from_operator(self, idname: str, properties: OperatorProperties = None, include: typing.Set[str] = {'ACTIONZONE', 'KEYBOARD', 'MOUSE', 'NDOF', 'TWEAK'}, exclude: typing.Set[str] = {}) -> KeyMapItem:

    """

    find_from_operator

    """

    ...

  def match_event(self, event: Event) -> KeyMapItem:

    """

    match_event

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyMaps(bpy_struct):

  """

  Collection of keymaps

  """

  def new(self, name: str, space_type: str = 'EMPTY', region_type: str = 'WINDOW', modal: bool = False, tool: bool = False) -> KeyMap:

    """

    new

    """

    ...

  def remove(self, keymap: KeyMap) -> None:

    """

    remove

    """

    ...

  def find(self, name: str, space_type: str = 'EMPTY', region_type: str = 'WINDOW') -> KeyMap:

    """

    find

    """

    ...

  def find_modal(self, name: str) -> KeyMap:

    """

    find_modal

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Keyframe(bpy_struct):

  """

  Bezier curve point with two handles defining a Keyframe on an F-Curve

  """

  amplitude: float = ...

  """

  Amount to boost elastic bounces for 'elastic' easing

  """

  back: float = ...

  """

  Amount of overshoot for 'back' easing

  """

  co: typing.Tuple[float, float] = ...

  """

  Coordinates of the control point

  """

  co_ui: typing.Tuple[float, float] = ...

  """

  Coordinates of the control point. Note: Changing this value also updates the handles similar to using the graph editor transform operator

  """

  easing: str = ...

  """

  Which ends of the segment between this and the next keyframe easing interpolation is applied to

  * ``AUTO``
Automatic Easing, Easing type is chosen automatically based on what the type of interpolation used (e.g. 'Ease In' for transitional types, and 'Ease Out' for dynamic effects).

  * ``EASE_IN``
Ease In, Only on the end closest to the next keyframe.

  * ``EASE_OUT``
Ease Out, Only on the end closest to the first keyframe.

  * ``EASE_IN_OUT``
Ease In and Out, Segment between both keyframes.

  """

  handle_left: typing.Tuple[float, float] = ...

  """

  Coordinates of the left handle (before the control point)

  """

  handle_left_type: str = ...

  """

  Handle types

  * ``FREE``
Free, Completely independent manually set handle.

  * ``ALIGNED``
Aligned, Manually set handle with rotation locked together with its pair.

  * ``VECTOR``
Vector, Automatic handles that create straight lines.

  * ``AUTO``
Automatic, Automatic handles that create smooth curves.

  * ``AUTO_CLAMPED``
Auto Clamped, Automatic handles that create smooth curves which only change direction at keyframes.

  """

  handle_right: typing.Tuple[float, float] = ...

  """

  Coordinates of the right handle (after the control point)

  """

  handle_right_type: str = ...

  """

  Handle types

  * ``FREE``
Free, Completely independent manually set handle.

  * ``ALIGNED``
Aligned, Manually set handle with rotation locked together with its pair.

  * ``VECTOR``
Vector, Automatic handles that create straight lines.

  * ``AUTO``
Automatic, Automatic handles that create smooth curves.

  * ``AUTO_CLAMPED``
Auto Clamped, Automatic handles that create smooth curves which only change direction at keyframes.

  """

  interpolation: str = ...

  """

  Interpolation method to use for segment of the F-Curve from this Keyframe until the next Keyframe

  * ``CONSTANT``
Constant, No interpolation, value of A gets held until B is encountered.

  * ``LINEAR``
Linear, Straight-line interpolation between A and B (i.e. no ease in/out).

  * ``BEZIER``
Bezier, Smooth interpolation between A and B, with some control over curve shape.

  * ``SINE``
Sinusoidal, Sinusoidal easing (weakest, almost linear but with a slight curvature).

  * ``QUAD``
Quadratic, Quadratic easing.

  * ``CUBIC``
Cubic, Cubic easing.

  * ``QUART``
Quartic, Quartic easing.

  * ``QUINT``
Quintic, Quintic easing.

  * ``EXPO``
Exponential, Exponential easing (dramatic).

  * ``CIRC``
Circular, Circular easing (strongest and most dynamic).

  * ``BACK``
Back, Cubic easing with overshoot and settle.

  * ``BOUNCE``
Bounce, Exponentially decaying parabolic bounce, like when objects collide.

  * ``ELASTIC``
Elastic, Exponentially decaying sine wave, like an elastic band.

  """

  period: float = ...

  """

  Time between bounces for elastic easing

  """

  select_control_point: bool = ...

  """

  Control point selection status

  """

  select_left_handle: bool = ...

  """

  Left handle selection status

  """

  select_right_handle: bool = ...

  """

  Right handle selection status

  """

  type: str = ...

  """

  Type of keyframe (for visual purposes only)

  * ``KEYFRAME``
Keyframe, Normal keyframe - e.g. for key poses.

  * ``BREAKDOWN``
Breakdown, A breakdown pose - e.g. for transitions between key poses.

  * ``MOVING_HOLD``
Moving Hold, A keyframe that is part of a moving hold.

  * ``EXTREME``
Extreme, An 'extreme' pose, or some other purpose as needed.

  * ``JITTER``
Jitter, A filler or baked keyframe for keying on ones, or some other purpose as needed.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyingSet(bpy_struct):

  """

  Settings that should be keyframed together

  """

  bl_description: str = ...

  """

  A short description of the keying set

  """

  bl_idname: str = ...

  """

  If this is set, the Keying Set gets a custom ID, otherwise it takes the name of the class used to define the Keying Set (for example, if the class name is "BUILTIN_KSI_location", and bl_idname is not set by the script, then bl_idname = "BUILTIN_KSI_location")

  """

  bl_label: str = ...

  is_path_absolute: bool = ...

  """

  Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)

  """

  paths: typing.Union[KeyingSetPaths, typing.Sequence[KeyingSetPath], typing.Mapping[str, KeyingSetPath], bpy_prop_collection] = ...

  """

  Keying Set Paths to define settings that get keyframed together

  """

  type_info: KeyingSetInfo = ...

  """

  Callback function defines for built-in Keying Sets

  """

  use_insertkey_needed: bool = ...

  """

  Only insert keyframes where they're needed in the relevant F-Curves

  """

  use_insertkey_override_needed: bool = ...

  """

  Override default setting to only insert keyframes where they're needed in the relevant F-Curves

  """

  use_insertkey_override_visual: bool = ...

  """

  Override default setting to insert keyframes based on 'visual transforms'

  """

  use_insertkey_override_xyz_to_rgb: bool = ...

  """

  Override default setting to set color for newly added transformation F-Curves (Location, Rotation, Scale) to be based on the transform axis

  """

  use_insertkey_visual: bool = ...

  """

  Insert keyframes based on 'visual transforms'

  """

  use_insertkey_xyz_to_rgb: bool = ...

  """

  Color for newly added transformation F-Curves (Location, Rotation, Scale) is based on the transform axis

  """

  def refresh(self) -> None:

    """

    Refresh Keying Set to ensure that it is valid for the current context (call before each use of one)

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyingSetInfo(bpy_struct):

  """

  Callback function defines for builtin Keying Sets

  """

  bl_description: str = ...

  """

  A short description of the keying set

  """

  bl_idname: str = ...

  """

  If this is set, the Keying Set gets a custom ID, otherwise it takes the name of the class used to define the Keying Set (for example, if the class name is "BUILTIN_KSI_location", and bl_idname is not set by the script, then bl_idname = "BUILTIN_KSI_location")

  """

  bl_label: str = ...

  bl_options: typing.Set[str] = ...

  """

  Keying Set options to use when inserting keyframes

  * ``INSERTKEY_NEEDED``
Only Needed, Only insert keyframes where they're needed in the relevant F-Curves.

  * ``INSERTKEY_VISUAL``
Visual Keying, Insert keyframes based on 'visual transforms'.

  * ``INSERTKEY_XYZ_TO_RGB``
XYZ=RGB Colors, Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis.

  """

  def poll(self, context: Context) -> bool:

    """

    Test if Keying Set can be used or not

    """

    ...

  def iterator(self, context: Context, ks: KeyingSet) -> None:

    """

    Call generate() on the structs which have properties to be keyframed

    """

    ...

  def generate(self, context: Context, ks: KeyingSet, data: typing.Any) -> None:

    """

    Add Paths to the Keying Set to keyframe the properties of the given data

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyingSetPath(bpy_struct):

  """

  Path to a setting for use in a Keying Set

  """

  array_index: int = ...

  """

  Index to the specific setting if applicable

  """

  data_path: str = ...

  """

  Path to property setting

  """

  group: str = ...

  """

  Name of Action Group to assign setting(s) for this path to

  """

  group_method: str = ...

  """

  Method used to define which Group-name to use

  """

  id: ID = ...

  """

  ID-Block that keyframes for Keying Set should be added to (for Absolute Keying Sets only)

  """

  id_type: str = ...

  """

  Type of ID-block that can be used

  """

  use_entire_array: bool = ...

  """

  When an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used

  """

  use_insertkey_needed: bool = ...

  """

  Only insert keyframes where they're needed in the relevant F-Curves

  """

  use_insertkey_override_needed: bool = ...

  """

  Override default setting to only insert keyframes where they're needed in the relevant F-Curves

  """

  use_insertkey_override_visual: bool = ...

  """

  Override default setting to insert keyframes based on 'visual transforms'

  """

  use_insertkey_override_xyz_to_rgb: bool = ...

  """

  Override default setting to set color for newly added transformation F-Curves (Location, Rotation, Scale) to be based on the transform axis

  """

  use_insertkey_visual: bool = ...

  """

  Insert keyframes based on 'visual transforms'

  """

  use_insertkey_xyz_to_rgb: bool = ...

  """

  Color for newly added transformation F-Curves (Location, Rotation, Scale) is based on the transform axis

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyingSetPaths(bpy_struct):

  """

  Collection of keying set paths

  """

  active: KeyingSetPath = ...

  """

  Active Keying Set used to insert/delete keyframes

  """

  active_index: int = ...

  """

  Current Keying Set index

  """

  def add(self, target_id: ID, data_path: str, index: int = -1, group_method: str = 'KEYINGSET', group_name: str = '') -> KeyingSetPath:

    """

    Add a new path for the Keying Set

    """

    ...

  def remove(self, path: KeyingSetPath) -> None:

    """

    Remove the given path from the Keying Set

    """

    ...

  def clear(self) -> None:

    """

    Remove all the paths from the Keying Set

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyingSets(bpy_struct):

  """

  Scene keying sets

  """

  active: KeyingSet = ...

  """

  Active Keying Set used to insert/delete keyframes

  """

  active_index: int = ...

  """

  Current Keying Set index (negative for 'builtin' and positive for 'absolute')

  """

  def new(self, idname: str = 'KeyingSet', name: str = 'KeyingSet') -> KeyingSet:

    """

    Add a new Keying Set to Scene

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KeyingSetsAll(bpy_struct):

  """

  All available keying sets

  """

  active: KeyingSet = ...

  """

  Active Keying Set used to insert/delete keyframes

  """

  active_index: int = ...

  """

  Current Keying Set index (negative for 'builtin' and positive for 'absolute')

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LatticePoint(bpy_struct):

  """

  Point in the lattice grid

  """

  co: typing.Tuple[float, float, float] = ...

  """

  Original undeformed location used to calculate the strength of the deform effect (edit/animate the Deformed Location instead)

  """

  co_deform: typing.Tuple[float, float, float] = ...

  groups: typing.Union[typing.Sequence[VertexGroupElement], typing.Mapping[str, VertexGroupElement], bpy_prop_collection] = ...

  """

  Weights for the vertex groups this point is member of

  """

  select: bool = ...

  """

  Selection status

  """

  weight_softbody: float = ...

  """

  Softbody goal weight

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LayerCollection(bpy_struct):

  """

  Layer collection

  """

  children: typing.Union[typing.Sequence[LayerCollection], typing.Mapping[str, LayerCollection], bpy_prop_collection] = ...

  """

  Child layer collections

  """

  collection: Collection = ...

  """

  Collection this layer collection is wrapping

  """

  exclude: bool = ...

  """

  Exclude from view layer

  """

  hide_viewport: bool = ...

  """

  Temporarily hide in viewport

  """

  holdout: bool = ...

  """

  Mask out objects in collection from view layer

  """

  indirect_only: bool = ...

  """

  Objects in collection only contribute indirectly (through shadows and reflections) in the view layer

  """

  is_visible: bool = ...

  """

  Whether this collection is visible for the view layer, take into account the collection parent

  """

  name: str = ...

  """

  Name of this view layer (same as its collection one)

  """

  def visible_get(self) -> bool:

    """

    Whether this collection is visible, take into account the collection parent and the viewport

    """

    ...

  def has_objects(self) -> bool:

    ...

  def has_selected_objects(self, view_layer: ViewLayer) -> bool:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LayerObjects(bpy_struct):

  """

  Collections of objects

  """

  active: Object = ...

  """

  Active object for this layer

  """

  selected: typing.Union[typing.Sequence[Object], typing.Mapping[str, Object], bpy_prop_collection] = ...

  """

  All the selected objects of this layer

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleAlphaModifiers(bpy_struct):

  """

  Alpha modifiers for changing line alphas

  """

  def new(self, name: str, type: str) -> LineStyleAlphaModifier:

    """

    Add a alpha modifier to line style

    """

    ...

  def remove(self, modifier: LineStyleAlphaModifier) -> None:

    """

    Remove a alpha modifier from line style

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleColorModifiers(bpy_struct):

  """

  Color modifiers for changing line colors

  """

  def new(self, name: str, type: str) -> LineStyleColorModifier:

    """

    Add a color modifier to line style

    """

    ...

  def remove(self, modifier: LineStyleColorModifier) -> None:

    """

    Remove a color modifier from line style

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifiers(bpy_struct):

  """

  Geometry modifiers for changing line geometries

  """

  def new(self, name: str, type: str) -> LineStyleGeometryModifier:

    """

    Add a geometry modifier to line style

    """

    ...

  def remove(self, modifier: LineStyleGeometryModifier) -> None:

    """

    Remove a geometry modifier from line style

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleModifier(bpy_struct):

  """

  Base type to define modifiers

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleTextureSlots(bpy_struct):

  """

  Collection of texture slots

  """

  @classmethod

  def add(cls) -> LineStyleTextureSlot:

    """

    add

    """

    ...

  @classmethod

  def create(cls, index: int) -> LineStyleTextureSlot:

    """

    create

    """

    ...

  @classmethod

  def clear(cls, index: int) -> None:

    """

    clear

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifiers(bpy_struct):

  """

  Thickness modifiers for changing line thickness

  """

  def new(self, name: str, type: str) -> LineStyleThicknessModifier:

    """

    Add a thickness modifier to line style

    """

    ...

  def remove(self, modifier: LineStyleThicknessModifier) -> None:

    """

    Remove a thickness modifier from line style

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Linesets(bpy_struct):

  """

  Line sets for associating lines and style parameters

  """

  active: FreestyleLineSet = ...

  """

  Active line set being displayed

  """

  active_index: int = ...

  """

  Index of active line set slot

  """

  def new(self, name: str) -> FreestyleLineSet:

    """

    Add a line set to scene render layer Freestyle settings

    """

    ...

  def remove(self, lineset: FreestyleLineSet) -> None:

    """

    Remove a line set from scene render layer Freestyle settings

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LoopColors(bpy_struct):

  """

  Collection of vertex colors

  """

  active: MeshLoopColorLayer = ...

  """

  Active vertex color layer

  """

  active_index: int = ...

  """

  Active vertex color index

  """

  def new(self, name: str = 'Col', do_init: bool = True) -> MeshLoopColorLayer:

    """

    Add a vertex color layer to Mesh

    """

    ...

  def remove(self, layer: MeshLoopColorLayer) -> None:

    """

    Remove a vertex color layer

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Macro(bpy_struct):

  """

  Storage of a macro operator being executed, or registered after execution

  """

  bl_description: str = ...

  bl_idname: str = ...

  bl_label: str = ...

  bl_options: typing.Set[str] = ...

  """

  Options for this operator type

  * ``REGISTER``
Register, Display in the info window and support the redo toolbar panel.

  * ``UNDO``
Undo, Push an undo event (needed for operator redo).

  * ``UNDO_GROUPED``
Grouped Undo, Push a single undo event for repeated instances of this operator.

  * ``BLOCKING``
Blocking, Block anything else from using the cursor.

  * ``MACRO``
Macro, Use to check if an operator is a macro.

  * ``GRAB_CURSOR``
Grab Pointer, Use so the operator grabs the mouse focus, enables wrapping when continuous grab is enabled.

  * ``GRAB_CURSOR_X``
Grab Pointer X, Grab, only warping the X axis.

  * ``GRAB_CURSOR_Y``
Grab Pointer Y, Grab, only warping the Y axis.

  * ``PRESET``
Preset, Display a preset button with the operators settings.

  * ``INTERNAL``
Internal, Removes the operator from search results.

  """

  bl_translation_context: str = ...

  bl_undo_group: str = ...

  name: str = ...

  properties: OperatorProperties = ...

  def report(self, type: typing.Set[str], message: str) -> None:

    """

    report

    """

    ...

  @classmethod

  def poll(cls, context: Context) -> bool:

    """

    Test if the operator can be called or not

    """

    ...

  def draw(self, context: Context) -> None:

    """

    Draw function for the operator

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaskLayer(bpy_struct):

  """

  Single layer used for masking pixels

  """

  alpha: float = ...

  """

  Render Opacity

  """

  blend: str = ...

  """

  Method of blending mask layers

  """

  falloff: str = ...

  """

  Falloff type the feather

  * ``SMOOTH``
Smooth, Smooth falloff.

  * ``SPHERE``
Sphere, Spherical falloff.

  * ``ROOT``
Root, Root falloff.

  * ``INVERSE_SQUARE``
Inverse Square, Inverse Square falloff.

  * ``SHARP``
Sharp, Sharp falloff.

  * ``LINEAR``
Linear, Linear falloff.

  """

  hide: bool = ...

  """

  Restrict visibility in the viewport

  """

  hide_render: bool = ...

  """

  Restrict renderability

  """

  hide_select: bool = ...

  """

  Restrict selection in the viewport

  """

  invert: bool = ...

  """

  Invert the mask black/white

  """

  name: str = ...

  """

  Unique name of layer

  """

  select: bool = ...

  """

  Layer is selected for editing in the Dope Sheet

  """

  splines: typing.Union[MaskSplines, typing.Sequence[MaskSpline], typing.Mapping[str, MaskSpline], bpy_prop_collection] = ...

  """

  Collection of splines which defines this layer

  """

  use_fill_holes: bool = ...

  """

  Calculate holes when filling overlapping curves

  """

  use_fill_overlap: bool = ...

  """

  Calculate self intersections and overlap before filling

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaskLayers(bpy_struct):

  """

  Collection of layers used by mask

  """

  active: MaskLayer = ...

  """

  Active layer in this mask

  """

  def new(self, name: str = '') -> MaskLayer:

    """

    Add layer to this mask

    """

    ...

  def remove(self, layer: MaskLayer) -> None:

    """

    Remove layer from this mask

    """

    ...

  def clear(self) -> None:

    """

    Remove all mask layers

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaskParent(bpy_struct):

  """

  Parenting settings for masking element

  """

  id: ID = ...

  """

  ID-block to which masking element would be parented to or to its property

  """

  id_type: str = ...

  """

  Type of ID-block that can be used

  """

  parent: str = ...

  """

  Name of parent object in specified data-block to which parenting happens

  """

  sub_parent: str = ...

  """

  Name of parent sub-object in specified data-block to which parenting happens

  """

  type: str = ...

  """

  Parent Type

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaskSpline(bpy_struct):

  """

  Single spline used for defining mask shape

  """

  offset_mode: str = ...

  """

  The method used for calculating the feather offset

  * ``EVEN``
Even, Calculate even feather offset.

  * ``SMOOTH``
Smooth, Calculate feather offset as a second curve.

  """

  points: typing.Union[MaskSplinePoints, typing.Sequence[MaskSplinePoint], typing.Mapping[str, MaskSplinePoint], bpy_prop_collection] = ...

  """

  Collection of points

  """

  use_cyclic: bool = ...

  """

  Make this spline a closed loop

  """

  use_fill: bool = ...

  """

  Make this spline filled

  """

  use_self_intersection_check: bool = ...

  """

  Prevent feather from self-intersections

  """

  weight_interpolation: str = ...

  """

  The type of weight interpolation for spline

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaskSplinePoint(bpy_struct):

  """

  Single point in spline used for defining mask

  """

  co: typing.Tuple[float, float] = ...

  """

  Coordinates of the control point

  """

  feather_points: typing.Union[typing.Sequence[MaskSplinePointUW], typing.Mapping[str, MaskSplinePointUW], bpy_prop_collection] = ...

  """

  Points defining feather

  """

  handle_left: typing.Tuple[float, float] = ...

  """

  Coordinates of the first handle

  """

  handle_left_type: str = ...

  """

  Handle type

  """

  handle_right: typing.Tuple[float, float] = ...

  """

  Coordinates of the second handle

  """

  handle_right_type: str = ...

  """

  Handle type

  """

  handle_type: str = ...

  """

  Handle type

  """

  parent: MaskParent = ...

  select: bool = ...

  """

  Selection status

  """

  weight: float = ...

  """

  Weight of the point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaskSplinePointUW(bpy_struct):

  """

  Single point in spline segment defining feather

  """

  select: bool = ...

  """

  Selection status

  """

  u: float = ...

  """

  U coordinate of point along spline segment

  """

  weight: float = ...

  """

  Weight of feather point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaskSplinePoints(bpy_struct):

  """

  Collection of masking spline points

  """

  def add(self, count: int) -> None:

    """

    Add a number of point to this spline

    """

    ...

  def remove(self, point: MaskSplinePoint) -> None:

    """

    Remove a point from a spline

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaskSplines(bpy_struct):

  """

  Collection of masking splines

  """

  active: MaskSpline = ...

  """

  Active spline of masking layer

  """

  active_point: MaskSplinePoint = ...

  """

  Active spline of masking layer

  """

  def new(self) -> MaskSpline:

    """

    Add a new spline to the layer

    """

    ...

  def remove(self, spline: MaskSpline) -> None:

    """

    Remove a spline from a layer

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaterialGPencilStyle(bpy_struct):

  alignment_mode: str = ...

  """

  Defines how align Dots and Boxes with drawing path and object rotation

  * ``PATH``
Path, Follow stroke drawing path and object rotation.

  * ``OBJECT``
Object, Follow object rotation only.

  * ``FIXED``
Fixed, Do not follow drawing path or object rotation and keeps aligned with viewport.

  """

  color: typing.Tuple[float, float, float, float] = ...

  fill_color: typing.Tuple[float, float, float, float] = ...

  """

  Color for filling region bounded by each stroke

  """

  fill_image: Image = ...

  fill_style: str = ...

  """

  Select style used to fill strokes

  * ``SOLID``
Solid, Fill area with solid color.

  * ``GRADIENT``
Gradient, Fill area with gradient color.

  * ``TEXTURE``
Texture, Fill area with image texture.

  """

  flip: bool = ...

  """

  Flip filling colors

  """

  ghost: bool = ...

  """

  Display strokes using this color when showing onion skins

  """

  gradient_type: str = ...

  """

  Select type of gradient used to fill strokes

  * ``LINEAR``
Linear, Fill area with gradient color.

  * ``RADIAL``
Radial, Fill area with radial gradient.

  """

  hide: bool = ...

  """

  Set color Visibility

  """

  is_fill_visible: bool = ...

  """

  True when opacity of fill is set high enough to be visible

  """

  is_stroke_visible: bool = ...

  """

  True when opacity of stroke is set high enough to be visible

  """

  lock: bool = ...

  """

  Protect color from further editing and/or frame changes

  """

  mix_color: typing.Tuple[float, float, float, float] = ...

  """

  Color for mixing with primary filling color

  """

  mix_factor: float = ...

  """

  Mix Factor

  """

  mix_stroke_factor: float = ...

  """

  Mix Stroke Factor

  """

  mode: str = ...

  """

  Select draw mode for stroke

  * ``LINE``
Line, Draw strokes using a continuous line.

  * ``DOTS``
Dots, Draw strokes using separated dots.

  * ``BOX``
Squares, Draw strokes using separated squares.

  """

  pass_index: int = ...

  """

  Index number for the "Color Index" pass

  """

  pixel_size: float = ...

  """

  Texture Pixel Size factor along the stroke

  """

  show_fill: bool = ...

  """

  Show stroke fills of this material

  """

  show_stroke: bool = ...

  """

  Show stroke lines of this material

  """

  stroke_image: Image = ...

  stroke_style: str = ...

  """

  Select style used to draw strokes

  * ``SOLID``
Solid, Draw strokes with solid color.

  * ``TEXTURE``
Texture, Draw strokes using texture.

  """

  texture_angle: float = ...

  """

  Texture Orientation Angle

  """

  texture_clamp: bool = ...

  """

  Do not repeat texture and clamp to one instance only

  """

  texture_offset: typing.Tuple[float, float] = ...

  """

  Shift Texture in 2d Space

  """

  texture_scale: typing.Tuple[float, float] = ...

  """

  Scale Factor for Texture

  """

  use_fill_holdout: bool = ...

  """

  Remove the color from underneath this stroke by using it as a mask

  """

  use_overlap_strokes: bool = ...

  """

  Disable stencil and overlap self intersections with alpha materials

  """

  use_stroke_holdout: bool = ...

  """

  Remove the color from underneath this stroke by using it as a mask

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaterialSlot(bpy_struct):

  """

  Material slot in an object

  """

  link: str = ...

  """

  Link material to object or the object's data

  """

  material: Material = ...

  """

  Material data-block used by this material slot

  """

  name: str = ...

  """

  Material slot name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Menu(bpy_struct):

  """

  Editor menu containing buttons

  """

  bl_description: str = ...

  bl_idname: str = ...

  """

  If this is set, the menu gets a custom ID, otherwise it takes the name of the class used to define the menu (for example, if the class name is "OBJECT_MT_hello", and bl_idname is not set by the script, then bl_idname = "OBJECT_MT_hello")

  """

  bl_label: str = ...

  """

  The menu label

  """

  bl_owner_id: str = ...

  bl_translation_context: str = ...

  layout: UILayout = ...

  """

  Defines the structure of the menu in the UI

  """

  @classmethod

  def poll(cls, context: Context) -> bool:

    """

    If this method returns a non-null output, then the menu can be drawn

    """

    ...

  def draw(self, context: Context) -> None:

    """

    Draw UI elements into the menu UI layout

    """

    ...

  def draw_preset(self, _context: typing.Any) -> None:

    """

    Define these on the subclass:
- preset_operator (string)
- preset_subdir (string)

    Optionally:
- preset_add_operator (string)
- preset_extensions (set of strings)
- preset_operator_defaults (dict of keyword args)

    """

    ...

  def path_menu(self, searchpaths: typing.Sequence[str], operator: str) -> None:

    """

    Populate a menu from a list of paths.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshCacheVertexVelocity(bpy_struct):

  """

  Velocity attribute of an Alembic mesh

  """

  velocity: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshEdge(bpy_struct):

  """

  Edge in a Mesh data-block

  """

  bevel_weight: float = ...

  """

  Weight used by the Bevel modifier

  """

  crease: float = ...

  """

  Weight used by the Subdivision Surface modifier for creasing

  """

  hide: bool = ...

  index: int = ...

  """

  Index of this edge

  """

  is_loose: bool = ...

  """

  Loose edge

  """

  select: bool = ...

  use_edge_sharp: bool = ...

  """

  Sharp edge for the Edge Split modifier

  """

  use_freestyle_mark: bool = ...

  """

  Edge mark for Freestyle line rendering

  """

  use_seam: bool = ...

  """

  Seam edge for UV unwrapping

  """

  vertices: typing.Tuple[int, int] = ...

  """

  Vertex indices

  """

  key: typing.Any = ...

  """

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshEdges(bpy_struct):

  """

  Collection of mesh edges

  """

  def add(self, count: int) -> None:

    """

    add

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshFaceMap(bpy_struct):

  value: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshFaceMapLayer(bpy_struct):

  """

  Per-face map index

  """

  data: typing.Union[typing.Sequence[MeshFaceMap], typing.Mapping[str, MeshFaceMap], bpy_prop_collection] = ...

  name: str = ...

  """

  Name of face-map layer

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshFaceMapLayers(bpy_struct):

  """

  Collection of mesh face-maps

  """

  active: MeshFaceMapLayer = ...

  def new(self, name: str = 'Face Map') -> MeshFaceMapLayer:

    """

    Add a float property layer to Mesh

    """

    ...

  def remove(self, layer: MeshFaceMapLayer) -> None:

    """

    Remove a face map layer

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshLoop(bpy_struct):

  """

  Loop in a Mesh data-block

  """

  bitangent: typing.Tuple[float, float, float] = ...

  """

  Bitangent vector of this vertex for this polygon (must be computed beforehand using calc_tangents, *use it only if really needed*, slower access than bitangent_sign)

  """

  bitangent_sign: float = ...

  """

  Sign of the bitangent vector of this vertex for this polygon (must be computed beforehand using calc_tangents, bitangent = bitangent_sign * cross(normal, tangent))

  """

  edge_index: int = ...

  """

  Edge index

  """

  index: int = ...

  """

  Index of this loop

  """

  normal: typing.Tuple[float, float, float] = ...

  """

  Local space unit length split normal vector of this vertex for this polygon (must be computed beforehand using calc_normals_split or calc_tangents)

  """

  tangent: typing.Tuple[float, float, float] = ...

  """

  Local space unit length tangent vector of this vertex for this polygon (must be computed beforehand using calc_tangents)

  """

  vertex_index: int = ...

  """

  Vertex index

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshLoopColor(bpy_struct):

  """

  Vertex loop colors in a Mesh

  """

  color: typing.Tuple[float, float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshLoopColorLayer(bpy_struct):

  """

  Layer of vertex colors in a Mesh data-block

  """

  active: bool = ...

  """

  Sets the layer as active for display and editing

  """

  active_render: bool = ...

  """

  Sets the layer as active for rendering

  """

  data: typing.Union[typing.Sequence[MeshLoopColor], typing.Mapping[str, MeshLoopColor], bpy_prop_collection] = ...

  name: str = ...

  """

  Name of Vertex color layer

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshLoopTriangle(bpy_struct):

  """

  Tessellated triangle in a Mesh data-block

  """

  area: float = ...

  """

  Area of this triangle

  """

  index: int = ...

  """

  Index of this loop triangle

  """

  loops: typing.Tuple[int, int, int] = ...

  """

  Indices of mesh loops that make up the triangle

  """

  material_index: int = ...

  normal: typing.Tuple[float, float, float] = ...

  """

  Local space unit length normal vector for this triangle

  """

  polygon_index: int = ...

  """

  Index of mesh polygon that the triangle is a part of

  """

  split_normals: typing.Tuple[typing.Tuple[float, float, float], typing.Tuple[float, float, float], typing.Tuple[float, float, float]] = ...

  """

  Local space unit length split normals vectors of the vertices of this triangle (must be computed beforehand using calc_normals_split or calc_tangents)

  """

  use_smooth: bool = ...

  vertices: typing.Tuple[int, int, int] = ...

  """

  Indices of triangle vertices

  """

  center: typing.Any = ...

  """

  The midpoint of the face.

  (readonly)

  """

  edge_keys: typing.Any = ...

  """

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshLoopTriangles(bpy_struct):

  """

  Tessellation of mesh polygons into triangles

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshLoops(bpy_struct):

  """

  Collection of mesh loops

  """

  def add(self, count: int) -> None:

    """

    add

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshPaintMaskLayer(bpy_struct):

  """

  Per-vertex paint mask data

  """

  data: typing.Union[typing.Sequence[MeshPaintMaskProperty], typing.Mapping[str, MeshPaintMaskProperty], bpy_prop_collection] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshPaintMaskProperty(bpy_struct):

  """

  Floating point paint mask value

  """

  value: float = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshPolygon(bpy_struct):

  """

  Polygon in a Mesh data-block

  """

  area: float = ...

  """

  Read only area of this polygon

  """

  center: typing.Tuple[float, float, float] = ...

  """

  Center of this polygon

  """

  hide: bool = ...

  index: int = ...

  """

  Index of this polygon

  """

  loop_start: int = ...

  """

  Index of the first loop of this polygon

  """

  loop_total: int = ...

  """

  Number of loops used by this polygon

  """

  material_index: int = ...

  normal: typing.Tuple[float, float, float] = ...

  """

  Local space unit length normal vector for this polygon

  """

  select: bool = ...

  use_freestyle_mark: bool = ...

  """

  Face mark for Freestyle line rendering

  """

  use_smooth: bool = ...

  vertices: typing.Tuple[int, int, int] = ...

  """

  Vertex indices

  """

  edge_keys: typing.Any = ...

  """

  (readonly)

  """

  loop_indices: typing.Any = ...

  """

  (readonly)

  """

  def flip(self) -> None:

    """

    Invert winding of this polygon (flip its normal)

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshPolygonFloatProperty(bpy_struct):

  """

  User defined floating point number value in a float properties layer

  """

  value: float = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshPolygonFloatPropertyLayer(bpy_struct):

  """

  User defined layer of floating point number values

  """

  data: typing.Union[typing.Sequence[MeshPolygonFloatProperty], typing.Mapping[str, MeshPolygonFloatProperty], bpy_prop_collection] = ...

  name: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshPolygonIntProperty(bpy_struct):

  """

  User defined integer number value in an integer properties layer

  """

  value: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshPolygonIntPropertyLayer(bpy_struct):

  """

  User defined layer of integer number values

  """

  data: typing.Union[typing.Sequence[MeshPolygonIntProperty], typing.Mapping[str, MeshPolygonIntProperty], bpy_prop_collection] = ...

  name: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshPolygonStringProperty(bpy_struct):

  """

  User defined string text value in a string properties layer

  """

  value: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshPolygonStringPropertyLayer(bpy_struct):

  """

  User defined layer of string text values

  """

  data: typing.Union[typing.Sequence[MeshPolygonStringProperty], typing.Mapping[str, MeshPolygonStringProperty], bpy_prop_collection] = ...

  name: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshPolygons(bpy_struct):

  """

  Collection of mesh polygons

  """

  active: int = ...

  """

  The active polygon for this mesh

  """

  def add(self, count: int) -> None:

    """

    add

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshSkinVertex(bpy_struct):

  """

  Per-vertex skin data for use with the Skin modifier

  """

  radius: typing.Tuple[float, float] = ...

  """

  Radius of the skin

  """

  use_loose: bool = ...

  """

  If vertex has multiple adjacent edges, it is hulled to them directly

  """

  use_root: bool = ...

  """

  Vertex is a root for rotation calculations and armature generation, setting this flag does not clear other roots in the same mesh island

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshSkinVertexLayer(bpy_struct):

  """

  Per-vertex skin data for use with the Skin modifier

  """

  data: typing.Union[typing.Sequence[MeshSkinVertex], typing.Mapping[str, MeshSkinVertex], bpy_prop_collection] = ...

  name: str = ...

  """

  Name of skin layer

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshStatVis(bpy_struct):

  distort_max: float = ...

  """

  Maximum angle to display

  """

  distort_min: float = ...

  """

  Minimum angle to display

  """

  overhang_axis: str = ...

  overhang_max: float = ...

  """

  Maximum angle to display

  """

  overhang_min: float = ...

  """

  Minimum angle to display

  """

  sharp_max: float = ...

  """

  Maximum angle to display

  """

  sharp_min: float = ...

  """

  Minimum angle to display

  """

  thickness_max: float = ...

  """

  Maximum for measuring thickness

  """

  thickness_min: float = ...

  """

  Minimum for measuring thickness

  """

  thickness_samples: int = ...

  """

  Number of samples to test per face

  """

  type: str = ...

  """

  Type of data to visualize/check

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshUVLoop(bpy_struct):

  pin_uv: bool = ...

  select: bool = ...

  uv: typing.Tuple[float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshUVLoopLayer(bpy_struct):

  active: bool = ...

  """

  Set the map as active for display and editing

  """

  active_clone: bool = ...

  """

  Set the map as active for cloning

  """

  active_render: bool = ...

  """

  Set the map as active for rendering

  """

  data: typing.Union[typing.Sequence[MeshUVLoop], typing.Mapping[str, MeshUVLoop], bpy_prop_collection] = ...

  name: str = ...

  """

  Name of UV map

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshVertColor(bpy_struct):

  """

  Vertex colors in a Mesh

  """

  color: typing.Tuple[float, float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshVertColorLayer(bpy_struct):

  """

  Layer of sculpt vertex colors in a Mesh data-block

  """

  active: bool = ...

  """

  Sets the sculpt vertex color layer as active for display and editing

  """

  active_render: bool = ...

  """

  Sets the sculpt vertex color layer as active for rendering

  """

  data: typing.Union[typing.Sequence[MeshVertColor], typing.Mapping[str, MeshVertColor], bpy_prop_collection] = ...

  name: str = ...

  """

  Name of Sculpt Vertex color layer

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshVertex(bpy_struct):

  """

  Vertex in a Mesh data-block

  """

  bevel_weight: float = ...

  """

  Weight used by the Bevel modifier 'Only Vertices' option

  """

  co: typing.Tuple[float, float, float] = ...

  groups: typing.Union[typing.Sequence[VertexGroupElement], typing.Mapping[str, VertexGroupElement], bpy_prop_collection] = ...

  """

  Weights for the vertex groups this vertex is member of

  """

  hide: bool = ...

  index: int = ...

  """

  Index of this vertex

  """

  normal: typing.Tuple[float, float, float] = ...

  """

  Vertex Normal

  """

  select: bool = ...

  undeformed_co: typing.Tuple[float, float, float] = ...

  """

  For meshes with modifiers applied, the coordinate of the vertex with no deforming modifiers applied, as used for generated texture coordinates

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshVertexFloatProperty(bpy_struct):

  """

  User defined floating point number value in a float properties layer

  """

  value: float = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshVertexFloatPropertyLayer(bpy_struct):

  """

  User defined layer of floating point number values

  """

  data: typing.Union[typing.Sequence[MeshVertexFloatProperty], typing.Mapping[str, MeshVertexFloatProperty], bpy_prop_collection] = ...

  name: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshVertexIntProperty(bpy_struct):

  """

  User defined integer number value in an integer properties layer

  """

  value: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshVertexIntPropertyLayer(bpy_struct):

  """

  User defined layer of integer number values

  """

  data: typing.Union[typing.Sequence[MeshVertexIntProperty], typing.Mapping[str, MeshVertexIntProperty], bpy_prop_collection] = ...

  name: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshVertexStringProperty(bpy_struct):

  """

  User defined string text value in a string properties layer

  """

  value: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshVertexStringPropertyLayer(bpy_struct):

  """

  User defined layer of string text values

  """

  data: typing.Union[typing.Sequence[MeshVertexStringProperty], typing.Mapping[str, MeshVertexStringProperty], bpy_prop_collection] = ...

  name: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshVertices(bpy_struct):

  """

  Collection of mesh vertices

  """

  def add(self, count: int) -> None:

    """

    add

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MetaBallElements(bpy_struct):

  """

  Collection of metaball elements

  """

  active: MetaElement = ...

  """

  Last selected element

  """

  def new(self, type: str = 'BALL') -> MetaElement:

    """

    Add a new element to the metaball

    """

    ...

  def remove(self, element: MetaElement) -> None:

    """

    Remove an element from the metaball

    """

    ...

  def clear(self) -> None:

    """

    Remove all elements from the metaball

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MetaElement(bpy_struct):

  """

  Blobby element in a Metaball data-block

  """

  co: typing.Tuple[float, float, float] = ...

  hide: bool = ...

  """

  Hide element

  """

  radius: float = ...

  rotation: typing.Tuple[float, float, float, float] = ...

  """

  Normalized quaternion rotation

  """

  select: bool = ...

  """

  Select element

  """

  size_x: float = ...

  """

  Size of element, use of components depends on element type

  """

  size_y: float = ...

  """

  Size of element, use of components depends on element type

  """

  size_z: float = ...

  """

  Size of element, use of components depends on element type

  """

  stiffness: float = ...

  """

  Stiffness defines how much of the element to fill

  """

  type: str = ...

  """

  Metaball types

  """

  use_negative: bool = ...

  """

  Set metaball as negative one

  """

  use_scale_stiffness: bool = ...

  """

  Scale stiffness instead of radius

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Modifier(bpy_struct):

  """

  Modifier affecting the geometry data of an object

  """

  name: str = ...

  """

  Modifier name

  """

  show_expanded: bool = ...

  """

  Set modifier expanded in the user interface

  """

  show_in_editmode: bool = ...

  """

  Display modifier in Edit mode

  """

  show_on_cage: bool = ...

  """

  Adjust edit cage to modifier result

  """

  show_render: bool = ...

  """

  Use modifier during render

  """

  show_viewport: bool = ...

  """

  Display modifier in viewport

  """

  type: str = ...

  """

  * ``DATA_TRANSFER``
Data Transfer, Transfer several types of data (vertex groups, UV maps, vertex colors, custom normals) from one mesh to another.

  * ``MESH_CACHE``
Mesh Cache, Deform the mesh using an external frame-by-frame vertex transform cache.

  * ``MESH_SEQUENCE_CACHE``
Mesh Sequence Cache, Deform the mesh or curve using an external mesh cache in Alembic format.

  * ``NORMAL_EDIT``
Normal Edit, Modify the direction of the surface normals.

  * ``WEIGHTED_NORMAL``
Weighted Normal, Modify the direction of the surface normals using a weighting method.

  * ``UV_PROJECT``
UV Project, Project the UV map coordinates from the negative Z axis of another object.

  * ``UV_WARP``
UV Warp, Transform the UV map using the difference between two objects.

  * ``VERTEX_WEIGHT_EDIT``
Vertex Weight Edit, Modify of the weights of a vertex group.

  * ``VERTEX_WEIGHT_MIX``
Vertex Weight Mix, Mix the weights of two vertex groups.

  * ``VERTEX_WEIGHT_PROXIMITY``
Vertex Weight Proximity, Set the vertex group weights based on the distance to another target object.

  * ``ARRAY``
Array, Create copies of the shape with offsets.

  * ``BEVEL``
Bevel, Generate sloped corners by adding geometry to the mesh's edges or vertices.

  * ``BOOLEAN``
Boolean, Use another shape to cut, combine or perform a difference operation.

  * ``BUILD``
Build, Cause the faces of the mesh object to appear or disappear one after the other over time.

  * ``DECIMATE``
Decimate, Reduce the geometry density.

  * ``EDGE_SPLIT``
Edge Split, Split away joined faces at the edges.

  * ``MASK``
Mask, Dynamically hide vertices based on a vertex group or armature.

  * ``MIRROR``
Mirror, Mirror along the local X, Y and/or Z axes, over the object origin.

  * ``MESH_TO_VOLUME``
Mesh to Volume.

  * ``MULTIRES``
Multiresolution, Subdivide the mesh in a way that allows editing the higher subdivision levels.

  * ``REMESH``
Remesh, Generate new mesh topology based on the current shape.

  * ``SCREW``
Screw, Lathe around an axis, treating the input mesh as a profile.

  * ``SKIN``
Skin, Create a solid shape from vertices and edges, using the vertex radius to define the thickness.

  * ``SOLIDIFY``
Solidify,  Make the surface thick.

  * ``SUBSURF``
Subdivision Surface, Split the faces into smaller parts, giving it a smoother appearance.

  * ``TRIANGULATE``
Triangulate, Convert all polygons to triangles.

  * ``VOLUME_TO_MESH``
Volume to Mesh.

  * ``WELD``
Weld, Find groups of vertices closer than dist and merges them together.

  * ``WIREFRAME``
Wireframe, Convert faces into thickened edges.

  * ``ARMATURE``
Armature, Deform the shape using an armature object.

  * ``CAST``
Cast, Shift the shape towards a predefined primitive.

  * ``CURVE``
Curve, Bend the mesh using a curve object.

  * ``DISPLACE``
Displace, Offset vertices based on a texture.

  * ``HOOK``
Hook, Deform specific points using another object.

  * ``LAPLACIANDEFORM``
Laplacian Deform, Deform based a series of anchor points.

  * ``LATTICE``
Lattice, Deform using the shape of a lattice object.

  * ``MESH_DEFORM``
Mesh Deform, Deform using a different mesh, which acts as a deformation cage.

  * ``SHRINKWRAP``
Shrinkwrap, Project the shape onto another object.

  * ``SIMPLE_DEFORM``
Simple Deform, Deform the shape by twisting, bending, tapering or stretching.

  * ``SMOOTH``
Smooth, Smooth the mesh by flattening the angles between adjacent faces.

  * ``CORRECTIVE_SMOOTH``
Smooth Corrective, Smooth the mesh while still preserving the volume.

  * ``LAPLACIANSMOOTH``
Smooth Laplacian, Reduce the noise on a mesh surface with minimal changes to its shape.

  * ``SURFACE_DEFORM``
Surface Deform, Transfer motion from another mesh.

  * ``WARP``
Warp, Warp parts of a mesh to a new location in a very flexible way thanks to 2 specified objects.

  * ``WAVE``
Wave, Adds a ripple-like motion to an object’s geometry.

  * ``VOLUME_DISPLACE``
Volume Displace, Deform volume based on noise or other vector fields.

  * ``CLOTH``
Cloth.

  * ``COLLISION``
Collision.

  * ``DYNAMIC_PAINT``
Dynamic Paint.

  * ``EXPLODE``
Explode, Break apart the mesh faces and let them follow particles.

  * ``FLUID``
Fluid.

  * ``OCEAN``
Ocean, Generate a moving ocean surface.

  * ``PARTICLE_INSTANCE``
Particle Instance.

  * ``PARTICLE_SYSTEM``
Particle System, Spawn particles from the shape.

  * ``SOFT_BODY``
Soft Body.

  * ``SURFACE``
Surface.

  * ``SIMULATION``
Simulation.

  """

  use_apply_on_spline: bool = ...

  """

  Apply this and all preceding deformation modifiers on splines' points rather than on filled curve/surface

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MotionPath(bpy_struct):

  """

  Cache of the worldspace positions of an element over a frame range

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Custom color for motion path

  """

  frame_end: int = ...

  """

  End frame of the stored range

  """

  frame_start: int = ...

  """

  Starting frame of the stored range

  """

  is_modified: bool = ...

  """

  Path is being edited

  """

  length: int = ...

  """

  Number of frames cached

  """

  line_thickness: int = ...

  """

  Line thickness for drawing path

  """

  lines: bool = ...

  """

  Draw straight lines between keyframe points

  """

  points: typing.Union[typing.Sequence[MotionPathVert], typing.Mapping[str, MotionPathVert], bpy_prop_collection] = ...

  """

  Cached positions per frame

  """

  use_bone_head: bool = ...

  """

  For PoseBone paths, use the bone head location when calculating this path

  """

  use_custom_color: bool = ...

  """

  Use custom color for this motion path

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MotionPathVert(bpy_struct):

  """

  Cached location on path

  """

  co: typing.Tuple[float, float, float] = ...

  select: bool = ...

  """

  Path point is selected for editing

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieClipProxy(bpy_struct):

  """

  Proxy parameters for a movie clip

  """

  build_100: bool = ...

  """

  Build proxy resolution 100% of the original footage dimension

  """

  build_25: bool = ...

  """

  Build proxy resolution 25% of the original footage dimension

  """

  build_50: bool = ...

  """

  Build proxy resolution 50% of the original footage dimension

  """

  build_75: bool = ...

  """

  Build proxy resolution 75% of the original footage dimension

  """

  build_free_run: bool = ...

  """

  Build free run time code index

  """

  build_free_run_rec_date: bool = ...

  """

  Build free run time code index using Record Date/Time

  """

  build_record_run: bool = ...

  """

  Build record run time code index

  """

  build_undistorted_100: bool = ...

  """

  Build proxy resolution 100% of the original undistorted footage dimension

  """

  build_undistorted_25: bool = ...

  """

  Build proxy resolution 25% of the original undistorted footage dimension

  """

  build_undistorted_50: bool = ...

  """

  Build proxy resolution 50% of the original undistorted footage dimension

  """

  build_undistorted_75: bool = ...

  """

  Build proxy resolution 75% of the original undistorted footage dimension

  """

  directory: str = ...

  """

  Location to store the proxy files

  """

  quality: int = ...

  """

  JPEG quality of proxy images

  """

  timecode: str = ...

  """

  * ``NONE``
No TC in use.

  * ``RECORD_RUN``
Record Run, Use images in the order they are recorded.

  * ``FREE_RUN``
Free Run, Use global timestamp written by recording device.

  * ``FREE_RUN_REC_DATE``
Free Run (rec date), Interpolate a global timestamp using the record date and time written by recording device.

  * ``FREE_RUN_NO_GAPS``
Free Run No Gaps, Record run, but ignore timecode, changes in framerate or dropouts.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieClipScopes(bpy_struct):

  """

  Scopes for statistical view of a movie clip

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieClipUser(bpy_struct):

  """

  Parameters defining how a MovieClip data-block is used by another data-block

  """

  frame_current: int = ...

  """

  Current frame number in movie or image sequence

  """

  proxy_render_size: str = ...

  """

  Draw preview using full resolution or different proxy resolutions

  """

  use_render_undistorted: bool = ...

  """

  Render preview using undistorted proxy

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieReconstructedCamera(bpy_struct):

  """

  Match-moving reconstructed camera data from tracker

  """

  average_error: float = ...

  """

  Average error of reconstruction

  """

  frame: int = ...

  """

  Frame number marker is keyframed on

  """

  matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Worldspace transformation matrix

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTracking(bpy_struct):

  """

  Match-moving data for tracking

  """

  active_object_index: int = ...

  """

  Index of active object

  """

  camera: MovieTrackingCamera = ...

  dopesheet: MovieTrackingDopesheet = ...

  objects: typing.Union[MovieTrackingObjects, typing.Sequence[MovieTrackingObject], typing.Mapping[str, MovieTrackingObject], bpy_prop_collection] = ...

  """

  Collection of objects in this tracking data object

  """

  plane_tracks: typing.Union[MovieTrackingPlaneTracks, typing.Sequence[MovieTrackingPlaneTrack], typing.Mapping[str, MovieTrackingPlaneTrack], bpy_prop_collection] = ...

  """

  Collection of plane tracks in this tracking data object

  """

  reconstruction: MovieTrackingReconstruction = ...

  settings: MovieTrackingSettings = ...

  stabilization: MovieTrackingStabilization = ...

  tracks: typing.Union[MovieTrackingTracks, typing.Sequence[MovieTrackingTrack], typing.Mapping[str, MovieTrackingTrack], bpy_prop_collection] = ...

  """

  Collection of tracks in this tracking data object

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingCamera(bpy_struct):

  """

  Match-moving camera data for tracking

  """

  brown_k1: float = ...

  """

  First coefficient of fourth order Brown-Conrady radial distortion

  """

  brown_k2: float = ...

  """

  Second coefficient of fourth order Brown-Conrady radial distortion

  """

  brown_k3: float = ...

  """

  Third coefficient of fourth order Brown-Conrady radial distortion

  """

  brown_k4: float = ...

  """

  Fourth coefficient of fourth order Brown-Conrady radial distortion

  """

  brown_p1: float = ...

  """

  First coefficient of second order Brown-Conrady tangential distortion

  """

  brown_p2: float = ...

  """

  Second coefficient of second order Brown-Conrady tangential distortion

  """

  distortion_model: str = ...

  """

  Distortion model used for camera lenses

  * ``POLYNOMIAL``
Polynomial, Radial distortion model which fits common cameras.

  * ``DIVISION``
Divisions, Division distortion model which better represents wide-angle cameras.

  * ``NUKE``
Nuke, Nuke distortion model.

  * ``BROWN``
Brown, Brown-Conrady distortion model.

  """

  division_k1: float = ...

  """

  First coefficient of second order division distortion

  """

  division_k2: float = ...

  """

  Second coefficient of second order division distortion

  """

  focal_length: float = ...

  """

  Camera's focal length

  """

  focal_length_pixels: float = ...

  """

  Camera's focal length

  """

  k1: float = ...

  """

  First coefficient of third order polynomial radial distortion

  """

  k2: float = ...

  """

  Second coefficient of third order polynomial radial distortion

  """

  k3: float = ...

  """

  Third coefficient of third order polynomial radial distortion

  """

  nuke_k1: float = ...

  """

  First coefficient of second order Nuke distortion

  """

  nuke_k2: float = ...

  """

  Second coefficient of second order Nuke distortion

  """

  pixel_aspect: float = ...

  """

  Pixel aspect ratio

  """

  principal: typing.Tuple[float, float] = ...

  """

  Optical center of lens

  """

  sensor_width: float = ...

  """

  Width of CCD sensor in millimeters

  """

  units: str = ...

  """

  Units used for camera focal length

  * ``PIXELS``
px, Use pixels for units of focal length.

  * ``MILLIMETERS``
mm, Use millimeters for units of focal length.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingDopesheet(bpy_struct):

  """

  Match-moving dopesheet data

  """

  show_hidden: bool = ...

  """

  Include channels from objects/bone that aren't visible

  """

  show_only_selected: bool = ...

  """

  Only include channels relating to selected objects and data

  """

  sort_method: str = ...

  """

  Method to be used to sort channels in dopesheet view

  * ``NAME``
Name, Sort channels by their names.

  * ``LONGEST``
Longest, Sort channels by longest tracked segment.

  * ``TOTAL``
Total, Sort channels by overall amount of tracked segments.

  * ``AVERAGE_ERROR``
Average Error, Sort channels by average reprojection error of tracks after solve.

  """

  use_invert_sort: bool = ...

  """

  Invert sort order of dopesheet channels

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingMarker(bpy_struct):

  """

  Match-moving marker data for tracking

  """

  co: typing.Tuple[float, float] = ...

  """

  Marker position at frame in normalized coordinates

  """

  frame: int = ...

  """

  Frame number marker is keyframed on

  """

  is_keyed: bool = ...

  """

  Whether the position of the marker is keyframed or tracked

  """

  mute: bool = ...

  """

  Is marker muted for current frame

  """

  pattern_bound_box: typing.Tuple[typing.Tuple[float, float], typing.Tuple[float, float]] = ...

  """

  Pattern area bounding box in normalized coordinates

  """

  pattern_corners: typing.Tuple[typing.Tuple[float, float], typing.Tuple[float, float], typing.Tuple[float, float], typing.Tuple[float, float]] = ...

  """

  Array of coordinates which represents pattern's corners in normalized coordinates relative to marker position

  """

  search_max: typing.Tuple[float, float] = ...

  """

  Right-bottom corner of search area in normalized coordinates relative to marker position

  """

  search_min: typing.Tuple[float, float] = ...

  """

  Left-bottom corner of search area in normalized coordinates relative to marker position

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingMarkers(bpy_struct):

  """

  Collection of markers for movie tracking track

  """

  def find_frame(self, frame: int, exact: bool = True) -> MovieTrackingMarker:

    """

    Get marker for specified frame

    """

    ...

  def insert_frame(self, frame: int, co: typing.Tuple[float, float] = (0.0, 0.0)) -> MovieTrackingMarker:

    """

    Insert a new marker at the specified frame

    """

    ...

  def delete_frame(self, frame: int) -> None:

    """

    Delete marker at specified frame

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingObject(bpy_struct):

  """

  Match-moving object tracking and reconstruction data

  """

  is_camera: bool = ...

  """

  Object is used for camera tracking

  """

  keyframe_a: int = ...

  """

  First keyframe used for reconstruction initialization

  """

  keyframe_b: int = ...

  """

  Second keyframe used for reconstruction initialization

  """

  name: str = ...

  """

  Unique name of object

  """

  plane_tracks: typing.Union[MovieTrackingObjectPlaneTracks, typing.Sequence[MovieTrackingPlaneTrack], typing.Mapping[str, MovieTrackingPlaneTrack], bpy_prop_collection] = ...

  """

  Collection of plane tracks in this tracking data object

  """

  reconstruction: MovieTrackingReconstruction = ...

  scale: float = ...

  """

  Scale of object solution in camera space

  """

  tracks: typing.Union[MovieTrackingObjectTracks, typing.Sequence[MovieTrackingTrack], typing.Mapping[str, MovieTrackingTrack], bpy_prop_collection] = ...

  """

  Collection of tracks in this tracking data object

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingObjectPlaneTracks(bpy_struct):

  """

  Collection of tracking plane tracks

  """

  active: MovieTrackingTrack = ...

  """

  Active track in this tracking data object

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingObjectTracks(bpy_struct):

  """

  Collection of movie tracking tracks

  """

  active: MovieTrackingTrack = ...

  """

  Active track in this tracking data object

  """

  def new(self, name: str = '', frame: int = 1) -> MovieTrackingTrack:

    """

    create new motion track in this movie clip

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingObjects(bpy_struct):

  """

  Collection of movie tracking objects

  """

  active: MovieTrackingObject = ...

  """

  Active object in this tracking data object

  """

  def new(self, name: str) -> MovieTrackingObject:

    """

    Add tracking object to this movie clip

    """

    ...

  def remove(self, object: MovieTrackingObject) -> None:

    """

    Remove tracking object from this movie clip

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingPlaneMarker(bpy_struct):

  """

  Match-moving plane marker data for tracking

  """

  corners: typing.Tuple[typing.Tuple[float, float], typing.Tuple[float, float], typing.Tuple[float, float], typing.Tuple[float, float]] = ...

  """

  Array of coordinates which represents UI rectangle corners in frame normalized coordinates

  """

  frame: int = ...

  """

  Frame number marker is keyframed on

  """

  mute: bool = ...

  """

  Is marker muted for current frame

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingPlaneMarkers(bpy_struct):

  """

  Collection of markers for movie tracking plane track

  """

  def find_frame(self, frame: int, exact: bool = True) -> MovieTrackingPlaneMarker:

    """

    Get plane marker for specified frame

    """

    ...

  def insert_frame(self, frame: int) -> MovieTrackingPlaneMarker:

    """

    Insert a new plane marker at the specified frame

    """

    ...

  def delete_frame(self, frame: int) -> None:

    """

    Delete plane marker at specified frame

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingPlaneTrack(bpy_struct):

  """

  Match-moving plane track data for tracking

  """

  image: Image = ...

  """

  Image displayed in the track during editing in clip editor

  """

  image_opacity: float = ...

  """

  Opacity of the image

  """

  markers: typing.Union[MovieTrackingPlaneMarkers, typing.Sequence[MovieTrackingPlaneMarker], typing.Mapping[str, MovieTrackingPlaneMarker], bpy_prop_collection] = ...

  """

  Collection of markers in track

  """

  name: str = ...

  """

  Unique name of track

  """

  select: bool = ...

  """

  Plane track is selected

  """

  use_auto_keying: bool = ...

  """

  Automatic keyframe insertion when moving plane corners

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingPlaneTracks(bpy_struct):

  """

  Collection of movie tracking plane tracks

  """

  active: MovieTrackingPlaneTrack = ...

  """

  Active plane track in this tracking data object

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingReconstructedCameras(bpy_struct):

  """

  Collection of solved cameras

  """

  def find_frame(self, frame: int = 1) -> MovieReconstructedCamera:

    """

    Find a reconstructed camera for a give frame number

    """

    ...

  def matrix_from_frame(self, frame: int = 1) -> typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]]:

    """

    Return interpolated camera matrix for a given frame

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingReconstruction(bpy_struct):

  """

  Match-moving reconstruction data from tracker

  """

  average_error: float = ...

  """

  Average error of reconstruction

  """

  cameras: typing.Union[MovieTrackingReconstructedCameras, typing.Sequence[MovieReconstructedCamera], typing.Mapping[str, MovieReconstructedCamera], bpy_prop_collection] = ...

  """

  Collection of solved cameras

  """

  is_valid: bool = ...

  """

  Is tracking data contains valid reconstruction information

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingSettings(bpy_struct):

  """

  Match moving settings

  """

  clean_action: str = ...

  """

  Cleanup action to execute

  * ``SELECT``
Select, Select unclean tracks.

  * ``DELETE_TRACK``
Delete Track, Delete unclean tracks.

  * ``DELETE_SEGMENTS``
Delete Segments, Delete unclean segments of tracks.

  """

  clean_error: float = ...

  """

  Effect on tracks which have a larger re-projection error

  """

  clean_frames: int = ...

  """

  Effect on tracks which are tracked less than the specified amount of frames

  """

  default_correlation_min: float = ...

  """

  Default minimum value of correlation between matched pattern and reference that is still treated as successful tracking

  """

  default_frames_limit: int = ...

  """

  Every tracking cycle, this number of frames are tracked

  """

  default_margin: int = ...

  """

  Default distance from image boundary at which marker stops tracking

  """

  default_motion_model: str = ...

  """

  Default motion model to use for tracking

  * ``Perspective``
Perspective, Search for markers that are perspectively deformed (homography) between frames.

  * ``Affine``
Affine, Search for markers that are affine-deformed (t, r, k, and skew) between frames.

  * ``LocRotScale``
Location, Rotation & Scale, Search for markers that are translated, rotated, and scaled between frames.

  * ``LocScale``
Location & Scale, Search for markers that are translated and scaled between frames.

  * ``LocRot``
Location & Rotation, Search for markers that are translated and rotated between frames.

  * ``Loc``
Location, Search for markers that are translated between frames.

  """

  default_pattern_match: str = ...

  """

  Track pattern from given frame when tracking marker to next frame

  * ``KEYFRAME``
Keyframe, Track pattern from keyframe to next frame.

  * ``PREV_FRAME``
Previous frame, Track pattern from current frame to next frame.

  """

  default_pattern_size: int = ...

  """

  Size of pattern area for newly created tracks

  """

  default_search_size: int = ...

  """

  Size of search area for newly created tracks

  """

  default_weight: float = ...

  """

  Influence of newly created track on a final solution

  """

  distance: float = ...

  """

  Distance between two bundles used for scene scaling

  """

  object_distance: float = ...

  """

  Distance between two bundles used for object scaling

  """

  refine_intrinsics: str = ...

  """

  Refine intrinsics during camera solving

  * ``NONE``
Nothing, Do not refine camera intrinsics.

  * ``FOCAL_LENGTH``
Focal Length, Refine focal length.

  * ``FOCAL_LENGTH_RADIAL_K1``
Focal length, K1, Refine focal length and radial distortion K1.

  * ``FOCAL_LENGTH_RADIAL_K1_K2``
Focal length, K1, K2, Refine focal length and radial distortion K1 and K2.

  * ``FOCAL_LENGTH_PRINCIPAL_POINT_RADIAL_K1_K2``
Focal Length, Optical Center, K1, K2, Refine focal length, optical center and radial distortion K1 and K2.

  * ``FOCAL_LENGTH_PRINCIPAL_POINT``
Focal Length, Optical Center, Refine focal length and optical center.

  * ``RADIAL_K1_K2``
K1, K2, Refine radial distortion K1 and K2.

  """

  show_default_expanded: bool = ...

  """

  Show default options expanded in the user interface

  """

  show_extra_expanded: bool = ...

  """

  Show extra options expanded in the user interface

  """

  speed: str = ...

  """

  Limit speed of tracking to make visual feedback easier (this does not affect the tracking quality)

  * ``FASTEST``
Fastest, Track as fast as it's possible.

  * ``DOUBLE``
Double, Track with double speed.

  * ``REALTIME``
Realtime, Track with realtime speed.

  * ``HALF``
Half, Track with half of realtime speed.

  * ``QUARTER``
Quarter, Track with quarter of realtime speed.

  """

  use_default_blue_channel: bool = ...

  """

  Use blue channel from footage for tracking

  """

  use_default_brute: bool = ...

  """

  Use a brute-force translation-only initialization when tracking

  """

  use_default_green_channel: bool = ...

  """

  Use green channel from footage for tracking

  """

  use_default_mask: bool = ...

  """

  Use a grease pencil data-block as a mask to use only specified areas of pattern when tracking

  """

  use_default_normalization: bool = ...

  """

  Normalize light intensities while tracking (slower)

  """

  use_default_red_channel: bool = ...

  """

  Use red channel from footage for tracking

  """

  use_keyframe_selection: bool = ...

  """

  Automatically select keyframes when solving camera/object motion

  """

  use_tripod_solver: bool = ...

  """

  Use special solver to track a stable camera position, such as a tripod

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingStabilization(bpy_struct):

  """

  2D stabilization based on tracking markers

  """

  active_rotation_track_index: int = ...

  """

  Index of active track in rotation stabilization tracks list

  """

  active_track_index: int = ...

  """

  Index of active track in translation stabilization tracks list

  """

  anchor_frame: int = ...

  """

  Reference point to anchor stabilization (other frames will be adjusted relative to this frame's position)

  """

  filter_type: str = ...

  """

  Interpolation to use for sub-pixel shifts and rotations due to stabilization

  * ``NEAREST``
Nearest, No interpolation, use nearest neighbor pixel.

  * ``BILINEAR``
Bilinear, Simple interpolation between adjacent pixels.

  * ``BICUBIC``
Bicubic, High quality pixel interpolation.

  """

  influence_location: float = ...

  """

  Influence of stabilization algorithm on footage location

  """

  influence_rotation: float = ...

  """

  Influence of stabilization algorithm on footage rotation

  """

  influence_scale: float = ...

  """

  Influence of stabilization algorithm on footage scale

  """

  rotation_tracks: typing.Union[typing.Sequence[MovieTrackingTrack], typing.Mapping[str, MovieTrackingTrack], bpy_prop_collection] = ...

  """

  Collection of tracks used for 2D stabilization (translation)

  """

  scale_max: float = ...

  """

  Limit the amount of automatic scaling

  """

  show_tracks_expanded: bool = ...

  """

  Show UI list of tracks participating in stabilization

  """

  target_position: typing.Tuple[float, float] = ...

  """

  Known relative offset of original shot, will be subtracted (e.g. for panning shot, can be animated)

  """

  target_rotation: float = ...

  """

  Rotation present on original shot, will be compensated (e.g. for deliberate tilting)

  """

  target_scale: float = ...

  """

  Explicitly scale resulting frame to compensate zoom of original shot

  """

  tracks: typing.Union[typing.Sequence[MovieTrackingTrack], typing.Mapping[str, MovieTrackingTrack], bpy_prop_collection] = ...

  """

  Collection of tracks used for 2D stabilization (translation)

  """

  use_2d_stabilization: bool = ...

  """

  Use 2D stabilization for footage

  """

  use_autoscale: bool = ...

  """

  Automatically scale footage to cover unfilled areas when stabilizing

  """

  use_stabilize_rotation: bool = ...

  """

  Stabilize detected rotation around center of frame

  """

  use_stabilize_scale: bool = ...

  """

  Compensate any scale changes relative to center of rotation

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingTrack(bpy_struct):

  """

  Match-moving track data for tracking

  """

  average_error: float = ...

  """

  Average error of re-projection

  """

  bundle: typing.Tuple[float, float, float] = ...

  """

  Position of bundle reconstructed from this track

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Color of the track in the Movie Clip Editor and the 3D viewport after a solve

  """

  correlation_min: float = ...

  """

  Minimal value of correlation between matched pattern and reference that is still treated as successful tracking

  """

  frames_limit: int = ...

  """

  Every tracking cycle, this number of frames are tracked

  """

  grease_pencil: GreasePencil = ...

  """

  Grease pencil data for this track

  """

  has_bundle: bool = ...

  """

  True if track has a valid bundle

  """

  hide: bool = ...

  """

  Track is hidden

  """

  lock: bool = ...

  """

  Track is locked and all changes to it are disabled

  """

  margin: int = ...

  """

  Distance from image boundary at which marker stops tracking

  """

  markers: typing.Union[MovieTrackingMarkers, typing.Sequence[MovieTrackingMarker], typing.Mapping[str, MovieTrackingMarker], bpy_prop_collection] = ...

  """

  Collection of markers in track

  """

  motion_model: str = ...

  """

  Default motion model to use for tracking

  * ``Perspective``
Perspective, Search for markers that are perspectively deformed (homography) between frames.

  * ``Affine``
Affine, Search for markers that are affine-deformed (t, r, k, and skew) between frames.

  * ``LocRotScale``
Location, Rotation & Scale, Search for markers that are translated, rotated, and scaled between frames.

  * ``LocScale``
Location & Scale, Search for markers that are translated and scaled between frames.

  * ``LocRot``
Location & Rotation, Search for markers that are translated and rotated between frames.

  * ``Loc``
Location, Search for markers that are translated between frames.

  """

  name: str = ...

  """

  Unique name of track

  """

  offset: typing.Tuple[float, float] = ...

  """

  Offset of track from the parenting point

  """

  pattern_match: str = ...

  """

  Track pattern from given frame when tracking marker to next frame

  * ``KEYFRAME``
Keyframe, Track pattern from keyframe to next frame.

  * ``PREV_FRAME``
Previous frame, Track pattern from current frame to next frame.

  """

  select: bool = ...

  """

  Track is selected

  """

  select_anchor: bool = ...

  """

  Track's anchor point is selected

  """

  select_pattern: bool = ...

  """

  Track's pattern area is selected

  """

  select_search: bool = ...

  """

  Track's search area is selected

  """

  use_alpha_preview: bool = ...

  """

  Apply track's mask on displaying preview

  """

  use_blue_channel: bool = ...

  """

  Use blue channel from footage for tracking

  """

  use_brute: bool = ...

  """

  Use a brute-force translation only pre-track before refinement

  """

  use_custom_color: bool = ...

  """

  Use custom color instead of theme-defined

  """

  use_grayscale_preview: bool = ...

  """

  Display what the tracking algorithm sees in the preview

  """

  use_green_channel: bool = ...

  """

  Use green channel from footage for tracking

  """

  use_mask: bool = ...

  """

  Use a grease pencil data-block as a mask to use only specified areas of pattern when tracking

  """

  use_normalization: bool = ...

  """

  Normalize light intensities while tracking. Slower

  """

  use_red_channel: bool = ...

  """

  Use red channel from footage for tracking

  """

  weight: float = ...

  """

  Influence of this track on a final solution

  """

  weight_stab: float = ...

  """

  Influence of this track on 2D stabilization

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieTrackingTracks(bpy_struct):

  """

  Collection of movie tracking tracks

  """

  active: MovieTrackingTrack = ...

  """

  Active track in this tracking data object

  """

  def new(self, name: str = '', frame: int = 1) -> MovieTrackingTrack:

    """

    Create new motion track in this movie clip

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NlaStrip(bpy_struct):

  """

  A container referencing an existing Action

  """

  action: Action = ...

  """

  Action referenced by this strip

  """

  action_frame_end: float = ...

  """

  Last frame from action to use

  """

  action_frame_start: float = ...

  """

  First frame from action to use

  """

  active: bool = ...

  """

  NLA Strip is active

  """

  blend_in: float = ...

  """

  Number of frames at start of strip to fade in influence

  """

  blend_out: float = ...

  blend_type: str = ...

  """

  Method used for combining strip's result with accumulated result

  * ``REPLACE``
Replace, The strip values replace the accumulated results by amount specified by influence.

  * ``COMBINE``
Combine, The strip values are combined with accumulated results by appropriately using addition, multiplication, or quaternion math, based on channel type.

  * ``ADD``
Add, Weighted result of strip is added to the accumulated results.

  * ``SUBTRACT``
Subtract, Weighted result of strip is removed from the accumulated results.

  * ``MULTIPLY``
Multiply, Weighted result of strip is multiplied with the accumulated results.

  """

  extrapolation: str = ...

  """

  Action to take for gaps past the strip extents

  * ``NOTHING``
Nothing, Strip has no influence past its extents.

  * ``HOLD``
Hold, Hold the first frame if no previous strips in track, and always hold last frame.

  * ``HOLD_FORWARD``
Hold Forward, Only hold last frame.

  """

  fcurves: typing.Union[NlaStripFCurves, typing.Sequence[FCurve], typing.Mapping[str, FCurve], bpy_prop_collection] = ...

  """

  F-Curves for controlling the strip's influence and timing

  """

  frame_end: float = ...

  frame_start: float = ...

  influence: float = ...

  """

  Amount the strip contributes to the current result

  """

  modifiers: typing.Union[typing.Sequence[FModifier], typing.Mapping[str, FModifier], bpy_prop_collection] = ...

  """

  Modifiers affecting all the F-Curves in the referenced Action

  """

  mute: bool = ...

  """

  Disable NLA Strip evaluation

  """

  name: str = ...

  repeat: float = ...

  """

  Number of times to repeat the action range

  """

  scale: float = ...

  """

  Scaling factor for action

  """

  select: bool = ...

  """

  NLA Strip is selected

  """

  strip_time: float = ...

  """

  Frame of referenced Action to evaluate

  """

  strips: typing.Union[typing.Sequence[NlaStrip], typing.Mapping[str, NlaStrip], bpy_prop_collection] = ...

  """

  NLA Strips that this strip acts as a container for (if it is of type Meta)

  """

  type: str = ...

  """

  Type of NLA Strip

  * ``CLIP``
Action Clip, NLA Strip references some Action.

  * ``TRANSITION``
Transition, NLA Strip 'transitions' between adjacent strips.

  * ``META``
Meta, NLA Strip acts as a container for adjacent strips.

  * ``SOUND``
Sound Clip, NLA Strip representing a sound event for speakers.

  """

  use_animated_influence: bool = ...

  """

  Influence setting is controlled by an F-Curve rather than automatically determined

  """

  use_animated_time: bool = ...

  """

  Strip time is controlled by an F-Curve rather than automatically determined

  """

  use_animated_time_cyclic: bool = ...

  """

  Cycle the animated time within the action start & end

  """

  use_auto_blend: bool = ...

  """

  Number of frames for Blending In/Out is automatically determined from overlapping strips

  """

  use_reverse: bool = ...

  """

  NLA Strip is played back in reverse order (only when timing is automatically determined)

  """

  use_sync_length: bool = ...

  """

  Update range of frames referenced from action after tweaking strip and its keyframes

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NlaStripFCurves(bpy_struct):

  """

  Collection of NLA strip F-Curves

  """

  def find(self, data_path: str, index: int = 0) -> FCurve:

    """

    Find an F-Curve. Note that this function performs a linear scan of all F-Curves in the NLA strip.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NlaStrips(bpy_struct):

  """

  Collection of Nla Strips

  """

  def new(self, name: str, start: int, action: Action) -> NlaStrip:

    """

    Add a new Action-Clip strip to the track

    """

    ...

  def remove(self, strip: NlaStrip) -> None:

    """

    Remove a NLA Strip

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NlaTrack(bpy_struct):

  """

  A animation layer containing Actions referenced as NLA strips

  """

  active: bool = ...

  """

  NLA Track is active

  """

  is_solo: bool = ...

  """

  NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)

  """

  lock: bool = ...

  """

  NLA Track is locked

  """

  mute: bool = ...

  """

  Disable NLA Track evaluation

  """

  name: str = ...

  select: bool = ...

  """

  NLA Track is selected

  """

  strips: typing.Union[NlaStrips, typing.Sequence[NlaStrip], typing.Mapping[str, NlaStrip], bpy_prop_collection] = ...

  """

  NLA Strips on this NLA-track

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NlaTracks(bpy_struct):

  """

  Collection of NLA Tracks

  """

  active: NlaTrack = ...

  """

  Active NLA Track

  """

  def new(self, prev: NlaTrack = None) -> NlaTrack:

    """

    Add a new NLA Track

    """

    ...

  def remove(self, track: NlaTrack) -> None:

    """

    Remove a NLA Track

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Node(bpy_struct):

  """

  Node in a node tree

  """

  bl_description: str = ...

  bl_height_default: float = ...

  bl_height_max: float = ...

  bl_height_min: float = ...

  bl_icon: str = ...

  """

  The node icon

  """

  bl_idname: str = ...

  bl_label: str = ...

  """

  The node label

  """

  bl_static_type: str = ...

  """

  Node type (deprecated, use with care)

  * ``CUSTOM``
Custom, Custom Node.

  """

  bl_width_default: float = ...

  bl_width_max: float = ...

  bl_width_min: float = ...

  color: typing.Tuple[float, float, float] = ...

  """

  Custom color of the node body

  """

  dimensions: typing.Tuple[float, float] = ...

  """

  Absolute bounding box dimensions of the node

  """

  height: float = ...

  """

  Height of the node

  """

  hide: bool = ...

  inputs: typing.Union[NodeInputs, typing.Sequence[NodeSocket], typing.Mapping[str, NodeSocket], bpy_prop_collection] = ...

  internal_links: typing.Union[typing.Sequence[NodeLink], typing.Mapping[str, NodeLink], bpy_prop_collection] = ...

  """

  Internal input-to-output connections for muting

  """

  label: str = ...

  """

  Optional custom node label

  """

  location: typing.Tuple[float, float] = ...

  mute: bool = ...

  name: str = ...

  """

  Unique node identifier

  """

  outputs: typing.Union[NodeOutputs, typing.Sequence[NodeSocket], typing.Mapping[str, NodeSocket], bpy_prop_collection] = ...

  parent: Node = ...

  """

  Parent this node is attached to

  """

  select: bool = ...

  """

  Node selection state

  """

  show_options: bool = ...

  show_preview: bool = ...

  show_texture: bool = ...

  """

  Draw node in viewport textured draw mode

  """

  type: str = ...

  """

  Node type (deprecated, use bl_static_type or bl_idname for the actual identifier string)

  * ``CUSTOM``
Custom, Custom Node.

  """

  use_custom_color: bool = ...

  """

  Use custom color for the node

  """

  width: float = ...

  """

  Width of the node

  """

  width_hidden: float = ...

  """

  Width of the node in hidden state

  """

  def socket_value_update(self, context: Context) -> None:

    """

    Update after property changes

    """

    ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def poll(cls, node_tree: NodeTree) -> bool:

    """

    If non-null output is returned, the node type can be added to the tree

    """

    ...

  def poll_instance(self, node_tree: NodeTree) -> bool:

    """

    If non-null output is returned, the node can be added to the tree

    """

    ...

  def update(self) -> None:

    """

    Update on node graph topology changes (adding or removing nodes and links)

    """

    ...

  def insert_link(self, link: NodeLink) -> None:

    """

    Handle creation of a link to or from the node

    """

    ...

  def init(self, context: Context) -> None:

    """

    Initialize a new instance of this node

    """

    ...

  def copy(self, node: Node) -> None:

    """

    Initialize a new instance of this node from an existing node

    """

    ...

  def free(self) -> None:

    """

    Clean up node on removal

    """

    ...

  def draw_buttons(self, context: Context, layout: UILayout) -> None:

    """

    Draw node buttons

    """

    ...

  def draw_buttons_ext(self, context: Context, layout: UILayout) -> None:

    """

    Draw node buttons in the sidebar

    """

    ...

  def draw_label(self) -> str:

    """

    Returns a dynamic label string

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeInputs(bpy_struct):

  """

  Collection of Node Sockets

  """

  def new(self, type: str, name: str, identifier: str = '') -> NodeSocket:

    """

    Add a socket to this node

    """

    ...

  def remove(self, socket: NodeSocket) -> None:

    """

    Remove a socket from this node

    """

    ...

  def clear(self) -> None:

    """

    Remove all sockets from this node

    """

    ...

  def move(self, from_index: int, to_index: int) -> None:

    """

    Move a socket to another position

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeInstanceHash(bpy_struct):

  """

  Hash table containing node instance data

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeInternalSocketTemplate(bpy_struct):

  """

  Type and default value of a node socket

  """

  identifier: str = ...

  """

  Identifier of the socket

  """

  name: str = ...

  """

  Name of the socket

  """

  type: str = ...

  """

  Data type of the socket

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeLink(bpy_struct):

  """

  Link is valid

  """

  from_node: Node = ...

  from_socket: NodeSocket = ...

  is_hidden: bool = ...

  """

  Link is hidden due to invisible sockets

  """

  is_valid: bool = ...

  to_node: Node = ...

  to_socket: NodeSocket = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeLinks(bpy_struct):

  """

  Collection of Node Links

  """

  def new(self, input: NodeSocket, output: NodeSocket, verify_limits: bool = True) -> NodeLink:

    """

    Add a node link to this node tree

    """

    ...

  def remove(self, link: NodeLink) -> None:

    """

    remove a node link from the node tree

    """

    ...

  def clear(self) -> None:

    """

    remove all node links from the node tree

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeOutputFileSlotFile(bpy_struct):

  """

  Single layer file slot of the file output node

  """

  format: ImageFormatSettings = ...

  path: str = ...

  """

  Subpath used for this slot

  """

  use_node_format: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeOutputFileSlotLayer(bpy_struct):

  """

  Multilayer slot of the file output node

  """

  name: str = ...

  """

  OpenEXR layer name used for this slot

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeOutputs(bpy_struct):

  """

  Collection of Node Sockets

  """

  def new(self, type: str, name: str, identifier: str = '') -> NodeSocket:

    """

    Add a socket to this node

    """

    ...

  def remove(self, socket: NodeSocket) -> None:

    """

    Remove a socket from this node

    """

    ...

  def clear(self) -> None:

    """

    Remove all sockets from this node

    """

    ...

  def move(self, from_index: int, to_index: int) -> None:

    """

    Move a socket to another position

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocket(bpy_struct):

  """

  Input or output socket of a node

  """

  bl_idname: str = ...

  display_shape: str = ...

  """

  Socket shape

  """

  enabled: bool = ...

  """

  Enable the socket

  """

  hide: bool = ...

  """

  Hide the socket

  """

  hide_value: bool = ...

  """

  Hide the socket input value

  """

  identifier: str = ...

  """

  Unique identifier for mapping sockets

  """

  is_linked: bool = ...

  """

  True if the socket is connected

  """

  is_output: bool = ...

  """

  True if the socket is an output, otherwise input

  """

  label: str = ...

  """

  Custom dynamic defined socket label

  """

  link_limit: int = ...

  """

  Max number of links allowed for this socket

  """

  name: str = ...

  """

  Socket name

  """

  node: Node = ...

  """

  Node owning this socket

  """

  show_expanded: bool = ...

  """

  Socket links are expanded in the user interface

  """

  type: str = ...

  """

  Data type

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  def draw(self, context: Context, layout: UILayout, node: Node, text: str) -> None:

    """

    Draw socket

    """

    ...

  def draw_color(self, context: Context, node: Node) -> typing.Tuple[float, float, float, float]:

    """

    Color of the socket icon

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterface(bpy_struct):

  """

  Parameters to define node sockets

  """

  bl_socket_idname: str = ...

  hide_value: bool = ...

  """

  Hide the socket input value even when the socket is not connected

  """

  identifier: str = ...

  """

  Unique identifier for mapping sockets

  """

  is_output: bool = ...

  """

  True if the socket is an output, otherwise input

  """

  name: str = ...

  """

  Socket name

  """

  def draw(self, context: Context, layout: UILayout) -> None:

    """

    Draw template settings

    """

    ...

  def draw_color(self, context: Context) -> typing.Tuple[float, float, float, float]:

    """

    Color of the socket icon

    """

    ...

  def register_properties(self, data_rna_type: Struct) -> None:

    """

    Define RNA properties of a socket

    """

    ...

  def init_socket(self, node: Node, socket: NodeSocket, data_path: str) -> None:

    """

    Initialize a node socket instance

    """

    ...

  def from_socket(self, node: Node, socket: NodeSocket) -> None:

    """

    Setup template parameters from an existing socket

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeTreeInputs(bpy_struct):

  """

  Collection of Node Tree Sockets

  """

  def new(self, type: str, name: str) -> NodeSocketInterface:

    """

    Add a socket to this node tree

    """

    ...

  def remove(self, socket: NodeSocketInterface) -> None:

    """

    Remove a socket from this node tree

    """

    ...

  def clear(self) -> None:

    """

    Remove all sockets from this node tree

    """

    ...

  def move(self, from_index: int, to_index: int) -> None:

    """

    Move a socket to another position

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeTreeOutputs(bpy_struct):

  """

  Collection of Node Tree Sockets

  """

  def new(self, type: str, name: str) -> NodeSocketInterface:

    """

    Add a socket to this node tree

    """

    ...

  def remove(self, socket: NodeSocketInterface) -> None:

    """

    Remove a socket from this node tree

    """

    ...

  def clear(self) -> None:

    """

    Remove all sockets from this node tree

    """

    ...

  def move(self, from_index: int, to_index: int) -> None:

    """

    Move a socket to another position

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeTreePath(bpy_struct):

  """

  Element of the node space tree path

  """

  node_tree: NodeTree = ...

  """

  Base node tree from context

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Nodes(bpy_struct):

  """

  Collection of Nodes

  """

  active: Node = ...

  """

  Active node in this tree

  """

  def new(self, type: str) -> Node:

    """

    Add a node to this node tree

    """

    ...

  def remove(self, node: Node) -> None:

    """

    Remove a node from this node tree

    """

    ...

  def clear(self) -> None:

    """

    Remove all nodes from this node tree

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ObjectBase(bpy_struct):

  """

  An object instance in a render layer

  """

  hide_viewport: bool = ...

  """

  Temporarily hide in viewport

  """

  object: Object = ...

  """

  Object this base links to

  """

  select: bool = ...

  """

  Object base selection state

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ObjectConstraints(bpy_struct):

  """

  Collection of object constraints

  """

  active: Constraint = ...

  """

  Active Object constraint

  """

  def new(self, type: str) -> Constraint:

    """

    Add a new constraint to this object

    """

    ...

  def remove(self, constraint: Constraint) -> None:

    """

    Remove a constraint from this object

    """

    ...

  def clear(self) -> None:

    """

    Remove all constraint from this object

    """

    ...

  def move(self, from_index: int, to_index: int) -> None:

    """

    Move a constraint to a different position

    """

    ...

  def copy(self, constraint: Constraint) -> Constraint:

    """

    Add a new constraint that is a copy of the given one

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ObjectDisplay(bpy_struct):

  """

  Object display settings for 3d viewport

  """

  show_shadows: bool = ...

  """

  Object cast shadows in the 3d viewport

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ObjectGpencilModifiers(bpy_struct):

  """

  Collection of object grease pencil modifiers

  """

  def new(self, name: str, type: str) -> GpencilModifier:

    """

    Add a new greasepencil_modifier

    """

    ...

  def remove(self, greasepencil_modifier: GpencilModifier) -> None:

    """

    Remove an existing greasepencil_modifier from the object

    """

    ...

  def clear(self) -> None:

    """

    Remove all grease pencil modifiers from the object

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ObjectModifiers(bpy_struct):

  """

  Collection of object modifiers

  """

  def new(self, name: str, type: str) -> Modifier:

    """

    Add a new modifier

    """

    ...

  def remove(self, modifier: Modifier) -> None:

    """

    Remove an existing modifier from the object

    """

    ...

  def clear(self) -> None:

    """

    Remove all modifiers from the object

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ObjectShaderFx(bpy_struct):

  """

  Collection of object effects

  """

  def new(self, name: str, type: str) -> ShaderFx:

    """

    Add a new shader fx

    """

    ...

  def remove(self, shader_fx: ShaderFx) -> None:

    """

    Remove an existing effect from the object

    """

    ...

  def clear(self) -> None:

    """

    Remove all effects from the object

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Operator(bpy_struct):

  """

  Storage of an operator being executed, or registered after execution

  """

  bl_description: str = ...

  bl_idname: str = ...

  bl_label: str = ...

  bl_options: typing.Set[str] = ...

  """

  Options for this operator type

  * ``REGISTER``
Register, Display in the info window and support the redo toolbar panel.

  * ``UNDO``
Undo, Push an undo event (needed for operator redo).

  * ``UNDO_GROUPED``
Grouped Undo, Push a single undo event for repeated instances of this operator.

  * ``BLOCKING``
Blocking, Block anything else from using the cursor.

  * ``MACRO``
Macro, Use to check if an operator is a macro.

  * ``GRAB_CURSOR``
Grab Pointer, Use so the operator grabs the mouse focus, enables wrapping when continuous grab is enabled.

  * ``GRAB_CURSOR_X``
Grab Pointer X, Grab, only warping the X axis.

  * ``GRAB_CURSOR_Y``
Grab Pointer Y, Grab, only warping the Y axis.

  * ``PRESET``
Preset, Display a preset button with the operators settings.

  * ``INTERNAL``
Internal, Removes the operator from search results.

  """

  bl_translation_context: str = ...

  bl_undo_group: str = ...

  has_reports: bool = ...

  """

  Operator has a set of reports (warnings and errors) from last execution

  """

  layout: UILayout = ...

  macros: typing.Union[typing.Sequence[Macro], typing.Mapping[str, Macro], bpy_prop_collection] = ...

  name: str = ...

  options: OperatorOptions = ...

  """

  Runtime options

  """

  properties: OperatorProperties = ...

  bl_property: typing.Any = ...

  """

  The name of a property to use as this operators primary property.
Currently this is only used to select the default property when
expanding an operator into a menu.
:type: string

  """

  def report(self, type: typing.Set[str], message: str) -> None:

    """

    report

    """

    ...

  def is_repeat(self) -> bool:

    """

    is_repeat

    """

    ...

  @classmethod

  def poll(cls, context: Context) -> bool:

    """

    Test if the operator can be called or not

    """

    ...

  def execute(self, context: Context) -> typing.Set[str]:

    """

    Execute the operator

    """

    ...

  def check(self, context: Context) -> bool:

    """

    Check the operator settings, return True to signal a change to redraw

    """

    ...

  def invoke(self, context: Context, event: Event) -> typing.Set[str]:

    """

    Invoke the operator

    """

    ...

  def modal(self, context: Context, event: Event) -> typing.Set[str]:

    """

    Modal operator function

    """

    ...

  def draw(self, context: Context) -> None:

    """

    Draw function for the operator

    """

    ...

  def cancel(self, context: Context) -> None:

    """

    Called when the operator is canceled

    """

    ...

  @classmethod

  def description(cls, context: Context, properties: OperatorProperties) -> str:

    """

    Compute a description string that depends on parameters

    """

    ...

  def as_keywords(self, ignore: typing.Any = ()) -> None:

    """

    Return a copy of the properties as a dictionary

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class OperatorMacro(bpy_struct):

  """

  Storage of a sub operator in a macro after it has been added

  """

  properties: OperatorProperties = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class OperatorOptions(bpy_struct):

  """

  Runtime options

  """

  is_grab_cursor: bool = ...

  """

  True when the cursor is grabbed

  """

  is_invoke: bool = ...

  """

  True when invoked (even if only the execute callbacks available)

  """

  is_repeat: bool = ...

  """

  True when run from the 'Adjust Last Operation' panel

  """

  is_repeat_last: bool = ...

  """

  True when run from the operator 'Repeat Last'

  """

  use_cursor_region: bool = ...

  """

  Enable to use the region under the cursor for modal execution

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class OperatorProperties(bpy_struct):

  """

  Input properties of an Operator

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PackedFile(bpy_struct):

  """

  External file packed into the .blend file

  """

  data: str = ...

  """

  Raw data (bytes, exact content of the embedded file)

  """

  size: int = ...

  """

  Size of packed file in bytes

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Paint(bpy_struct):

  brush: Brush = ...

  """

  Active Brush

  """

  cavity_curve: CurveMapping = ...

  """

  Editable cavity curve

  """

  input_samples: int = ...

  """

  Average multiple input samples together to smooth the brush stroke

  """

  palette: Palette = ...

  """

  Active Palette

  """

  show_brush: bool = ...

  show_brush_on_surface: bool = ...

  show_low_resolution: bool = ...

  """

  For multires, show low resolution while navigating the view

  """

  tile_offset: typing.Tuple[float, float, float] = ...

  """

  Stride at which tiled strokes are copied

  """

  tile_x: bool = ...

  """

  Tile along X axis

  """

  tile_y: bool = ...

  """

  Tile along Y axis

  """

  tile_z: bool = ...

  """

  Tile along Z axis

  """

  tool_slots: typing.Union[typing.Sequence[PaintToolSlot], typing.Mapping[str, PaintToolSlot], bpy_prop_collection] = ...

  use_cavity: bool = ...

  """

  Mask painting according to mesh geometry cavity

  """

  use_sculpt_delay_updates: bool = ...

  """

  Update the geometry when it enters the view, providing faster view navigation

  """

  use_symmetry_feather: bool = ...

  """

  Reduce the strength of the brush where it overlaps symmetrical daubs

  """

  use_symmetry_x: bool = ...

  """

  Mirror brush across the X axis

  """

  use_symmetry_y: bool = ...

  """

  Mirror brush across the Y axis

  """

  use_symmetry_z: bool = ...

  """

  Mirror brush across the Z axis

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PaintToolSlot(bpy_struct):

  brush: Brush = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PaletteColor(bpy_struct):

  color: typing.Tuple[float, float, float] = ...

  strength: float = ...

  weight: float = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PaletteColors(bpy_struct):

  """

  Collection of palette colors

  """

  active: PaletteColor = ...

  def new(self) -> PaletteColor:

    """

    Add a new color to the palette

    """

    ...

  def remove(self, color: PaletteColor) -> None:

    """

    Remove a color from the palette

    """

    ...

  def clear(self) -> None:

    """

    Remove all colors from the palette

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Panel(bpy_struct):

  """

  Panel containing UI elements

  """

  bl_category: str = ...

  bl_context: str = ...

  """

  The context in which the panel belongs to. (TODO: explain the possible combinations bl_context/bl_region_type/bl_space_type)

  """

  bl_idname: str = ...

  """

  If this is set, the panel gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is "OBJECT_PT_hello", and bl_idname is not set by the script, then bl_idname = "OBJECT_PT_hello"

  """

  bl_label: str = ...

  """

  The panel label, shows up in the panel header at the right of the triangle used to collapse the panel

  """

  bl_options: typing.Set[str] = ...

  """

  Options for this panel type

  * ``DEFAULT_CLOSED``
Default Closed, Defines if the panel has to be open or collapsed at the time of its creation.

  * ``HIDE_HEADER``
Hide Header, If set to False, the panel shows a header, which contains a clickable arrow to collapse the panel and the label (see bl_label).

  * ``INSTANCED``
Instanced Panel, Multiple panels with this type can be used as part of a list depending on data external to the UI. Used to create panels for the modifiers and other stacks.

  * ``HEADER_LAYOUT_EXPAND``
Expand Header Layout, Allow buttons in the header to stretch and shrink to fill the entire layout width.

  * ``DRAW_BOX``
Box Style, Draw panel with the box widget theme.

  """

  bl_order: int = ...

  """

  Panels with lower numbers are default ordered before panels with higher numbers

  """

  bl_owner_id: str = ...

  bl_parent_id: str = ...

  """

  If this is set, the panel becomes a sub-panel

  """

  bl_region_type: str = ...

  """

  The region where the panel is going to be used in

  """

  bl_space_type: str = ...

  """

  The space where the panel is going to be used in

  * ``EMPTY``
Empty.

  * ``VIEW_3D``
3D Viewport, Manipulate objects in a 3D environment.

  * ``IMAGE_EDITOR``
UV/Image Editor, View and edit images and UV Maps.

  * ``NODE_EDITOR``
Node Editor, Editor for node-based shading and compositing tools.

  * ``SEQUENCE_EDITOR``
Video Sequencer, Video editing tools.

  * ``CLIP_EDITOR``
Movie Clip Editor, Motion tracking tools.

  * ``DOPESHEET_EDITOR``
Dope Sheet, Adjust timing of keyframes.

  * ``GRAPH_EDITOR``
Graph Editor, Edit drivers and keyframe interpolation.

  * ``NLA_EDITOR``
Nonlinear Animation, Combine and layer Actions.

  * ``TEXT_EDITOR``
Text Editor, Edit scripts and in-file documentation.

  * ``CONSOLE``
Python Console, Interactive programmatic console for advanced editing and script development.

  * ``INFO``
Info, Log of operations, warnings and error messages.

  * ``TOPBAR``
Top Bar, Global bar at the top of the screen for global per-window settings.

  * ``STATUSBAR``
Status Bar, Global bar at the bottom of the screen for general status information.

  * ``OUTLINER``
Outliner, Overview of scene graph and all available data-blocks.

  * ``PROPERTIES``
Properties, Edit properties of active object and related data-blocks.

  * ``FILE_BROWSER``
File Browser, Browse for files and assets.

  * ``PREFERENCES``
Preferences, Edit persistent configuration settings.

  """

  bl_translation_context: str = ...

  bl_ui_units_x: int = ...

  """

  When set, defines popup panel width

  """

  custom_data: Constraint = ...

  """

  Panel Data

  """

  is_popover: bool = ...

  layout: UILayout = ...

  """

  Defines the structure of the panel in the UI

  """

  text: str = ...

  """

  XXX todo

  """

  use_pin: bool = ...

  """

  Show the panel on all tabs

  """

  @classmethod

  def poll(cls, context: Context) -> bool:

    """

    If this method returns a non-null output, then the panel can be drawn

    """

    ...

  def draw(self, context: Context) -> None:

    """

    Draw UI elements into the panel UI layout

    """

    ...

  def draw_header(self, context: Context) -> None:

    """

    Draw UI elements into the panel's header UI layout

    """

    ...

  def draw_header_preset(self, context: Context) -> None:

    """

    Draw UI elements for presets in the panel's header

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Particle(bpy_struct):

  """

  Particle in a particle system

  """

  alive_state: str = ...

  angular_velocity: typing.Tuple[float, float, float] = ...

  birth_time: float = ...

  die_time: float = ...

  hair_keys: typing.Union[typing.Sequence[ParticleHairKey], typing.Mapping[str, ParticleHairKey], bpy_prop_collection] = ...

  is_exist: bool = ...

  is_visible: bool = ...

  lifetime: float = ...

  location: typing.Tuple[float, float, float] = ...

  particle_keys: typing.Union[typing.Sequence[ParticleKey], typing.Mapping[str, ParticleKey], bpy_prop_collection] = ...

  prev_angular_velocity: typing.Tuple[float, float, float] = ...

  prev_location: typing.Tuple[float, float, float] = ...

  prev_rotation: typing.Tuple[float, float, float, float] = ...

  prev_velocity: typing.Tuple[float, float, float] = ...

  rotation: typing.Tuple[float, float, float, float] = ...

  size: float = ...

  velocity: typing.Tuple[float, float, float] = ...

  def uv_on_emitter(self, modifier: ParticleSystemModifier) -> typing.Tuple[float, float]:

    """

    Obtain UV coordinates for a particle on an evaluated mesh.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleBrush(bpy_struct):

  """

  Particle editing brush

  """

  count: int = ...

  """

  Particle count

  """

  curve: CurveMapping = ...

  length_mode: str = ...

  """

  * ``GROW``
Grow, Make hairs longer.

  * ``SHRINK``
Shrink, Make hairs shorter.

  """

  puff_mode: str = ...

  """

  * ``ADD``
Add, Make hairs more puffy.

  * ``SUB``
Sub, Make hairs less puffy.

  """

  size: int = ...

  """

  Radius of the brush in pixels

  """

  steps: int = ...

  """

  Brush steps

  """

  strength: float = ...

  """

  Brush strength

  """

  use_puff_volume: bool = ...

  """

  Apply puff to unselected end-points (helps maintain hair volume when puffing root)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleDupliWeight(bpy_struct):

  """

  Weight of a particle dupliobject in a collection

  """

  count: int = ...

  """

  The number of times this object is repeated with respect to other objects

  """

  name: str = ...

  """

  Particle dupliobject name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleEdit(bpy_struct):

  """

  Properties of particle editing mode

  """

  brush: ParticleBrush = ...

  default_key_count: int = ...

  """

  How many keys to make new particles with

  """

  display_step: int = ...

  """

  How many steps to display the path with

  """

  emitter_distance: float = ...

  """

  Distance to keep particles away from the emitter

  """

  fade_frames: int = ...

  """

  How many frames to fade

  """

  is_editable: bool = ...

  """

  A valid edit mode exists

  """

  is_hair: bool = ...

  """

  Editing hair

  """

  object: Object = ...

  """

  The edited object

  """

  select_mode: str = ...

  """

  Particle select and display mode

  * ``PATH``
Path, Path edit mode.

  * ``POINT``
Point, Point select mode.

  * ``TIP``
Tip, Tip select mode.

  """

  shape_object: Object = ...

  """

  Outer shape to use for tools

  """

  show_particles: bool = ...

  """

  Display actual particles

  """

  tool: str = ...

  """

  * ``COMB``
Comb, Comb hairs.

  * ``SMOOTH``
Smooth, Smooth hairs.

  * ``ADD``
Add, Add hairs.

  * ``LENGTH``
Length, Make hairs longer or shorter.

  * ``PUFF``
Puff, Make hairs stand up.

  * ``CUT``
Cut, Cut hairs.

  * ``WEIGHT``
Weight, Weight hair particles.

  """

  type: str = ...

  use_auto_velocity: bool = ...

  """

  Calculate point velocities automatically

  """

  use_default_interpolate: bool = ...

  """

  Interpolate new particles from the existing ones

  """

  use_emitter_deflect: bool = ...

  """

  Keep paths from intersecting the emitter

  """

  use_fade_time: bool = ...

  """

  Fade paths and keys further away from current frame

  """

  use_preserve_length: bool = ...

  """

  Keep path lengths constant

  """

  use_preserve_root: bool = ...

  """

  Keep root keys unmodified

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleHairKey(bpy_struct):

  """

  Particle key for hair particle system

  """

  co: typing.Tuple[float, float, float] = ...

  """

  Location of the hair key in object space

  """

  co_local: typing.Tuple[float, float, float] = ...

  """

  Location of the hair key in its local coordinate system, relative to the emitting face

  """

  time: float = ...

  """

  Relative time of key over hair length

  """

  weight: float = ...

  """

  Weight for cloth simulation

  """

  def co_object(self, object: Object, modifier: ParticleSystemModifier, particle: Particle) -> typing.Tuple[float, float, float]:

    """

    Obtain hairkey location with particle and modifier data

    """

    ...

  def co_object_set(self, object: Object, modifier: ParticleSystemModifier, particle: Particle, co: typing.Tuple[float, float, float]) -> None:

    """

    Set hairkey location with particle and modifier data

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleKey(bpy_struct):

  """

  Key location for a particle over time

  """

  angular_velocity: typing.Tuple[float, float, float] = ...

  """

  Key angular velocity

  """

  location: typing.Tuple[float, float, float] = ...

  """

  Key location

  """

  rotation: typing.Tuple[float, float, float, float] = ...

  """

  Key rotation quaternion

  """

  time: float = ...

  """

  Time of key over the simulation

  """

  velocity: typing.Tuple[float, float, float] = ...

  """

  Key velocity

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleSettingsTextureSlots(bpy_struct):

  """

  Collection of texture slots

  """

  @classmethod

  def add(cls) -> ParticleSettingsTextureSlot:

    """

    add

    """

    ...

  @classmethod

  def create(cls, index: int) -> ParticleSettingsTextureSlot:

    """

    create

    """

    ...

  @classmethod

  def clear(cls, index: int) -> None:

    """

    clear

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleSystem(bpy_struct):

  """

  Particle system in an object

  """

  active_particle_target: ParticleTarget = ...

  active_particle_target_index: int = ...

  child_particles: typing.Union[typing.Sequence[ChildParticle], typing.Mapping[str, ChildParticle], bpy_prop_collection] = ...

  """

  Child particles generated by the particle system

  """

  child_seed: int = ...

  """

  Offset in the random number table for child particles, to get a different randomized result

  """

  cloth: ClothModifier = ...

  """

  Cloth dynamics for hair

  """

  dt_frac: float = ...

  """

  The current simulation time step size, as a fraction of a frame

  """

  has_multiple_caches: bool = ...

  """

  Particle system has multiple point caches

  """

  invert_vertex_group_clump: bool = ...

  """

  Negate the effect of the clump vertex group

  """

  invert_vertex_group_density: bool = ...

  """

  Negate the effect of the density vertex group

  """

  invert_vertex_group_field: bool = ...

  """

  Negate the effect of the field vertex group

  """

  invert_vertex_group_kink: bool = ...

  """

  Negate the effect of the kink vertex group

  """

  invert_vertex_group_length: bool = ...

  """

  Negate the effect of the length vertex group

  """

  invert_vertex_group_rotation: bool = ...

  """

  Negate the effect of the rotation vertex group

  """

  invert_vertex_group_roughness_1: bool = ...

  """

  Negate the effect of the roughness 1 vertex group

  """

  invert_vertex_group_roughness_2: bool = ...

  """

  Negate the effect of the roughness 2 vertex group

  """

  invert_vertex_group_roughness_end: bool = ...

  """

  Negate the effect of the roughness end vertex group

  """

  invert_vertex_group_size: bool = ...

  """

  Negate the effect of the size vertex group

  """

  invert_vertex_group_tangent: bool = ...

  """

  Negate the effect of the tangent vertex group

  """

  invert_vertex_group_twist: bool = ...

  """

  Negate the effect of the twist vertex group

  """

  invert_vertex_group_velocity: bool = ...

  """

  Negate the effect of the velocity vertex group

  """

  is_editable: bool = ...

  """

  Particle system can be edited in particle mode

  """

  is_edited: bool = ...

  """

  Particle system has been edited in particle mode

  """

  is_global_hair: bool = ...

  """

  Hair keys are in global coordinate space

  """

  name: str = ...

  """

  Particle system name

  """

  parent: Object = ...

  """

  Use this object's coordinate system instead of global coordinate system

  """

  particles: typing.Union[typing.Sequence[Particle], typing.Mapping[str, Particle], bpy_prop_collection] = ...

  """

  Particles generated by the particle system

  """

  point_cache: PointCache = ...

  reactor_target_object: Object = ...

  """

  For reactor systems, the object that has the target particle system (empty if same object)

  """

  reactor_target_particle_system: int = ...

  """

  For reactor systems, index of particle system on the target object

  """

  seed: int = ...

  """

  Offset in the random number table, to get a different randomized result

  """

  settings: ParticleSettings = ...

  """

  Particle system settings

  """

  targets: typing.Union[typing.Sequence[ParticleTarget], typing.Mapping[str, ParticleTarget], bpy_prop_collection] = ...

  """

  Target particle systems

  """

  use_hair_dynamics: bool = ...

  """

  Enable hair dynamics using cloth simulation

  """

  use_keyed_timing: bool = ...

  """

  Use key times

  """

  vertex_group_clump: str = ...

  """

  Vertex group to control clump

  """

  vertex_group_density: str = ...

  """

  Vertex group to control density

  """

  vertex_group_field: str = ...

  """

  Vertex group to control field

  """

  vertex_group_kink: str = ...

  """

  Vertex group to control kink

  """

  vertex_group_length: str = ...

  """

  Vertex group to control length

  """

  vertex_group_rotation: str = ...

  """

  Vertex group to control rotation

  """

  vertex_group_roughness_1: str = ...

  """

  Vertex group to control roughness 1

  """

  vertex_group_roughness_2: str = ...

  """

  Vertex group to control roughness 2

  """

  vertex_group_roughness_end: str = ...

  """

  Vertex group to control roughness end

  """

  vertex_group_size: str = ...

  """

  Vertex group to control size

  """

  vertex_group_tangent: str = ...

  """

  Vertex group to control tangent

  """

  vertex_group_twist: str = ...

  """

  Vertex group to control twist

  """

  vertex_group_velocity: str = ...

  """

  Vertex group to control velocity

  """

  def co_hair(self, object: Object, particle_no: int = 0, step: int = 0) -> typing.Tuple[float, float, float]:

    """

    Obtain cache hair data

    """

    ...

  def uv_on_emitter(self, modifier: ParticleSystemModifier, particle: Particle = None, particle_no: int = 0, uv_no: int = 0) -> typing.Tuple[float, float]:

    """

    Obtain uv for all particles

    """

    ...

  def mcol_on_emitter(self, modifier: ParticleSystemModifier, particle: Particle, particle_no: int = 0, vcol_no: int = 0) -> typing.Tuple[float, float, float]:

    """

    Obtain mcol for all particles

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleSystems(bpy_struct):

  """

  Collection of particle systems

  """

  active: ParticleSystem = ...

  """

  Active particle system being displayed

  """

  active_index: int = ...

  """

  Index of active particle system slot

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleTarget(bpy_struct):

  """

  Target particle system

  """

  alliance: str = ...

  duration: float = ...

  is_valid: bool = ...

  """

  Keyed particles target is valid

  """

  name: str = ...

  """

  Particle target name

  """

  object: Object = ...

  """

  The object that has the target particle system (empty if same object)

  """

  system: int = ...

  """

  The index of particle system on the target object

  """

  time: float = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PathCompare(bpy_struct):

  """

  Match paths against this value

  """

  path: str = ...

  use_glob: bool = ...

  """

  Enable wildcard globbing

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PathCompareCollection(bpy_struct):

  """

  Collection of paths

  """

  @classmethod

  def new(cls) -> PathCompare:

    """

    Add a new path

    """

    ...

  @classmethod

  def remove(cls, pathcmp: PathCompare) -> None:

    """

    Remove path

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PointCache(bpy_struct):

  """

  Active point cache for physics simulations

  """

  compression: str = ...

  """

  Compression method to be used

  * ``NO``
None, No compression.

  * ``LIGHT``
Lite, Fast but not so effective compression.

  * ``HEAVY``
Heavy, Effective but slow compression.

  """

  filepath: str = ...

  """

  Cache file path

  """

  frame_end: int = ...

  """

  Frame on which the simulation stops

  """

  frame_start: int = ...

  """

  Frame on which the simulation starts

  """

  frame_step: int = ...

  """

  Number of frames between cached frames

  """

  index: int = ...

  """

  Index number of cache files

  """

  info: str = ...

  """

  Info on current cache status

  """

  is_baked: bool = ...

  is_baking: bool = ...

  is_frame_skip: bool = ...

  is_outdated: bool = ...

  name: str = ...

  """

  Cache name

  """

  point_caches: typing.Union[PointCaches, typing.Sequence[PointCacheItem], typing.Mapping[str, PointCacheItem], bpy_prop_collection] = ...

  use_disk_cache: bool = ...

  """

  Save cache files to disk (.blend file must be saved first)

  """

  use_external: bool = ...

  """

  Read cache from an external location

  """

  use_library_path: bool = ...

  """

  Use this file's path for the disk cache when library linked into another file (for local bakes per scene file, disable this option)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PointCacheItem(bpy_struct):

  """

  Point cache for physics simulations

  """

  compression: str = ...

  """

  Compression method to be used

  * ``NO``
None, No compression.

  * ``LIGHT``
Lite, Fast but not so effective compression.

  * ``HEAVY``
Heavy, Effective but slow compression.

  """

  filepath: str = ...

  """

  Cache file path

  """

  frame_end: int = ...

  """

  Frame on which the simulation stops

  """

  frame_start: int = ...

  """

  Frame on which the simulation starts

  """

  frame_step: int = ...

  """

  Number of frames between cached frames

  """

  index: int = ...

  """

  Index number of cache files

  """

  info: str = ...

  """

  Info on current cache status

  """

  is_baked: bool = ...

  is_baking: bool = ...

  is_frame_skip: bool = ...

  is_outdated: bool = ...

  name: str = ...

  """

  Cache name

  """

  use_disk_cache: bool = ...

  """

  Save cache files to disk (.blend file must be saved first)

  """

  use_external: bool = ...

  """

  Read cache from an external location

  """

  use_library_path: bool = ...

  """

  Use this file's path for the disk cache when library linked into another file (for local bakes per scene file, disable this option)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PointCaches(bpy_struct):

  """

  Collection of point caches

  """

  active_index: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PolygonFloatProperties(bpy_struct):

  """

  Collection of float properties

  """

  def new(self, name: str = 'Float Prop') -> MeshPolygonFloatPropertyLayer:

    """

    Add a float property layer to Mesh

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PolygonIntProperties(bpy_struct):

  """

  Collection of int properties

  """

  def new(self, name: str = 'Int Prop') -> MeshPolygonIntPropertyLayer:

    """

    Add a integer property layer to Mesh

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PolygonStringProperties(bpy_struct):

  """

  Collection of string properties

  """

  def new(self, name: str = 'String Prop') -> MeshPolygonStringPropertyLayer:

    """

    Add a string property layer to Mesh

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Pose(bpy_struct):

  """

  A collection of pose channels, including settings for animating bones

  """

  animation_visualization: AnimViz = ...

  """

  Animation data for this data-block

  """

  bone_groups: typing.Union[BoneGroups, typing.Sequence[BoneGroup], typing.Mapping[str, BoneGroup], bpy_prop_collection] = ...

  """

  Groups of the bones

  """

  bones: typing.Union[typing.Sequence[PoseBone], typing.Mapping[str, PoseBone], bpy_prop_collection] = ...

  """

  Individual pose bones for the armature

  """

  ik_param: IKParam = ...

  """

  Parameters for IK solver

  """

  ik_solver: str = ...

  """

  Selection of IK solver for IK chain

  * ``LEGACY``
Standard, Original IK solver.

  * ``ITASC``
iTaSC, Multi constraint, stateful IK solver.

  """

  use_auto_ik: bool = ...

  """

  Add temporary IK constraints while grabbing bones in Pose Mode

  """

  use_mirror_relative: bool = ...

  """

  Apply relative transformations in X-mirror mode (not supported with Auto IK)

  """

  use_mirror_x: bool = ...

  """

  Apply changes to matching bone on opposite side of X-Axis

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PoseBone(bpy_struct):

  """

  Channel defining pose data for a bone in a Pose

  """

  bbone_curveinx: float = ...

  """

  X-axis handle offset for start of the B-Bone's curve, adjusts curvature

  """

  bbone_curveiny: float = ...

  """

  Y-axis handle offset for start of the B-Bone's curve, adjusts curvature

  """

  bbone_curveoutx: float = ...

  """

  X-axis handle offset for end of the B-Bone's curve, adjusts curvature

  """

  bbone_curveouty: float = ...

  """

  Y-axis handle offset for end of the B-Bone's curve, adjusts curvature

  """

  bbone_custom_handle_end: PoseBone = ...

  """

  Bone that serves as the end handle for the B-Bone curve

  """

  bbone_custom_handle_start: PoseBone = ...

  """

  Bone that serves as the start handle for the B-Bone curve

  """

  bbone_easein: float = ...

  """

  Length of first Bezier Handle (for B-Bones only)

  """

  bbone_easeout: float = ...

  """

  Length of second Bezier Handle (for B-Bones only)

  """

  bbone_rollin: float = ...

  """

  Roll offset for the start of the B-Bone, adjusts twist

  """

  bbone_rollout: float = ...

  """

  Roll offset for the end of the B-Bone, adjusts twist

  """

  bbone_scaleinx: float = ...

  """

  X-axis scale factor for start of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_scaleiny: float = ...

  """

  Y-axis scale factor for start of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_scaleoutx: float = ...

  """

  X-axis scale factor for end of the B-Bone, adjusts thickness (for tapering effects)

  """

  bbone_scaleouty: float = ...

  """

  Y-axis scale factor for end of the B-Bone, adjusts thickness (for tapering effects)

  """

  bone: Bone = ...

  """

  Bone associated with this PoseBone

  """

  bone_group: BoneGroup = ...

  """

  Bone Group this pose channel belongs to

  """

  bone_group_index: int = ...

  """

  Bone Group this pose channel belongs to (0=no group)

  """

  child: PoseBone = ...

  """

  Child of this pose bone

  """

  constraints: typing.Union[PoseBoneConstraints, typing.Sequence[Constraint], typing.Mapping[str, Constraint], bpy_prop_collection] = ...

  """

  Constraints that act on this PoseChannel

  """

  custom_shape: Object = ...

  """

  Object that defines custom draw type for this bone

  """

  custom_shape_scale: float = ...

  """

  Adjust the size of the custom shape

  """

  custom_shape_transform: PoseBone = ...

  """

  Bone that defines the display transform of this custom shape

  """

  head: typing.Tuple[float, float, float] = ...

  """

  Location of head of the channel's bone

  """

  ik_linear_weight: float = ...

  """

  Weight of scale constraint for IK

  """

  ik_max_x: float = ...

  """

  Maximum angles for IK Limit

  """

  ik_max_y: float = ...

  """

  Maximum angles for IK Limit

  """

  ik_max_z: float = ...

  """

  Maximum angles for IK Limit

  """

  ik_min_x: float = ...

  """

  Minimum angles for IK Limit

  """

  ik_min_y: float = ...

  """

  Minimum angles for IK Limit

  """

  ik_min_z: float = ...

  """

  Minimum angles for IK Limit

  """

  ik_rotation_weight: float = ...

  """

  Weight of rotation constraint for IK

  """

  ik_stiffness_x: float = ...

  """

  IK stiffness around the X axis

  """

  ik_stiffness_y: float = ...

  """

  IK stiffness around the Y axis

  """

  ik_stiffness_z: float = ...

  """

  IK stiffness around the Z axis

  """

  ik_stretch: float = ...

  """

  Allow scaling of the bone for IK

  """

  is_in_ik_chain: bool = ...

  """

  Is part of an IK chain

  """

  length: float = ...

  """

  Length of the bone

  """

  location: typing.Tuple[float, float, float] = ...

  lock_ik_x: bool = ...

  """

  Disallow movement around the X axis

  """

  lock_ik_y: bool = ...

  """

  Disallow movement around the Y axis

  """

  lock_ik_z: bool = ...

  """

  Disallow movement around the Z axis

  """

  lock_location: typing.Tuple[bool, bool, bool] = ...

  """

  Lock editing of location when transforming

  """

  lock_rotation: typing.Tuple[bool, bool, bool] = ...

  """

  Lock editing of rotation when transforming

  """

  lock_rotation_w: bool = ...

  """

  Lock editing of 'angle' component of four-component rotations when transforming

  """

  lock_rotations_4d: bool = ...

  """

  Lock editing of four component rotations by components (instead of as Eulers)

  """

  lock_scale: typing.Tuple[bool, bool, bool] = ...

  """

  Lock editing of scale when transforming

  """

  matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Final 4x4 matrix after constraints and drivers are applied (object space)

  """

  matrix_basis: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Alternative access to location/scale/rotation relative to the parent and own rest bone

  """

  matrix_channel: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  4x4 matrix, before constraints

  """

  motion_path: MotionPath = ...

  """

  Motion Path for this element

  """

  name: str = ...

  parent: PoseBone = ...

  """

  Parent of this pose bone

  """

  rotation_axis_angle: typing.Tuple[float, float, float, float] = ...

  """

  Angle of Rotation for Axis-Angle rotation representation

  """

  rotation_euler: typing.Tuple[float, float, float] = ...

  """

  Rotation in Eulers

  """

  rotation_mode: str = ...

  """

  * ``QUATERNION``
Quaternion (WXYZ), No Gimbal Lock.

  * ``XYZ``
XYZ Euler, XYZ Rotation Order - prone to Gimbal Lock (default).

  * ``XZY``
XZY Euler, XZY Rotation Order - prone to Gimbal Lock.

  * ``YXZ``
YXZ Euler, YXZ Rotation Order - prone to Gimbal Lock.

  * ``YZX``
YZX Euler, YZX Rotation Order - prone to Gimbal Lock.

  * ``ZXY``
ZXY Euler, ZXY Rotation Order - prone to Gimbal Lock.

  * ``ZYX``
ZYX Euler, ZYX Rotation Order - prone to Gimbal Lock.

  * ``AXIS_ANGLE``
Axis Angle, Axis Angle (W+XYZ), defines a rotation around some axis defined by 3D-Vector.

  """

  rotation_quaternion: typing.Tuple[float, float, float, float] = ...

  """

  Rotation in Quaternions

  """

  scale: typing.Tuple[float, float, float] = ...

  tail: typing.Tuple[float, float, float] = ...

  """

  Location of tail of the channel's bone

  """

  use_custom_shape_bone_size: bool = ...

  """

  Scale the custom object by the bone length

  """

  use_ik_limit_x: bool = ...

  """

  Limit movement around the X axis

  """

  use_ik_limit_y: bool = ...

  """

  Limit movement around the Y axis

  """

  use_ik_limit_z: bool = ...

  """

  Limit movement around the Z axis

  """

  use_ik_linear_control: bool = ...

  """

  Apply channel size as IK constraint if stretching is enabled

  """

  use_ik_rotation_control: bool = ...

  """

  Apply channel rotation as IK constraint

  """

  basename: typing.Any = ...

  """

  The name of this bone before any '.' character

  (readonly)

  """

  center: typing.Any = ...

  """

  The midpoint between the head and the tail.

  (readonly)

  """

  children: typing.Any = ...

  """

  (readonly)

  """

  children_recursive: typing.Any = ...

  """

  A list of all children from this bone.

    Note: Takes ``O(len(bones)**2)`` time.

  (readonly)

  """

  children_recursive_basename: typing.Any = ...

  """

  Returns a chain of children with the same base name as this bone.
Only direct chains are supported, forks caused by multiple children
with matching base names will terminate the function
and not be returned.

  Note: Takes ``O(len(bones)**2)`` time.

  (readonly)

  """

  parent_recursive: typing.Any = ...

  """

  A list of parents, starting with the immediate parent

  (readonly)

  """

  vector: typing.Any = ...

  """

  The direction this bone is pointing.
Utility function for (tail - head)

  (readonly)

  """

  x_axis: typing.Any = ...

  """

  Vector pointing down the x-axis of the bone.

  (readonly)

  """

  y_axis: typing.Any = ...

  """

  Vector pointing down the y-axis of the bone.

  (readonly)

  """

  z_axis: typing.Any = ...

  """

  Vector pointing down the z-axis of the bone.

  (readonly)

  """

  def evaluate_envelope(self, point: typing.Tuple[float, float, float]) -> float:

    """

    Calculate bone envelope at given point

    """

    ...

  def bbone_segment_matrix(self, index: int, rest: bool = False) -> typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]]:

    """

    Retrieve the matrix of the joint between B-Bone segments if available

    """

    ...

  def compute_bbone_handles(self, rest: bool = False, ease: bool = False, offsets: bool = False) -> None:

    """

    Retrieve the vectors and rolls coming from B-Bone custom handles

    """

    ...

  def parent_index(self, parent_test: typing.Any) -> None:

    """

    The same as 'bone in other_bone.parent_recursive'
but saved generating a list.

    """

    ...

  def translate(self, vec: typing.Any) -> None:

    """

    Utility function to add *vec* to the head and tail of this bone

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PoseBoneConstraints(bpy_struct):

  """

  Collection of pose bone constraints

  """

  active: Constraint = ...

  """

  Active PoseChannel constraint

  """

  def new(self, type: str) -> Constraint:

    """

    Add a constraint to this object

    """

    ...

  def remove(self, constraint: Constraint) -> None:

    """

    Remove a constraint from this object

    """

    ...

  def move(self, from_index: int, to_index: int) -> None:

    """

    Move a constraint to a different position

    """

    ...

  def copy(self, constraint: Constraint) -> Constraint:

    """

    Add a new constraint that is a copy of the given one

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Preferences(bpy_struct):

  """

  Global preferences

  """

  active_section: str = ...

  """

  Active section of the preferences shown in the user interface

  """

  addons: typing.Union[Addons, typing.Sequence[Addon], typing.Mapping[str, Addon], bpy_prop_collection] = ...

  app_template: str = ...

  autoexec_paths: typing.Union[PathCompareCollection, typing.Sequence[PathCompare], typing.Mapping[str, PathCompare], bpy_prop_collection] = ...

  edit: PreferencesEdit = ...

  """

  Settings for interacting with Blender data

  """

  experimental: PreferencesExperimental = ...

  """

  Settings for features that are still early in their development stage

  """

  filepaths: PreferencesFilePaths = ...

  """

  Default paths for external files

  """

  inputs: PreferencesInput = ...

  """

  Settings for input devices

  """

  is_dirty: bool = ...

  """

  Preferences have changed

  """

  keymap: PreferencesKeymap = ...

  """

  Shortcut setup for keyboards and other input devices

  """

  studio_lights: typing.Union[StudioLights, typing.Sequence[StudioLight], typing.Mapping[str, StudioLight], bpy_prop_collection] = ...

  system: PreferencesSystem = ...

  """

  Graphics driver and operating system settings

  """

  themes: typing.Union[typing.Sequence[Theme], typing.Mapping[str, Theme], bpy_prop_collection] = ...

  ui_styles: typing.Union[typing.Sequence[ThemeStyle], typing.Mapping[str, ThemeStyle], bpy_prop_collection] = ...

  use_preferences_save: bool = ...

  """

  Save preferences on exit when modified (unless factory settings have been loaded)

  """

  version: typing.Tuple[int, int, int] = ...

  """

  Version of Blender the userpref.blend was saved with

  """

  view: PreferencesView = ...

  """

  Preferences related to viewing data

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PreferencesEdit(bpy_struct):

  """

  Settings for interacting with Blender data

  """

  auto_keying_mode: str = ...

  """

  Mode of automatic keyframe insertion for Objects and Bones (default setting used for new Scenes)

  """

  collection_instance_empty_size: float = ...

  """

  Display size of the empty when new collection instances are created

  """

  fcurve_new_auto_smoothing: str = ...

  """

  Auto Handle Smoothing mode used for newly added F-Curves

  * ``NONE``
None, Automatic handles only take immediately adjacent keys into account.

  * ``CONT_ACCEL``
Continuous Acceleration, Automatic handles are adjusted to avoid jumps in acceleration, resulting in smoother curves. However, key changes may affect interpolation over a larger stretch of the curve.

  """

  fcurve_unselected_alpha: float = ...

  """

  Amount that unselected F-Curves stand out from the background (Graph Editor)

  """

  grease_pencil_default_color: typing.Tuple[float, float, float, float] = ...

  """

  Color of new annotation layers

  """

  grease_pencil_eraser_radius: int = ...

  """

  Radius of eraser 'brush'

  """

  grease_pencil_euclidean_distance: int = ...

  """

  Distance moved by mouse when drawing stroke to include

  """

  grease_pencil_manhattan_distance: int = ...

  """

  Pixels moved by mouse per axis when drawing stroke

  """

  keyframe_new_handle_type: str = ...

  """

  Handle type for handles of new keyframes

  * ``FREE``
Free, Completely independent manually set handle.

  * ``ALIGNED``
Aligned, Manually set handle with rotation locked together with its pair.

  * ``VECTOR``
Vector, Automatic handles that create straight lines.

  * ``AUTO``
Automatic, Automatic handles that create smooth curves.

  * ``AUTO_CLAMPED``
Auto Clamped, Automatic handles that create smooth curves which only change direction at keyframes.

  """

  keyframe_new_interpolation_type: str = ...

  """

  Interpolation mode used for first keyframe on newly added F-Curves (subsequent keyframes take interpolation from preceding keyframe)

  * ``CONSTANT``
Constant, No interpolation, value of A gets held until B is encountered.

  * ``LINEAR``
Linear, Straight-line interpolation between A and B (i.e. no ease in/out).

  * ``BEZIER``
Bezier, Smooth interpolation between A and B, with some control over curve shape.

  * ``SINE``
Sinusoidal, Sinusoidal easing (weakest, almost linear but with a slight curvature).

  * ``QUAD``
Quadratic, Quadratic easing.

  * ``CUBIC``
Cubic, Cubic easing.

  * ``QUART``
Quartic, Quartic easing.

  * ``QUINT``
Quintic, Quintic easing.

  * ``EXPO``
Exponential, Exponential easing (dramatic).

  * ``CIRC``
Circular, Circular easing (strongest and most dynamic).

  * ``BACK``
Back, Cubic easing with overshoot and settle.

  * ``BOUNCE``
Bounce, Exponentially decaying parabolic bounce, like when objects collide.

  * ``ELASTIC``
Elastic, Exponentially decaying sine wave, like an elastic band.

  """

  material_link: str = ...

  """

  Toggle whether the material is linked to object data or the object block

  * ``OBDATA``
Object Data, Toggle whether the material is linked to object data or the object block.

  * ``OBJECT``
Object, Toggle whether the material is linked to object data or the object block.

  """

  node_margin: int = ...

  """

  Minimum distance between nodes for Auto-offsetting nodes

  """

  object_align: str = ...

  """

  When adding objects from a 3D View menu, either align them with that view or with the world

  * ``WORLD``
World, Align newly added objects to the world coordinate system.

  * ``VIEW``
View, Align newly added objects to the active 3D View direction.

  * ``CURSOR``
3D Cursor, Align newly added objects to the 3D Cursor's rotation.

  """

  sculpt_paint_overlay_color: typing.Tuple[float, float, float] = ...

  """

  Color of texture overlay

  """

  undo_memory_limit: int = ...

  """

  Maximum memory usage in megabytes (0 means unlimited)

  """

  undo_steps: int = ...

  """

  Number of undo steps available (smaller values conserve memory)

  """

  use_auto_keying: bool = ...

  """

  Automatic keyframe insertion for Objects and Bones (default setting used for new Scenes)

  """

  use_auto_keying_warning: bool = ...

  """

  Show warning indicators when transforming objects and bones if auto keying is enabled

  """

  use_cursor_lock_adjust: bool = ...

  """

  Place the cursor without 'jumping' to the new location (when lock-to-cursor is used)

  """

  use_duplicate_action: bool = ...

  """

  Causes actions to be duplicated with the data-blocks

  """

  use_duplicate_armature: bool = ...

  """

  Causes armature data to be duplicated with the object

  """

  use_duplicate_curve: bool = ...

  """

  Causes curve data to be duplicated with the object

  """

  use_duplicate_grease_pencil: bool = ...

  """

  Causes grease pencil data to be duplicated with the object

  """

  use_duplicate_hair: bool = ...

  """

  Causes hair data to be duplicated with the object

  """

  use_duplicate_light: bool = ...

  """

  Causes light data to be duplicated with the object

  """

  use_duplicate_lightprobe: bool = ...

  """

  Causes light probe data to be duplicated with the object

  """

  use_duplicate_material: bool = ...

  """

  Causes material data to be duplicated with the object

  """

  use_duplicate_mesh: bool = ...

  """

  Causes mesh data to be duplicated with the object

  """

  use_duplicate_metaball: bool = ...

  """

  Causes metaball data to be duplicated with the object

  """

  use_duplicate_particle: bool = ...

  """

  Causes particle systems to be duplicated with the object

  """

  use_duplicate_pointcloud: bool = ...

  """

  Causes point cloud data to be duplicated with the object

  """

  use_duplicate_surface: bool = ...

  """

  Causes surface data to be duplicated with the object

  """

  use_duplicate_text: bool = ...

  """

  Causes text data to be duplicated with the object

  """

  use_duplicate_volume: bool = ...

  """

  Causes volume data to be duplicated with the object

  """

  use_enter_edit_mode: bool = ...

  """

  Enter Edit Mode automatically after adding a new object

  """

  use_global_undo: bool = ...

  """

  Global undo works by keeping a full copy of the file itself in memory, so takes extra memory

  """

  use_insertkey_xyz_to_rgb: bool = ...

  """

  Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis

  """

  use_keyframe_insert_available: bool = ...

  """

  Automatic keyframe insertion in available F-Curves

  """

  use_keyframe_insert_needed: bool = ...

  """

  Keyframe insertion only when keyframe needed

  """

  use_mouse_depth_cursor: bool = ...

  """

  Use the surface depth for cursor placement

  """

  use_negative_frames: bool = ...

  """

  Current frame number can be manually set to a negative value

  """

  use_visual_keying: bool = ...

  """

  Use Visual keying automatically for constrained objects

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PreferencesExperimental(bpy_struct):

  """

  Experimental features

  """

  use_cycles_debug: bool = ...

  """

  Enable Cycles debugging options for developers

  """

  use_new_geometry_nodes: bool = ...

  """

  Enable the new geometry nodes system in the ui

  """

  use_new_hair_type: bool = ...

  """

  Enable the new hair type in the ui

  """

  use_new_point_cloud_type: bool = ...

  """

  Enable the new point cloud type in the ui

  """

  use_sculpt_tools_tilt: bool = ...

  """

  Support for pen tablet tilt events in Sculpt Mode

  """

  use_sculpt_vertex_colors: bool = ...

  """

  Use the new Vertex Painting system

  """

  use_switch_object_operator: bool = ...

  """

  Enable the operator to switch objects by pressing D

  """

  use_undo_legacy: bool = ...

  """

  Use legacy undo (slower than the new default one, but may be more stable in some cases)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PreferencesFilePaths(bpy_struct):

  """

  Default paths for external files

  """

  animation_player: str = ...

  """

  Path to a custom animation/frame sequence player

  """

  animation_player_preset: str = ...

  """

  Preset configs for external animation players

  * ``INTERNAL``
Internal, Built-in animation player.

  * ``DJV``
DJV, Open source frame player: http://djv.sourceforge.net.

  * ``FRAMECYCLER``
FrameCycler, Frame player from IRIDAS.

  * ``RV``
RV, Frame player from Tweak Software.

  * ``MPLAYER``
MPlayer, Media player for video & png/jpeg/sgi image sequences.

  * ``CUSTOM``
Custom, Custom animation player executable path.

  """

  auto_save_time: int = ...

  """

  The time (in minutes) to wait between automatic temporary saves

  """

  font_directory: str = ...

  """

  The default directory to search for loading fonts

  """

  hide_recent_locations: bool = ...

  """

  Hide recent locations in the file selector

  """

  hide_system_bookmarks: bool = ...

  """

  Hide system bookmarks in the file selector

  """

  i18n_branches_directory: str = ...

  """

  The path to the '/branches' directory of your local svn-translation copy, to allow translating from the UI

  """

  image_editor: str = ...

  """

  Path to an image editor

  """

  recent_files: int = ...

  """

  Maximum number of recently opened files to remember

  """

  render_cache_directory: str = ...

  """

  Where to cache raw render results

  """

  render_output_directory: str = ...

  """

  The default directory for rendering output, for new scenes

  """

  save_version: int = ...

  """

  The number of old versions to maintain in the current directory, when manually saving

  """

  script_directory: str = ...

  """

  Alternate script path, matching the default layout with subdirs: startup, add-ons & modules (requires restart)

  """

  show_hidden_files_datablocks: bool = ...

  """

  Hide files and data-blocks if their name start with a dot (.*)

  """

  sound_directory: str = ...

  """

  The default directory to search for sounds

  """

  temporary_directory: str = ...

  """

  The directory for storing temporary save files

  """

  texture_directory: str = ...

  """

  The default directory to search for textures

  """

  use_auto_save_temporary_files: bool = ...

  """

  Automatic saving of temporary files in temp directory, uses process ID (sculpt & edit-mode data won't be saved!)

  """

  use_file_compression: bool = ...

  """

  Enable file compression when saving .blend files

  """

  use_filter_files: bool = ...

  """

  Display only files with extensions in the image select window

  """

  use_load_ui: bool = ...

  """

  Load user interface setup when loading .blend files

  """

  use_relative_paths: bool = ...

  """

  Default relative path option for the file selector

  """

  use_save_preview_images: bool = ...

  """

  Enables automatic saving of preview images in the .blend file

  """

  use_scripts_auto_execute: bool = ...

  """

  Allow any .blend file to run scripts automatically (unsafe with blend files from an untrusted source)

  """

  use_tabs_as_spaces: bool = ...

  """

  Automatically convert all new tabs into spaces for new and loaded text files

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PreferencesInput(bpy_struct):

  """

  Settings for input devices

  """

  drag_threshold: int = ...

  """

  Number of pixels to drag before a drag event is triggered for keyboard and other non mouse/tablet input (otherwise click events are detected)

  """

  drag_threshold_mouse: int = ...

  """

  Number of pixels to drag before a tweak/drag event is triggered for mouse/track-pad input (otherwise click events are detected)

  """

  drag_threshold_tablet: int = ...

  """

  Number of pixels to drag before a tweak/drag event is triggered for tablet input (otherwise click events are detected)

  """

  invert_mouse_zoom: bool = ...

  """

  Invert the axis of mouse movement for zooming

  """

  invert_zoom_wheel: bool = ...

  """

  Swap the Mouse Wheel zoom direction

  """

  mouse_double_click_time: int = ...

  """

  Time/delay (in ms) for a double click

  """

  mouse_emulate_3_button_modifier: str = ...

  """

  Hold this modifier to emulate the middle mouse button

  """

  move_threshold: int = ...

  """

  Number of pixels to before the cursor is considered to have moved (used for cycling selected items on successive clicks)

  """

  navigation_mode: str = ...

  """

  Which method to use for viewport navigation

  * ``WALK``
Walk, Interactively walk or free navigate around the scene.

  * ``FLY``
Fly, Use fly dynamics to navigate the scene.

  """

  ndof_deadzone: float = ...

  """

  Threshold of initial movement needed from the device's rest position

  """

  ndof_fly_helicopter: bool = ...

  """

  Device up/down directly controls the Z position of the 3D viewport

  """

  ndof_lock_horizon: bool = ...

  """

  Keep horizon level while flying with 3D Mouse

  """

  ndof_orbit_sensitivity: float = ...

  """

  Overall sensitivity of the 3D Mouse for orbiting

  """

  ndof_pan_yz_swap_axis: bool = ...

  """

  Pan using up/down on the device (otherwise forward/backward)

  """

  ndof_panx_invert_axis: bool = ...

  ndof_pany_invert_axis: bool = ...

  ndof_panz_invert_axis: bool = ...

  ndof_rotx_invert_axis: bool = ...

  ndof_roty_invert_axis: bool = ...

  ndof_rotz_invert_axis: bool = ...

  ndof_sensitivity: float = ...

  """

  Overall sensitivity of the 3D Mouse for panning

  """

  ndof_show_guide: bool = ...

  """

  Display the center and axis during rotation

  """

  ndof_view_navigate_method: str = ...

  """

  Navigation style in the viewport

  * ``FREE``
Free, Use full 6 degrees of freedom by default.

  * ``ORBIT``
Orbit, Orbit about the view center by default.

  """

  ndof_view_rotate_method: str = ...

  """

  Rotation style in the viewport

  * ``TURNTABLE``
Turntable, Use turntable style rotation in the viewport.

  * ``TRACKBALL``
Trackball, Use trackball style rotation in the viewport.

  """

  ndof_zoom_invert: bool = ...

  """

  Zoom using opposite direction

  """

  pressure_softness: float = ...

  """

  Adjusts softness of the low pressure response onset using a gamma curve

  """

  pressure_threshold_max: float = ...

  """

  Raw input pressure value that is interpreted as 100% by Blender

  """

  tablet_api: str = ...

  """

  Select the tablet API to use for pressure sensitivity (restart Blender for changes to take effect)

  * ``AUTOMATIC``
Automatic, Automatically choose Wintab or Windows Ink depending on the device.

  * ``WINDOWS_INK``
Windows Ink, Use native Windows Ink API, for modern tablet and pen devices. Requires Windows 8 or newer.

  * ``WINTAB``
Wintab, Use Wintab driver for older tablets and Windows versions.

  """

  use_auto_perspective: bool = ...

  """

  Automatically switch between orthographic and perspective when changing from top/front/side views

  """

  use_camera_lock_parent: bool = ...

  """

  When the camera is locked to the view and in fly mode, transform the parent rather than the camera

  """

  use_drag_immediately: bool = ...

  """

  Moving things with a mouse drag confirms when releasing the button

  """

  use_emulate_numpad: bool = ...

  """

  Main 1 to 0 keys act as the numpad ones (useful for laptops)

  """

  use_mouse_continuous: bool = ...

  """

  Allow moving the mouse outside the view on some manipulations (transform, ui control drag)

  """

  use_mouse_depth_navigate: bool = ...

  """

  Use the depth under the mouse to improve view pan/rotate/zoom functionality

  """

  use_mouse_emulate_3_button: bool = ...

  """

  Emulate Middle Mouse with Alt+Left Mouse

  """

  use_ndof: bool = ...

  use_numeric_input_advanced: bool = ...

  """

  When entering numbers while transforming, default to advanced mode for full math expression evaluation

  """

  use_rotate_around_active: bool = ...

  """

  Use selection as the pivot point

  """

  use_trackpad_natural: bool = ...

  """

  If your system uses 'natural' scrolling, this option keeps consistent trackpad usage throughout the UI

  """

  use_zoom_to_mouse: bool = ...

  """

  Zoom in towards the mouse pointer's position in the 3D view, rather than the 2D window center

  """

  view_rotate_method: str = ...

  """

  Orbit method in the viewport

  * ``TURNTABLE``
Turntable, Turntable keeps the Z-axis upright while orbiting.

  * ``TRACKBALL``
Trackball, Trackball allows you to tumble your view at any angle.

  """

  view_rotate_sensitivity_trackball: float = ...

  """

  Scale trackball orbit sensitivity

  """

  view_rotate_sensitivity_turntable: float = ...

  """

  Rotation amount per-pixel to control how fast the viewport orbits

  """

  view_zoom_axis: str = ...

  """

  Axis of mouse movement to zoom in or out on

  * ``VERTICAL``
Vertical, Zoom in and out based on vertical mouse movement.

  * ``HORIZONTAL``
Horizontal, Zoom in and out based on horizontal mouse movement.

  """

  view_zoom_method: str = ...

  """

  Which style to use for viewport scaling

  * ``CONTINUE``
Continue, Continuous zooming. The zoom direction and speed depends on how far along the set Zoom Axis the mouse has moved.

  * ``DOLLY``
Dolly, Zoom in and out based on mouse movement along the set Zoom Axis.

  * ``SCALE``
Scale, Zoom in and out as if you are scaling the view, mouse movements relative to center.

  """

  walk_navigation: WalkNavigation = ...

  """

  Settings for walk navigation mode

  """

  wheel_scroll_lines: int = ...

  """

  Number of lines scrolled at a time with the mouse wheel

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PreferencesKeymap(bpy_struct):

  """

  Shortcut setup for keyboards and other input devices

  """

  active_keyconfig: str = ...

  """

  The name of the active key configuration

  """

  show_ui_keyconfig: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PreferencesSystem(bpy_struct):

  """

  Graphics driver and operating system settings

  """

  anisotropic_filter: str = ...

  """

  Quality of the anisotropic filtering (values greater than 1.0 enable anisotropic filtering)

  """

  audio_channels: str = ...

  """

  Audio channel count

  * ``MONO``
Mono, Set audio channels to mono.

  * ``STEREO``
Stereo, Set audio channels to stereo.

  * ``SURROUND4``
4 Channels, Set audio channels to 4 channels.

  * ``SURROUND51``
5.1 Surround, Set audio channels to 5.1 surround sound.

  * ``SURROUND71``
7.1 Surround, Set audio channels to 7.1 surround sound.

  """

  audio_device: str = ...

  """

  Audio output device

  * ``Null``
None, Null device - there will be no audio output.

  """

  audio_mixing_buffer: str = ...

  """

  Number of samples used by the audio mixing buffer

  * ``SAMPLES_256``
256 Samples, Set audio mixing buffer size to 256 samples.

  * ``SAMPLES_512``
512 Samples, Set audio mixing buffer size to 512 samples.

  * ``SAMPLES_1024``
1024 Samples, Set audio mixing buffer size to 1024 samples.

  * ``SAMPLES_2048``
2048 Samples, Set audio mixing buffer size to 2048 samples.

  * ``SAMPLES_4096``
4096 Samples, Set audio mixing buffer size to 4096 samples.

  * ``SAMPLES_8192``
8192 Samples, Set audio mixing buffer size to 8192 samples.

  * ``SAMPLES_16384``
16384 Samples, Set audio mixing buffer size to 16384 samples.

  * ``SAMPLES_32768``
32768 Samples, Set audio mixing buffer size to 32768 samples.

  """

  audio_sample_format: str = ...

  """

  Audio sample format

  * ``U8``
8-bit Unsigned, Set audio sample format to 8 bit unsigned integer.

  * ``S16``
16-bit Signed, Set audio sample format to 16 bit signed integer.

  * ``S24``
24-bit Signed, Set audio sample format to 24 bit signed integer.

  * ``S32``
32-bit Signed, Set audio sample format to 32 bit signed integer.

  * ``FLOAT``
32-bit Float, Set audio sample format to 32 bit float.

  * ``DOUBLE``
64-bit Float, Set audio sample format to 64 bit float.

  """

  audio_sample_rate: str = ...

  """

  Audio sample rate

  * ``RATE_44100``
44.1 kHz, Set audio sampling rate to 44100 samples per second.

  * ``RATE_48000``
48 kHz, Set audio sampling rate to 48000 samples per second.

  * ``RATE_96000``
96 kHz, Set audio sampling rate to 96000 samples per second.

  * ``RATE_192000``
192 kHz, Set audio sampling rate to 192000 samples per second.

  """

  dpi: int = ...

  gl_clip_alpha: float = ...

  """

  Clip alpha below this threshold in the 3D textured view

  """

  gl_texture_limit: str = ...

  """

  Limit the texture size to save graphics memory

  """

  image_draw_method: str = ...

  """

  Method used for displaying images on the screen

  * ``AUTO``
Automatic, Automatically choose method based on GPU and image.

  * ``2DTEXTURE``
2D Texture, Use CPU for display transform and draw image with 2D texture.

  * ``GLSL``
GLSL, Use GLSL shaders for display transform and draw image with 2D texture.

  """

  legacy_compute_device_type: int = ...

  """

  For backwards compatibility only

  """

  light_ambient: typing.Tuple[float, float, float] = ...

  """

  Color of the ambient light that uniformly lit the scene

  """

  memory_cache_limit: int = ...

  """

  Memory cache limit (in megabytes)

  """

  opensubdiv_compute_type: str = ...

  """

  Type of computer back-end used with OpenSubdiv

  """

  pixel_size: float = ...

  scrollback: int = ...

  """

  Maximum number of lines to store for the console buffer

  """

  sequencer_disk_cache_compression: str = ...

  """

  Smaller compression will result in larger files, but less decoding overhead

  * ``NONE``
None, Requires fast storage, but uses minimum CPU resources.

  * ``LOW``
Low, Doesn't require fast storage and uses less CPU resources.

  * ``HIGH``
High, Works on slower storage devices and uses most CPU resources.

  """

  sequencer_disk_cache_dir: str = ...

  """

  Override default directory

  """

  sequencer_disk_cache_size_limit: int = ...

  """

  Disk cache limit (in gigabytes)

  """

  solid_lights: typing.Union[typing.Sequence[UserSolidLight], typing.Mapping[str, UserSolidLight], bpy_prop_collection] = ...

  """

  Lights user to display objects in solid draw mode

  """

  texture_collection_rate: int = ...

  """

  Number of seconds between each run of the GL texture garbage collector

  """

  texture_time_out: int = ...

  """

  Time since last access of a GL texture in seconds after which it is freed (set to 0 to keep textures allocated)

  """

  ui_line_width: float = ...

  """

  Suggested line thickness and point size in pixels, for add-ons drawing custom user interface elements, based on operating system settings and Blender UI scale

  """

  ui_scale: float = ...

  """

  Size multiplier to use when drawing custom user interface elements, so that they are scaled correctly on screens with different DPI. This value is based on operating system DPI settings and Blender display scale

  """

  use_edit_mode_smooth_wire: bool = ...

  """

  Enable Edit-Mode edge smoothing, reducing aliasing, requires restart

  """

  use_overlay_smooth_wire: bool = ...

  """

  Enable overlay smooth wires, reducing aliasing

  """

  use_region_overlap: bool = ...

  """

  Draw tool/property regions over the main region

  """

  use_select_pick_depth: bool = ...

  """

  Use the depth buffer for picking 3D View selection (without this the front most object may not be selected first)

  """

  use_sequencer_disk_cache: bool = ...

  """

  Store cached images to disk

  """

  use_studio_light_edit: bool = ...

  """

  View the result of the studio light editor in the viewport

  """

  vbo_collection_rate: int = ...

  """

  Number of seconds between each run of the GL Vertex buffer object garbage collector

  """

  vbo_time_out: int = ...

  """

  Time since last access of a GL Vertex buffer object in seconds after which it is freed (set to 0 to keep vbo allocated)

  """

  viewport_aa: str = ...

  """

  Method of anti-aliasing in 3d viewport

  * ``OFF``
No Anti-Aliasing, Scene will be rendering without any anti-aliasing.

  * ``FXAA``
Single Pass Anti-Aliasing, Scene will be rendered using a single pass anti-aliasing method (FXAA).

  * ``5``
5 Samples, Scene will be rendered using 5 anti-aliasing samples.

  * ``8``
8 Samples, Scene will be rendered using 8 anti-aliasing samples.

  * ``11``
11 Samples, Scene will be rendered using 11 anti-aliasing samples.

  * ``16``
16 Samples, Scene will be rendered using 16 anti-aliasing samples.

  * ``32``
32 Samples, Scene will be rendered using 32 anti-aliasing samples.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PreferencesView(bpy_struct):

  """

  Preferences related to viewing data

  """

  color_picker_type: str = ...

  """

  Different styles of displaying the color picker widget

  * ``CIRCLE_HSV``
Circle (HSV), A circular Hue/Saturation color wheel, with Value slider.

  * ``CIRCLE_HSL``
Circle (HSL), A circular Hue/Saturation color wheel, with Lightness slider.

  * ``SQUARE_SV``
Square (SV + H), A square showing Saturation/Value, with Hue slider.

  * ``SQUARE_HS``
Square (HS + V), A square showing Hue/Saturation, with Value slider.

  * ``SQUARE_HV``
Square (HV + S), A square showing Hue/Value, with Saturation slider.

  """

  factor_display_type: str = ...

  """

  How factor values are displayed

  * ``FACTOR``
Factor, Display factors as values between 0 and 1.

  * ``PERCENTAGE``
Percentage, Display factors as percentages.

  """

  filebrowser_display_type: str = ...

  """

  Default location where the File Editor will be displayed in

  * ``SCREEN``
Full Screen, Open the temporary editor in a maximized screen.

  * ``WINDOW``
New Window, Open the temporary editor in a new window.

  """

  font_path_ui: str = ...

  """

  Path to interface font

  """

  font_path_ui_mono: str = ...

  """

  Path to interface mono-space Font

  """

  gizmo_size: int = ...

  """

  Diameter of the gizmo

  """

  header_align: str = ...

  """

  Default header position for new space-types

  * ``NONE``
Keep Existing, Keep existing header alignment.

  * ``TOP``
Top, Top aligned on load.

  * ``BOTTOM``
Bottom, Bottom align on load (except for property editors).

  """

  language: str = ...

  """

  Language used for translation

  * ``DEFAULT``
Automatic (Automatic), Automatically choose system's defined language if available, or fall-back to English.

  """

  lookdev_sphere_size: int = ...

  """

  Diameter of the HDRI preview spheres

  """

  mini_axis_brightness: int = ...

  """

  Brightness of the icon

  """

  mini_axis_size: int = ...

  """

  The axes icon's size

  """

  mini_axis_type: str = ...

  """

  Show a small rotating 3D axes in the top right corner of the 3D View

  """

  open_sublevel_delay: int = ...

  """

  Time delay in 1/10 seconds before automatically opening sub level menus

  """

  open_toplevel_delay: int = ...

  """

  Time delay in 1/10 seconds before automatically opening top level menus

  """

  pie_animation_timeout: int = ...

  """

  Time needed to fully animate the pie to unfolded state (in 1/100ths of sec)

  """

  pie_initial_timeout: int = ...

  """

  Pie menus will use the initial mouse position as center for this amount of time (in 1/100ths of sec)

  """

  pie_menu_confirm: int = ...

  """

  Distance threshold after which selection is made (zero to disable)

  """

  pie_menu_radius: int = ...

  """

  Pie menu size in pixels

  """

  pie_menu_threshold: int = ...

  """

  Distance from center needed before a selection can be made

  """

  pie_tap_timeout: int = ...

  """

  Pie menu button held longer than this will dismiss menu on release.(in 1/100ths of sec)

  """

  render_display_type: str = ...

  """

  Default location where rendered images will be displayed in

  * ``NONE``
Keep User Interface, Images are rendered without changing the user interface.

  * ``SCREEN``
Full Screen, Images are rendered in a maximized Image Editor.

  * ``AREA``
Image Editor, Images are rendered in an Image Editor.

  * ``WINDOW``
New Window, Images are rendered in a new window.

  """

  rotation_angle: float = ...

  """

  Rotation step for numerical pad keys (2 4 6 8)

  """

  show_addons_enabled_only: bool = ...

  """

  Only show enabled add-ons. Un-check to see all installed add-ons

  """

  show_column_layout: bool = ...

  """

  Use a column layout for toolbox

  """

  show_developer_ui: bool = ...

  """

  Show options for developers (edit source in context menu, geometry indices)

  """

  show_gizmo: bool = ...

  """

  Use transform gizmos by default

  """

  show_layout_ui: bool = ...

  """

  Split and join editors by dragging from corners

  """

  show_navigate_ui: bool = ...

  """

  Show navigation controls in 2D & 3D views which do not have scroll bars

  """

  show_object_info: bool = ...

  """

  Display objects name and frame number in 3D view

  """

  show_playback_fps: bool = ...

  """

  Show the frames per second screen refresh rate, while animation is played back

  """

  show_splash: bool = ...

  """

  Display splash screen on startup

  """

  show_statusbar_memory: bool = ...

  """

  Show Blender memory usage

  """

  show_statusbar_stats: bool = ...

  """

  Show scene statistics

  """

  show_statusbar_version: bool = ...

  """

  Show Blender version string

  """

  show_statusbar_vram: bool = ...

  """

  Show GPU video memory usage

  """

  show_tooltips: bool = ...

  """

  Display tooltips (when off hold Alt to force display)

  """

  show_tooltips_python: bool = ...

  """

  Show Python references in tooltips

  """

  show_view_name: bool = ...

  """

  Show the name of the view's direction in each 3D View

  """

  smooth_view: int = ...

  """

  Time to animate the view in milliseconds, zero to disable

  """

  text_hinting: str = ...

  """

  Method for making user interface text render sharp

  """

  timecode_style: str = ...

  """

  Format of Time Codes displayed when not displaying timing in terms of frames

  * ``MINIMAL``
Minimal Info, Most compact representation, uses '+' as separator for sub-second frame numbers, with left and right truncation of the timecode as necessary.

  * ``SMPTE``
SMPTE (Full), Full SMPTE timecode (format is HH:MM:SS:FF).

  * ``SMPTE_COMPACT``
SMPTE (Compact), SMPTE timecode showing minutes, seconds, and frames only - hours are also shown if necessary, but not by default.

  * ``MILLISECONDS``
Compact with Milliseconds, Similar to SMPTE (Compact), except that instead of frames, milliseconds are shown instead.

  * ``SECONDS_ONLY``
Only Seconds, Direct conversion of frame numbers to seconds.

  """

  ui_line_width: str = ...

  """

  Changes the thickness of widget outlines, lines and points in the interface, for high DPI displays

  * ``THIN``
Thin, Thinner lines than the default.

  * ``AUTO``
Auto, Automatic line width based on UI scale.

  * ``THICK``
Thick, Thicker lines than the default.

  """

  ui_scale: float = ...

  """

  Changes the size of the fonts and widgets in the interface

  """

  use_directional_menus: bool = ...

  """

  Otherwise menus, etc will always be top to bottom, left to right, no matter opening direction

  """

  use_mouse_over_open: bool = ...

  """

  Open menu buttons and pulldowns automatically when the mouse is hovering

  """

  use_save_prompt: bool = ...

  """

  Ask for confirmation when quitting with unsaved changes

  """

  use_text_antialiasing: bool = ...

  """

  Draw user interface text anti-aliased

  """

  use_translate_interface: bool = ...

  """

  Translate all labels in menus, buttons and panels (note that this might make it hard to follow tutorials or the manual)

  """

  use_translate_new_dataname: bool = ...

  """

  Translate the names of new data-blocks (objects, materials...)

  """

  use_translate_tooltips: bool = ...

  """

  Translate the descriptions when hovering UI elements (recommended)

  """

  use_weight_color_range: bool = ...

  """

  Enable color range used for weight visualization in weight painting mode

  """

  view2d_grid_spacing_min: int = ...

  """

  Minimum number of pixels between each gridline in 2D Viewports

  """

  view_frame_keyframes: int = ...

  """

  Keyframes around cursor that we zoom around

  """

  view_frame_seconds: float = ...

  """

  Seconds around cursor that we zoom around

  """

  view_frame_type: str = ...

  """

  How zooming to frame focuses around current frame

  """

  weight_color_range: ColorRamp = ...

  """

  Color range used for weight visualization in weight painting mode

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Property(bpy_struct):

  """

  RNA property definition

  """

  description: str = ...

  """

  Description of the property for tooltips

  """

  icon: str = ...

  """

  Icon of the item

  """

  identifier: str = ...

  """

  Unique name used in the code and scripting

  """

  is_animatable: bool = ...

  """

  Property is animatable through RNA

  """

  is_argument_optional: bool = ...

  """

  True when the property is optional in a Python function implementing an RNA function

  """

  is_enum_flag: bool = ...

  """

  True when multiple enums

  """

  is_hidden: bool = ...

  """

  True when the property is hidden

  """

  is_library_editable: bool = ...

  """

  Property is editable from linked instances (changes not saved)

  """

  is_never_none: bool = ...

  """

  True when this value can't be set to None

  """

  is_output: bool = ...

  """

  True when this property is an output value from an RNA function

  """

  is_overridable: bool = ...

  """

  Property is overridable through RNA

  """

  is_readonly: bool = ...

  """

  Property is editable through RNA

  """

  is_registered: bool = ...

  """

  Property is registered as part of type registration

  """

  is_registered_optional: bool = ...

  """

  Property is optionally registered as part of type registration

  """

  is_required: bool = ...

  """

  False when this property is an optional argument in an RNA function

  """

  is_runtime: bool = ...

  """

  Property has been dynamically created at runtime

  """

  is_skip_save: bool = ...

  """

  True when the property is not saved in presets

  """

  name: str = ...

  """

  Human readable name

  """

  srna: Struct = ...

  """

  Struct definition used for properties assigned to this item

  """

  subtype: str = ...

  """

  Semantic interpretation of the property

  * ``NONE``
None.

  * ``FILEPATH``
File Path.

  * ``DIRPATH``
Directory Path.

  * ``FILENAME``
File Name.

  * ``BYTESTRING``
Byte String.

  * ``PASSWORD``
Password, A string that is displayed hidden ('********').

  * ``PIXEL``
Pixel.

  * ``UNSIGNED``
Unsigned.

  * ``PERCENTAGE``
Percentage.

  * ``FACTOR``
Factor.

  * ``ANGLE``
Angle.

  * ``TIME``
Time.

  * ``DISTANCE``
Distance.

  * ``DISTANCE_CAMERA``
Camera Distance.

  * ``POWER``
Power.

  * ``TEMPERATURE``
Temperature.

  * ``COLOR``
Color.

  * ``TRANSLATION``
Translation.

  * ``DIRECTION``
Direction.

  * ``VELOCITY``
Velocity.

  * ``ACCELERATION``
Acceleration.

  * ``MATRIX``
Matrix.

  * ``EULER``
Euler Angles.

  * ``QUATERNION``
Quaternion.

  * ``AXISANGLE``
Axis-Angle.

  * ``XYZ``
XYZ.

  * ``XYZ_LENGTH``
XYZ Length.

  * ``COLOR_GAMMA``
Color.

  * ``COORDS``
Coordinates.

  * ``LAYER``
Layer.

  * ``LAYER_MEMBER``
Layer Member.

  """

  tags: typing.Set[str] = ...

  """

  Subset of tags (defined in parent struct) that are set for this property

  """

  translation_context: str = ...

  """

  Translation context of the property's name

  """

  type: str = ...

  """

  Data type of the property

  """

  unit: str = ...

  """

  Type of units for this property

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PropertyGroup(bpy_struct):

  """

  Group of ID properties

  """

  name: str = ...

  """

  Unique name used in the code and scripting

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PropertyGroupItem(bpy_struct):

  """

  Property that stores arbitrary, user defined properties

  """

  collection: typing.Union[typing.Sequence[PropertyGroup], typing.Mapping[str, PropertyGroup], bpy_prop_collection] = ...

  double: float = ...

  double_array: typing.Tuple[float] = ...

  float: float = ...

  float_array: typing.Tuple[float] = ...

  group: PropertyGroup = ...

  id: ID = ...

  idp_array: typing.Union[typing.Sequence[PropertyGroup], typing.Mapping[str, PropertyGroup], bpy_prop_collection] = ...

  int: int = ...

  int_array: typing.Tuple[int] = ...

  string: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Region(bpy_struct):

  """

  Region in a subdivided screen area

  """

  alignment: str = ...

  """

  Alignment of the region within the area

  * ``NONE``
None, Don't use any fixed alignment, fill available space.

  * ``TOP``
Top.

  * ``BOTTOM``
Bottom.

  * ``LEFT``
Left.

  * ``RIGHT``
Right.

  * ``HORIZONTAL_SPLIT``
Horizontal Split.

  * ``VERTICAL_SPLIT``
Vertical Split.

  * ``FLOAT``
Float, Region floats on screen, doesn't use any fixed alignment.

  * ``QUAD_SPLIT``
Quad Split, Region is split horizontally and vertically.

  """

  height: int = ...

  """

  Region height

  """

  type: str = ...

  """

  Type of this region

  """

  view2d: View2D = ...

  """

  2D view of the region

  """

  width: int = ...

  """

  Region width

  """

  x: int = ...

  """

  The window relative vertical location of the region

  """

  y: int = ...

  """

  The window relative horizontal location of the region

  """

  def tag_redraw(self) -> None:

    """

    tag_redraw

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RegionView3D(bpy_struct):

  """

  3D View region data

  """

  clip_planes: typing.Tuple[typing.Tuple[float, float, float, float], ...] = ...

  is_orthographic_side_view: bool = ...

  """

  Is current view an orthographic side view

  """

  is_perspective: bool = ...

  lock_rotation: bool = ...

  """

  Lock view rotation in side views

  """

  perspective_matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Current perspective matrix (``window_matrix * view_matrix``)

  """

  show_sync_view: bool = ...

  """

  Sync view position between side views

  """

  use_box_clip: bool = ...

  """

  Clip objects based on what's visible in other side views

  """

  use_clip_planes: bool = ...

  view_camera_offset: typing.Tuple[float, float] = ...

  """

  View shift in camera view

  """

  view_camera_zoom: float = ...

  """

  Zoom factor in camera view

  """

  view_distance: float = ...

  """

  Distance to the view location

  """

  view_location: typing.Tuple[float, float, float] = ...

  """

  View pivot location

  """

  view_matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Current view matrix

  """

  view_perspective: str = ...

  """

  View Perspective

  """

  view_rotation: typing.Tuple[float, float, float, float] = ...

  """

  Rotation in quaternions (keep normalized)

  """

  window_matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Current window matrix

  """

  def update(self) -> None:

    """

    Recalculate the view matrices

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RenderEngine(bpy_struct):

  """

  Render engine

  """

  bl_idname: str = ...

  bl_label: str = ...

  bl_use_eevee_viewport: bool = ...

  """

  Uses Eevee for viewport shading in LookDev shading mode

  """

  bl_use_gpu_context: bool = ...

  """

  Enable OpenGL context for the render method, for engines that render using OpenGL

  """

  bl_use_postprocess: bool = ...

  """

  Apply compositing on render results

  """

  bl_use_preview: bool = ...

  """

  Render engine supports being used for rendering previews of materials, lights and worlds

  """

  bl_use_save_buffers: bool = ...

  """

  Support render to an on disk buffer during rendering

  """

  bl_use_shading_nodes_custom: bool = ...

  """

  Don't expose Cycles and Eevee shading nodes in the node editor user interface, so own nodes can be used instead

  """

  bl_use_spherical_stereo: bool = ...

  """

  Support spherical stereo camera models

  """

  bl_use_stereo_viewport: bool = ...

  """

  Support rendering stereo 3D viewport

  """

  camera_override: Object = ...

  is_animation: bool = ...

  is_preview: bool = ...

  layer_override: typing.Tuple[bool, ...] = ...

  render: RenderSettings = ...

  resolution_x: int = ...

  resolution_y: int = ...

  tile_x: int = ...

  tile_y: int = ...

  use_highlight_tiles: bool = ...

  def update(self, data: BlendData = None, depsgraph: Depsgraph = None) -> None:

    """

    Export scene data for render

    """

    ...

  def render(self, depsgraph: Depsgraph) -> None:

    """

    Render scene into an image

    """

    ...

  def bake(self, depsgraph: Depsgraph, object: Object, pass_type: str, pass_filter: int, width: int, height: int) -> None:

    """

    Bake passes

    """

    ...

  def view_update(self, context: Context, depsgraph: Depsgraph) -> None:

    """

    Update on data changes for viewport render

    """

    ...

  def view_draw(self, context: Context, depsgraph: Depsgraph) -> None:

    """

    Draw viewport render

    """

    ...

  def update_script_node(self, node: Node = None) -> None:

    """

    Compile shader script node

    """

    ...

  def update_render_passes(self, scene: Scene = None, renderlayer: ViewLayer = None) -> None:

    """

    Update the render passes that will be generated

    """

    ...

  def tag_redraw(self) -> None:

    """

    Request redraw for viewport rendering

    """

    ...

  def tag_update(self) -> None:

    """

    Request update call for viewport rendering

    """

    ...

  def begin_result(self, x: int, y: int, w: int, h: int, layer: str = '', view: str = '') -> RenderResult:

    """

    Create render result to write linear floating point render layers and passes

    """

    ...

  def update_result(self, result: RenderResult) -> None:

    """

    Signal that pixels have been updated and can be redrawn in the user interface

    """

    ...

  def end_result(self, result: RenderResult, cancel: bool = False, highlight: bool = False, do_merge_results: bool = False) -> None:

    """

    All pixels in the render result have been set and are final

    """

    ...

  def add_pass(self, name: str, channels: int, chan_id: str, layer: str = '') -> None:

    """

    Add a pass to the render layer

    """

    ...

  def get_result(self) -> RenderResult:

    """

    Get final result for non-pixel operations

    """

    ...

  def test_break(self) -> bool:

    """

    Test if the render operation should been canceled, this is a fast call that should be used regularly for responsiveness

    """

    ...

  def active_view_get(self) -> str:

    """

    active_view_get

    """

    ...

  def active_view_set(self, view: str) -> None:

    """

    active_view_set

    """

    ...

  def camera_shift_x(self, camera: Object, use_spherical_stereo: bool = False) -> float:

    """

    camera_shift_x

    """

    ...

  def camera_model_matrix(self, camera: Object, use_spherical_stereo: bool = False) -> typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]]:

    """

    camera_model_matrix

    """

    ...

  def use_spherical_stereo(self, camera: Object) -> bool:

    """

    use_spherical_stereo

    """

    ...

  def update_stats(self, stats: str, info: str) -> None:

    """

    Update and signal to redraw render status text

    """

    ...

  def frame_set(self, frame: int, subframe: float) -> None:

    """

    Evaluate scene at a different frame (for motion blur)

    """

    ...

  def update_progress(self, progress: float) -> None:

    """

    Update progress percentage of render

    """

    ...

  def update_memory_stats(self, memory_used: float = 0.0, memory_peak: float = 0.0) -> None:

    """

    Update memory usage statistics

    """

    ...

  def report(self, type: typing.Set[str], message: str) -> None:

    """

    Report info, warning or error messages

    """

    ...

  def error_set(self, message: str) -> None:

    """

    Set error message displaying after the render is finished

    """

    ...

  def bind_display_space_shader(self, scene: Scene) -> None:

    """

    Bind GLSL fragment shader that converts linear colors to display space colors using scene color management settings

    """

    ...

  def unbind_display_space_shader(self) -> None:

    """

    Unbind GLSL display space shader, must always be called after binding the shader

    """

    ...

  def support_display_space_shader(self, scene: Scene) -> bool:

    """

    Test if GLSL display space shader is supported for the combination of graphics card and scene settings

    """

    ...

  def get_preview_pixel_size(self, scene: Scene) -> int:

    """

    Free Blender side memory of render engine

    """

    ...

  def free_blender_memory(self) -> None:

    """

    free_blender_memory

    """

    ...

  def register_pass(self, scene: Scene, view_layer: ViewLayer, name: str, channels: int, chanid: str, type: str) -> None:

    """

    Register a render pass that will be part of the render with the current settings

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RenderLayer(bpy_struct):

  invert_zmask: bool = ...

  """

  For Zmask, only render what is behind solid z values instead of in front

  """

  name: str = ...

  """

  View layer name

  """

  passes: typing.Union[RenderPasses, typing.Sequence[RenderPass], typing.Mapping[str, RenderPass], bpy_prop_collection] = ...

  use_all_z: bool = ...

  """

  Fill in Z values for solid faces in invisible layers, for masking

  """

  use_ao: bool = ...

  """

  Render Ambient Occlusion in this Layer

  """

  use_edge_enhance: bool = ...

  """

  Render Edge-enhance in this Layer (only works for Solid faces)

  """

  use_halo: bool = ...

  """

  Render Halos in this Layer (on top of Solid)

  """

  use_pass_ambient_occlusion: bool = ...

  """

  Deliver Ambient Occlusion pass

  """

  use_pass_combined: bool = ...

  """

  Deliver full combined RGBA buffer

  """

  use_pass_diffuse_color: bool = ...

  """

  Deliver diffuse color pass

  """

  use_pass_diffuse_direct: bool = ...

  """

  Deliver diffuse direct pass

  """

  use_pass_diffuse_indirect: bool = ...

  """

  Deliver diffuse indirect pass

  """

  use_pass_emit: bool = ...

  """

  Deliver emission pass

  """

  use_pass_environment: bool = ...

  """

  Deliver environment lighting pass

  """

  use_pass_glossy_color: bool = ...

  """

  Deliver glossy color pass

  """

  use_pass_glossy_direct: bool = ...

  """

  Deliver glossy direct pass

  """

  use_pass_glossy_indirect: bool = ...

  """

  Deliver glossy indirect pass

  """

  use_pass_material_index: bool = ...

  """

  Deliver material index pass

  """

  use_pass_mist: bool = ...

  """

  Deliver mist factor pass (0.0-1.0)

  """

  use_pass_normal: bool = ...

  """

  Deliver normal pass

  """

  use_pass_object_index: bool = ...

  """

  Deliver object index pass

  """

  use_pass_shadow: bool = ...

  """

  Deliver shadow pass

  """

  use_pass_subsurface_color: bool = ...

  """

  Deliver subsurface color pass

  """

  use_pass_subsurface_direct: bool = ...

  """

  Deliver subsurface direct pass

  """

  use_pass_subsurface_indirect: bool = ...

  """

  Deliver subsurface indirect pass

  """

  use_pass_transmission_color: bool = ...

  """

  Deliver transmission color pass

  """

  use_pass_transmission_direct: bool = ...

  """

  Deliver transmission direct pass

  """

  use_pass_transmission_indirect: bool = ...

  """

  Deliver transmission indirect pass

  """

  use_pass_uv: bool = ...

  """

  Deliver texture UV pass

  """

  use_pass_vector: bool = ...

  """

  Deliver speed vector pass

  """

  use_pass_z: bool = ...

  """

  Deliver Z values pass

  """

  use_sky: bool = ...

  """

  Render Sky in this Layer

  """

  use_solid: bool = ...

  """

  Render Solid faces in this Layer

  """

  use_strand: bool = ...

  """

  Render Strands in this Layer

  """

  use_volumes: bool = ...

  """

  Render volumes in this Layer

  """

  use_zmask: bool = ...

  """

  Only render what's in front of the solid z values

  """

  use_ztransp: bool = ...

  """

  Render Z-Transparent faces in this Layer (on top of Solid and Halos)

  """

  def load_from_file(self, filename: str, x: int = 0, y: int = 0) -> None:

    """

    Copies the pixels of this renderlayer from an image file

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RenderPass(bpy_struct):

  channel_id: str = ...

  channels: int = ...

  fullname: str = ...

  name: str = ...

  rect: float = ...

  view_id: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RenderPasses(bpy_struct):

  """

  Collection of render passes

  """

  def find_by_type(self, pass_type: str, view: str) -> RenderPass:

    """

    Get the render pass for a given type and view

    """

    ...

  def find_by_name(self, name: str, view: str) -> RenderPass:

    """

    Get the render pass for a given name and view

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RenderResult(bpy_struct):

  """

  Result of rendering, including all layers and passes

  """

  layers: typing.Union[typing.Sequence[RenderLayer], typing.Mapping[str, RenderLayer], bpy_prop_collection] = ...

  resolution_x: int = ...

  resolution_y: int = ...

  views: typing.Union[typing.Sequence[RenderView], typing.Mapping[str, RenderView], bpy_prop_collection] = ...

  def load_from_file(self, filename: str) -> None:

    """

    Copies the pixels of this render result from an image file

    """

    ...

  def stamp_data_add_field(self, field: str, value: str) -> None:

    """

    Add engine-specific stamp data to the result

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RenderSettings(bpy_struct):

  """

  Rendering settings for a Scene data-block

  """

  bake: BakeSettings = ...

  bake_bias: float = ...

  """

  Bias towards faces further away from the object (in blender units)

  """

  bake_margin: int = ...

  """

  Extends the baked result as a post process filter

  """

  bake_samples: int = ...

  """

  Number of samples used for ambient occlusion baking from multires

  """

  bake_type: str = ...

  """

  Choose shading information to bake into the image

  * ``NORMALS``
Normals, Bake normals.

  * ``DISPLACEMENT``
Displacement, Bake displacement.

  """

  bake_user_scale: float = ...

  """

  Instead of automatically normalizing to 0..1, apply a user scale to the derivative map

  """

  border_max_x: float = ...

  """

  Maximum X value for the render region

  """

  border_max_y: float = ...

  """

  Maximum Y value for the render region

  """

  border_min_x: float = ...

  """

  Minimum X value for the render region

  """

  border_min_y: float = ...

  """

  Minimum Y value for the render region

  """

  dither_intensity: float = ...

  """

  Amount of dithering noise added to the rendered image to break up banding

  """

  engine: str = ...

  """

  Engine to use for rendering

  """

  ffmpeg: FFmpegSettings = ...

  """

  FFmpeg related settings for the scene

  """

  file_extension: str = ...

  """

  The file extension used for saving renders

  """

  filepath: str = ...

  """

  Directory/name to save animations, # characters defines the position and length of frame numbers

  """

  film_transparent: bool = ...

  """

  World background is transparent, for compositing the render over another background

  """

  filter_size: float = ...

  """

  Width over which the reconstruction filter combines samples

  """

  fps: int = ...

  """

  Framerate, expressed in frames per second

  """

  fps_base: float = ...

  """

  Framerate base

  """

  frame_map_new: int = ...

  """

  How many frames the Map Old will last

  """

  frame_map_old: int = ...

  """

  Old mapping value in frames

  """

  hair_subdiv: int = ...

  """

  Additional subdivision along the hair

  """

  hair_type: str = ...

  """

  Hair shape type

  """

  has_multiple_engines: bool = ...

  """

  More than one rendering engine is available

  """

  image_settings: ImageFormatSettings = ...

  is_movie_format: bool = ...

  """

  When true the format is a movie

  """

  line_thickness: float = ...

  """

  Line thickness in pixels

  """

  line_thickness_mode: str = ...

  """

  Line thickness mode for Freestyle line drawing

  * ``ABSOLUTE``
Absolute, Specify unit line thickness in pixels.

  * ``RELATIVE``
Relative, Unit line thickness is scaled by the proportion of the present vertical image resolution to 480 pixels.

  """

  metadata_input: str = ...

  """

  Where to take the metadata from

  * ``SCENE``
Scene, Use metadata from the current scene.

  * ``STRIPS``
Sequencer Strips, Use metadata from the strips in the sequencer.

  """

  motion_blur_shutter: float = ...

  """

  Time taken in frames between shutter open and close

  """

  motion_blur_shutter_curve: CurveMapping = ...

  """

  Curve defining the shutter's openness over time

  """

  pixel_aspect_x: float = ...

  """

  Horizontal aspect ratio - for anamorphic or non-square pixel output

  """

  pixel_aspect_y: float = ...

  """

  Vertical aspect ratio - for anamorphic or non-square pixel output

  """

  preview_pixel_size: str = ...

  """

  Pixel size for viewport rendering

  * ``AUTO``
Automatic, Automatic pixel size, depends on the user interface scale.

  * ``1``
1x, Render at full resolution.

  * ``2``
2x, Render at 50% resolution.

  * ``4``
4x, Render at 25% resolution.

  * ``8``
8x, Render at 12.5% resolution.

  """

  preview_start_resolution: int = ...

  """

  Resolution to start rendering preview at, progressively increasing it to the full viewport size

  """

  resolution_percentage: int = ...

  """

  Percentage scale for render resolution

  """

  resolution_x: int = ...

  """

  Number of horizontal pixels in the rendered image

  """

  resolution_y: int = ...

  """

  Number of vertical pixels in the rendered image

  """

  sequencer_gl_preview: str = ...

  """

  Method to draw in the sequencer view

  * ``WIREFRAME``
Wireframe, Display the object as wire edges.

  * ``SOLID``
Solid, Display in solid mode.

  * ``MATERIAL``
Material Preview, Display in Material Preview mode.

  * ``RENDERED``
Rendered, Display render preview.

  """

  simplify_child_particles: float = ...

  """

  Global child particles percentage

  """

  simplify_child_particles_render: float = ...

  """

  Global child particles percentage during rendering

  """

  simplify_gpencil: bool = ...

  """

  Simplify Grease Pencil drawing

  """

  simplify_gpencil_antialiasing: bool = ...

  """

  Use Antialiasing to smooth stroke edges

  """

  simplify_gpencil_modifier: bool = ...

  """

  Display modifiers

  """

  simplify_gpencil_onplay: bool = ...

  """

  Simplify Grease Pencil only during animation playback

  """

  simplify_gpencil_shader_fx: bool = ...

  """

  Display Shader Effects

  """

  simplify_gpencil_tint: bool = ...

  """

  Display layer tint

  """

  simplify_gpencil_view_fill: bool = ...

  """

  Display fill strokes in the viewport

  """

  simplify_subdivision: int = ...

  """

  Global maximum subdivision level

  """

  simplify_subdivision_render: int = ...

  """

  Global maximum subdivision level during rendering

  """

  simplify_volumes: float = ...

  """

  Resolution percentage of volume objects in viewport

  """

  stamp_background: typing.Tuple[float, float, float, float] = ...

  """

  Color to use behind stamp text

  """

  stamp_font_size: int = ...

  """

  Size of the font used when rendering stamp text

  """

  stamp_foreground: typing.Tuple[float, float, float, float] = ...

  """

  Color to use for stamp text

  """

  stamp_note_text: str = ...

  """

  Custom text to appear in the stamp note

  """

  stereo_views: typing.Union[typing.Sequence[SceneRenderView], typing.Mapping[str, SceneRenderView], bpy_prop_collection] = ...

  threads: int = ...

  """

  Maximum number of CPU cores to use simultaneously while rendering (for multi-core/CPU systems)

  """

  threads_mode: str = ...

  """

  Determine the amount of render threads used

  * ``AUTO``
Auto-detect, Automatically determine the number of threads, based on CPUs.

  * ``FIXED``
Fixed, Manually determine the number of threads.

  """

  tile_x: int = ...

  """

  Horizontal tile size to use while rendering

  """

  tile_y: int = ...

  """

  Vertical tile size to use while rendering

  """

  use_bake_clear: bool = ...

  """

  Clear Images before baking

  """

  use_bake_lores_mesh: bool = ...

  """

  Calculate heights against unsubdivided low resolution mesh

  """

  use_bake_multires: bool = ...

  """

  Bake directly from multires object

  """

  use_bake_selected_to_active: bool = ...

  """

  Bake shading on the surface of selected objects to the active object

  """

  use_bake_user_scale: bool = ...

  """

  Use a user scale for the derivative map

  """

  use_border: bool = ...

  """

  Render a user-defined render region, within the frame size

  """

  use_compositing: bool = ...

  """

  Process the render result through the compositing pipeline, if compositing nodes are enabled

  """

  use_crop_to_border: bool = ...

  """

  Crop the rendered frame to the defined render region size

  """

  use_file_extension: bool = ...

  """

  Add the file format extensions to the rendered file name (eg: filename + .jpg)

  """

  use_freestyle: bool = ...

  """

  Draw stylized strokes using Freestyle

  """

  use_full_sample: bool = ...

  """

  Save for every anti-aliasing sample the entire RenderLayer results (this solves anti-aliasing issues with compositing)

  """

  use_high_quality_normals: bool = ...

  """

  Use high quality tangent space at the cost of lower performance

  """

  use_lock_interface: bool = ...

  """

  Lock interface during rendering in favor of giving more memory to the renderer

  """

  use_motion_blur: bool = ...

  """

  Use multi-sampled 3D scene motion blur

  """

  use_multiview: bool = ...

  """

  Use multiple views in the scene

  """

  use_overwrite: bool = ...

  """

  Overwrite existing files while rendering

  """

  use_persistent_data: bool = ...

  """

  Keep render data around for faster re-renders

  """

  use_placeholder: bool = ...

  """

  Create empty placeholder files while rendering frames (similar to Unix 'touch')

  """

  use_render_cache: bool = ...

  """

  Save render cache to EXR files (useful for heavy compositing, Note: affects indirectly rendered scenes)

  """

  use_save_buffers: bool = ...

  """

  Save tiles for all RenderLayers and SceneNodes to files in the temp directory (saves memory, required for Full Sample)

  """

  use_sequencer: bool = ...

  """

  Process the render (and composited) result through the video sequence editor pipeline, if sequencer strips exist

  """

  use_sequencer_override_scene_strip: bool = ...

  """

  Use workbench render settings from the sequencer scene, instead of each individual scene used in the strip

  """

  use_simplify: bool = ...

  """

  Enable simplification of scene for quicker preview renders

  """

  use_single_layer: bool = ...

  """

  Only render the active layer. Only affects rendering from the interface, ignored for rendering from command line

  """

  use_spherical_stereo: bool = ...

  """

  Active render engine supports spherical stereo rendering

  """

  use_stamp: bool = ...

  """

  Render the stamp info text in the rendered image

  """

  use_stamp_camera: bool = ...

  """

  Include the name of the active camera in image metadata

  """

  use_stamp_date: bool = ...

  """

  Include the current date in image/video metadata

  """

  use_stamp_filename: bool = ...

  """

  Include the .blend filename in image/video metadata

  """

  use_stamp_frame: bool = ...

  """

  Include the frame number in image metadata

  """

  use_stamp_frame_range: bool = ...

  """

  Include the rendered frame range in image/video metadata

  """

  use_stamp_hostname: bool = ...

  """

  Include the hostname of the machine that rendered the frame

  """

  use_stamp_labels: bool = ...

  """

  Display stamp labels ("Camera" in front of camera name, etc.)

  """

  use_stamp_lens: bool = ...

  """

  Include the active camera's lens in image metadata

  """

  use_stamp_marker: bool = ...

  """

  Include the name of the last marker in image metadata

  """

  use_stamp_memory: bool = ...

  """

  Include the peak memory usage in image metadata

  """

  use_stamp_note: bool = ...

  """

  Include a custom note in image/video metadata

  """

  use_stamp_render_time: bool = ...

  """

  Include the render time in image metadata

  """

  use_stamp_scene: bool = ...

  """

  Include the name of the active scene in image/video metadata

  """

  use_stamp_sequencer_strip: bool = ...

  """

  Include the name of the foreground sequence strip in image metadata

  """

  use_stamp_time: bool = ...

  """

  Include the rendered frame timecode as HH:MM:SS.FF in image metadata

  """

  views: typing.Union[RenderViews, typing.Sequence[SceneRenderView], typing.Mapping[str, SceneRenderView], bpy_prop_collection] = ...

  views_format: str = ...

  """

  * ``STEREO_3D``
Stereo 3D, Single stereo camera system, adjust the stereo settings in the camera panel.

  * ``MULTIVIEW``
Multi-View, Multi camera system, adjust the cameras individually.

  """

  def frame_path(self, frame: int = -2147483648, preview: bool = False, view: str = '') -> str:

    """

    Return the absolute path to the filename to be written for a given frame

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RenderSlot(bpy_struct):

  """

  Parameters defining the render slot

  """

  name: str = ...

  """

  Render slot name

  """

  def clear(self, iuser: ImageUser) -> None:

    """

    Clear the render slot

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RenderSlots(bpy_struct):

  """

  Collection of render layers

  """

  active: RenderSlot = ...

  """

  Active render slot of the image

  """

  active_index: int = ...

  """

  Active render slot of the image

  """

  def new(self, name: str = '') -> RenderSlot:

    """

    Add a render slot to the image

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RenderView(bpy_struct):

  name: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RenderViews(bpy_struct):

  """

  Collection of render views

  """

  active: SceneRenderView = ...

  """

  Active Render View

  """

  active_index: int = ...

  """

  Active index in render view array

  """

  def new(self, name: str) -> SceneRenderView:

    """

    Add a render view to scene

    """

    ...

  def remove(self, view: SceneRenderView) -> None:

    """

    Remove a render view

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RigidBodyConstraint(bpy_struct):

  """

  Constraint influencing Objects inside Rigid Body Simulation

  """

  breaking_threshold: float = ...

  """

  Impulse threshold that must be reached for the constraint to break

  """

  disable_collisions: bool = ...

  """

  Disable collisions between constrained rigid bodies

  """

  enabled: bool = ...

  """

  Enable this constraint

  """

  limit_ang_x_lower: float = ...

  """

  Lower limit of X axis rotation

  """

  limit_ang_x_upper: float = ...

  """

  Upper limit of X axis rotation

  """

  limit_ang_y_lower: float = ...

  """

  Lower limit of Y axis rotation

  """

  limit_ang_y_upper: float = ...

  """

  Upper limit of Y axis rotation

  """

  limit_ang_z_lower: float = ...

  """

  Lower limit of Z axis rotation

  """

  limit_ang_z_upper: float = ...

  """

  Upper limit of Z axis rotation

  """

  limit_lin_x_lower: float = ...

  """

  Lower limit of X axis translation

  """

  limit_lin_x_upper: float = ...

  """

  Upper limit of X axis translation

  """

  limit_lin_y_lower: float = ...

  """

  Lower limit of Y axis translation

  """

  limit_lin_y_upper: float = ...

  """

  Upper limit of Y axis translation

  """

  limit_lin_z_lower: float = ...

  """

  Lower limit of Z axis translation

  """

  limit_lin_z_upper: float = ...

  """

  Upper limit of Z axis translation

  """

  motor_ang_max_impulse: float = ...

  """

  Maximum angular motor impulse

  """

  motor_ang_target_velocity: float = ...

  """

  Target angular motor velocity

  """

  motor_lin_max_impulse: float = ...

  """

  Maximum linear motor impulse

  """

  motor_lin_target_velocity: float = ...

  """

  Target linear motor velocity

  """

  object1: Object = ...

  """

  First Rigid Body Object to be constrained

  """

  object2: Object = ...

  """

  Second Rigid Body Object to be constrained

  """

  solver_iterations: int = ...

  """

  Number of constraint solver iterations made per simulation step (higher values are more accurate but slower)

  """

  spring_damping_ang_x: float = ...

  """

  Damping on the X rotational axis

  """

  spring_damping_ang_y: float = ...

  """

  Damping on the Y rotational axis

  """

  spring_damping_ang_z: float = ...

  """

  Damping on the Z rotational axis

  """

  spring_damping_x: float = ...

  """

  Damping on the X axis

  """

  spring_damping_y: float = ...

  """

  Damping on the Y axis

  """

  spring_damping_z: float = ...

  """

  Damping on the Z axis

  """

  spring_stiffness_ang_x: float = ...

  """

  Stiffness on the X rotational axis

  """

  spring_stiffness_ang_y: float = ...

  """

  Stiffness on the Y rotational axis

  """

  spring_stiffness_ang_z: float = ...

  """

  Stiffness on the Z rotational axis

  """

  spring_stiffness_x: float = ...

  """

  Stiffness on the X axis

  """

  spring_stiffness_y: float = ...

  """

  Stiffness on the Y axis

  """

  spring_stiffness_z: float = ...

  """

  Stiffness on the Z axis

  """

  spring_type: str = ...

  """

  Which implementation of spring to use

  * ``SPRING1``
Blender 2.7, Spring implementation used in blender 2.7. Damping is capped at 1.0.

  * ``SPRING2``
Blender 2.8, New implementation available since 2.8.

  """

  type: str = ...

  """

  Type of Rigid Body Constraint

  * ``FIXED``
Fixed, Glue rigid bodies together.

  * ``POINT``
Point, Constrain rigid bodies to move around common pivot point.

  * ``HINGE``
Hinge, Restrict rigid body rotation to one axis.

  * ``SLIDER``
Slider, Restrict rigid body translation to one axis.

  * ``PISTON``
Piston, Restrict rigid body translation and rotation to one axis.

  * ``GENERIC``
Generic, Restrict translation and rotation to specified axes.

  * ``GENERIC_SPRING``
Generic Spring, Restrict translation and rotation to specified axes with springs.

  * ``MOTOR``
Motor, Drive rigid body around or along an axis.

  """

  use_breaking: bool = ...

  """

  Constraint can be broken if it receives an impulse above the threshold

  """

  use_limit_ang_x: bool = ...

  """

  Limit rotation around X axis

  """

  use_limit_ang_y: bool = ...

  """

  Limit rotation around Y axis

  """

  use_limit_ang_z: bool = ...

  """

  Limit rotation around Z axis

  """

  use_limit_lin_x: bool = ...

  """

  Limit translation on X axis

  """

  use_limit_lin_y: bool = ...

  """

  Limit translation on Y axis

  """

  use_limit_lin_z: bool = ...

  """

  Limit translation on Z axis

  """

  use_motor_ang: bool = ...

  """

  Enable angular motor

  """

  use_motor_lin: bool = ...

  """

  Enable linear motor

  """

  use_override_solver_iterations: bool = ...

  """

  Override the number of solver iterations for this constraint

  """

  use_spring_ang_x: bool = ...

  """

  Enable spring on X rotational axis

  """

  use_spring_ang_y: bool = ...

  """

  Enable spring on Y rotational axis

  """

  use_spring_ang_z: bool = ...

  """

  Enable spring on Z rotational axis

  """

  use_spring_x: bool = ...

  """

  Enable spring on X axis

  """

  use_spring_y: bool = ...

  """

  Enable spring on Y axis

  """

  use_spring_z: bool = ...

  """

  Enable spring on Z axis

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RigidBodyObject(bpy_struct):

  """

  Settings for object participating in Rigid Body Simulation

  """

  angular_damping: float = ...

  """

  Amount of angular velocity that is lost over time

  """

  collision_collections: typing.Tuple[bool, ...] = ...

  """

  Collision collections rigid body belongs to

  """

  collision_margin: float = ...

  """

  Threshold of distance near surface where collisions are still considered (best results when non-zero)

  """

  collision_shape: str = ...

  """

  Collision Shape of object in Rigid Body Simulations

  * ``BOX``
Box, Box-like shapes (i.e. cubes), including planes (i.e. ground planes).

  * ``SPHERE``
Sphere.

  * ``CAPSULE``
Capsule.

  * ``CYLINDER``
Cylinder.

  * ``CONE``
Cone.

  * ``CONVEX_HULL``
Convex Hull, A mesh-like surface encompassing (i.e. shrinkwrap over) all vertices (best results with fewer vertices).

  * ``MESH``
Mesh, Mesh consisting of triangles only, allowing for more detailed interactions than convex hulls.

  * ``COMPOUND``
Compound Parent, Combines all of its direct rigid body children into one rigid object.

  """

  deactivate_angular_velocity: float = ...

  """

  Angular Velocity below which simulation stops simulating object

  """

  deactivate_linear_velocity: float = ...

  """

  Linear Velocity below which simulation stops simulating object

  """

  enabled: bool = ...

  """

  Rigid Body actively participates to the simulation

  """

  friction: float = ...

  """

  Resistance of object to movement

  """

  kinematic: bool = ...

  """

  Allow rigid body to be controlled by the animation system

  """

  linear_damping: float = ...

  """

  Amount of linear velocity that is lost over time

  """

  mass: float = ...

  """

  How much the object 'weighs' irrespective of gravity

  """

  mesh_source: str = ...

  """

  Source of the mesh used to create collision shape

  * ``BASE``
Base, Base mesh.

  * ``DEFORM``
Deform, Deformations (shape keys, deform modifiers).

  * ``FINAL``
Final, All modifiers.

  """

  restitution: float = ...

  """

  Tendency of object to bounce after colliding with another (0 = stays still, 1 = perfectly elastic)

  """

  type: str = ...

  """

  Role of object in Rigid Body Simulations

  * ``ACTIVE``
Active, Object is directly controlled by simulation results.

  * ``PASSIVE``
Passive, Object is directly controlled by animation system.

  """

  use_deactivation: bool = ...

  """

  Enable deactivation of resting rigid bodies (increases performance and stability but can cause glitches)

  """

  use_deform: bool = ...

  """

  Rigid body deforms during simulation

  """

  use_margin: bool = ...

  """

  Use custom collision margin (some shapes will have a visible gap around them)

  """

  use_start_deactivated: bool = ...

  """

  Deactivate rigid body at the start of the simulation

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RigidBodyWorld(bpy_struct):

  """

  Self-contained rigid body simulation environment and settings

  """

  collection: Collection = ...

  """

  Collection containing objects participating in this simulation

  """

  constraints: Collection = ...

  """

  Collection containing rigid body constraint objects

  """

  effector_weights: EffectorWeights = ...

  enabled: bool = ...

  """

  Simulation will be evaluated

  """

  point_cache: PointCache = ...

  solver_iterations: int = ...

  """

  Number of constraint solver iterations made per simulation step (higher values are more accurate but slower)

  """

  substeps_per_frame: int = ...

  """

  Number of simulation steps taken per frame (higher values are more accurate but slower)

  """

  time_scale: float = ...

  """

  Change the speed of the simulation

  """

  use_split_impulse: bool = ...

  """

  Reduce extra velocity that can build up when objects collide (lowers simulation stability a little so use only when necessary)

  """

  def convex_sweep_test(self, object: Object, start: typing.Tuple[float, float, float], end: typing.Tuple[float, float, float]) -> None:

    """

    Sweep test convex rigidbody against the current rigidbody world

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SPHFluidSettings(bpy_struct):

  """

  Settings for particle fluids physics

  """

  buoyancy: float = ...

  """

  Artificial buoyancy force in negative gravity direction based on pressure differences inside the fluid

  """

  fluid_radius: float = ...

  """

  Fluid interaction radius

  """

  linear_viscosity: float = ...

  """

  Linear viscosity

  """

  plasticity: float = ...

  """

  How much the spring rest length can change after the elastic limit is crossed

  """

  repulsion: float = ...

  """

  How strongly the fluid tries to keep from clustering (factor of stiffness)

  """

  rest_density: float = ...

  """

  Fluid rest density

  """

  rest_length: float = ...

  """

  Spring rest length (factor of particle radius)

  """

  solver: str = ...

  """

  The code used to calculate internal forces on particles

  * ``DDR``
Double-Density, An artistic solver with strong surface tension effects (original).

  * ``CLASSICAL``
Classical, A more physically-accurate solver.

  """

  spring_force: float = ...

  """

  Spring force

  """

  spring_frames: int = ...

  """

  Create springs for this number of frames since particles birth (0 is always)

  """

  stiff_viscosity: float = ...

  """

  Creates viscosity for expanding fluid

  """

  stiffness: float = ...

  """

  How incompressible the fluid is (speed of sound)

  """

  use_factor_density: bool = ...

  """

  Density is calculated as a factor of default density (depends on particle size)

  """

  use_factor_radius: bool = ...

  """

  Interaction radius is a factor of 4 * particle size

  """

  use_factor_repulsion: bool = ...

  """

  Repulsion is a factor of stiffness

  """

  use_factor_rest_length: bool = ...

  """

  Spring rest length is a factor of 2 * particle size

  """

  use_factor_stiff_viscosity: bool = ...

  """

  Stiff viscosity is a factor of normal viscosity

  """

  use_initial_rest_length: bool = ...

  """

  Use the initial length as spring rest length instead of 2 * particle size

  """

  use_viscoelastic_springs: bool = ...

  """

  Use viscoelastic springs instead of Hooke's springs

  """

  yield_ratio: float = ...

  """

  How much the spring has to be stretched/compressed in order to change its rest length

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SceneDisplay(bpy_struct):

  """

  Scene display settings for 3d viewport

  """

  light_direction: typing.Tuple[float, float, float] = ...

  """

  Direction of the light for shadows and highlights

  """

  matcap_ssao_attenuation: float = ...

  """

  Attenuation constant

  """

  matcap_ssao_distance: float = ...

  """

  Distance of object that contribute to the Cavity/Edge effect

  """

  matcap_ssao_samples: int = ...

  """

  Number of samples

  """

  render_aa: str = ...

  """

  Method of anti-aliasing when rendering final image

  * ``OFF``
No Anti-Aliasing, Scene will be rendering without any anti-aliasing.

  * ``FXAA``
Single Pass Anti-Aliasing, Scene will be rendered using a single pass anti-aliasing method (FXAA).

  * ``5``
5 Samples, Scene will be rendered using 5 anti-aliasing samples.

  * ``8``
8 Samples, Scene will be rendered using 8 anti-aliasing samples.

  * ``11``
11 Samples, Scene will be rendered using 11 anti-aliasing samples.

  * ``16``
16 Samples, Scene will be rendered using 16 anti-aliasing samples.

  * ``32``
32 Samples, Scene will be rendered using 32 anti-aliasing samples.

  """

  shading: View3DShading = ...

  """

  Shading settings for OpenGL render engine

  """

  shadow_focus: float = ...

  """

  Shadow factor hardness

  """

  shadow_shift: float = ...

  """

  Shadow termination angle

  """

  viewport_aa: str = ...

  """

  Method of anti-aliasing when rendering 3d viewport

  * ``OFF``
No Anti-Aliasing, Scene will be rendering without any anti-aliasing.

  * ``FXAA``
Single Pass Anti-Aliasing, Scene will be rendered using a single pass anti-aliasing method (FXAA).

  * ``5``
5 Samples, Scene will be rendered using 5 anti-aliasing samples.

  * ``8``
8 Samples, Scene will be rendered using 8 anti-aliasing samples.

  * ``11``
11 Samples, Scene will be rendered using 11 anti-aliasing samples.

  * ``16``
16 Samples, Scene will be rendered using 16 anti-aliasing samples.

  * ``32``
32 Samples, Scene will be rendered using 32 anti-aliasing samples.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SceneEEVEE(bpy_struct):

  """

  Scene display settings for 3d viewport

  """

  bloom_clamp: float = ...

  """

  Maximum intensity a bloom pixel can have (0 to disabled)

  """

  bloom_color: typing.Tuple[float, float, float] = ...

  """

  Color applied to the bloom effect

  """

  bloom_intensity: float = ...

  """

  Blend factor

  """

  bloom_knee: float = ...

  """

  Makes transition between under/over-threshold gradual

  """

  bloom_radius: float = ...

  """

  Bloom spread distance

  """

  bloom_threshold: float = ...

  """

  Filters out pixels under this level of brightness

  """

  bokeh_max_size: float = ...

  """

  Max size of the bokeh shape for the depth of field (lower is faster)

  """

  bokeh_threshold: float = ...

  """

  Brightness threshold for using sprite base depth of field

  """

  gi_auto_bake: bool = ...

  """

  Auto bake indirect lighting when editing probes

  """

  gi_cache_info: str = ...

  """

  Info on current cache status

  """

  gi_cubemap_display_size: float = ...

  """

  Size of the cubemap spheres to debug captured light

  """

  gi_cubemap_resolution: str = ...

  """

  Size of every cubemaps

  """

  gi_diffuse_bounces: int = ...

  """

  Number of time the light is reinjected inside light grids, 0 disable indirect diffuse light

  """

  gi_filter_quality: float = ...

  """

  Take more samples during cubemap filtering to remove artifacts

  """

  gi_glossy_clamp: float = ...

  """

  Clamp pixel intensity to reduce noise inside glossy reflections from reflection cubemaps (0 to disabled)

  """

  gi_irradiance_display_size: float = ...

  """

  Size of the irradiance sample spheres to debug captured light

  """

  gi_irradiance_smoothing: float = ...

  """

  Smoother irradiance interpolation but introduce light bleeding

  """

  gi_show_cubemaps: bool = ...

  """

  Display captured cubemaps in the viewport

  """

  gi_show_irradiance: bool = ...

  """

  Display irradiance samples in the viewport

  """

  gi_visibility_resolution: str = ...

  """

  Size of the shadow map applied to each irradiance sample

  """

  gtao_distance: float = ...

  """

  Distance of object that contribute to the ambient occlusion effect

  """

  gtao_factor: float = ...

  """

  Factor for ambient occlusion blending

  """

  gtao_quality: float = ...

  """

  Precision of the horizon search

  """

  light_threshold: float = ...

  """

  Minimum light intensity for a light to contribute to the lighting

  """

  motion_blur_depth_scale: float = ...

  """

  Lower values will reduce background bleeding onto foreground elements

  """

  motion_blur_max: int = ...

  """

  Maximum blur distance a pixel can spread over

  """

  motion_blur_position: str = ...

  """

  Offset for the shutter's time interval, allows to change the motion blur trails

  * ``START``
Start on Frame, The shutter opens at the current frame.

  * ``CENTER``
Center on Frame, The shutter is open during the current frame.

  * ``END``
End on Frame, The shutter closes at the current frame.

  """

  motion_blur_shutter: float = ...

  """

  Time taken in frames between shutter open and close

  """

  motion_blur_steps: int = ...

  """

  Controls accuracy of motion blur, more steps means longer render time

  """

  overscan_size: float = ...

  """

  Percentage of render size to add as overscan to the internal render buffers

  """

  shadow_cascade_size: str = ...

  """

  Size of sun light shadow maps

  """

  shadow_cube_size: str = ...

  """

  Size of point and area light shadow maps

  """

  ssr_border_fade: float = ...

  """

  Screen percentage used to fade the SSR

  """

  ssr_firefly_fac: float = ...

  """

  Clamp pixel intensity to remove noise (0 to disabled)

  """

  ssr_max_roughness: float = ...

  """

  Do not raytrace reflections for roughness above this value

  """

  ssr_quality: float = ...

  """

  Precision of the screen space raytracing

  """

  ssr_thickness: float = ...

  """

  Pixel thickness used to detect intersection

  """

  sss_jitter_threshold: float = ...

  """

  Rotate samples that are below this threshold

  """

  sss_samples: int = ...

  """

  Number of samples to compute the scattering effect

  """

  taa_render_samples: int = ...

  """

  Number of samples per pixels for rendering

  """

  taa_samples: int = ...

  """

  Number of samples, unlimited if 0

  """

  use_bloom: bool = ...

  """

  High brightness pixels generate a glowing effect

  """

  use_gtao: bool = ...

  """

  Enable ambient occlusion to simulate medium scale indirect shadowing

  """

  use_gtao_bent_normals: bool = ...

  """

  Compute main non occluded direction to sample the environment

  """

  use_gtao_bounce: bool = ...

  """

  An approximation to simulate light bounces giving less occlusion on brighter objects

  """

  use_motion_blur: bool = ...

  """

  Enable motion blur effect (only in camera view)

  """

  use_overscan: bool = ...

  """

  Internally render past the image border to avoid screen-space effects disappearing

  """

  use_shadow_high_bitdepth: bool = ...

  """

  Use 32bit shadows

  """

  use_soft_shadows: bool = ...

  """

  Randomize shadowmaps origin to create soft shadows

  """

  use_ssr: bool = ...

  """

  Enable screen space reflection

  """

  use_ssr_halfres: bool = ...

  """

  Raytrace at a lower resolution

  """

  use_ssr_refraction: bool = ...

  """

  Enable screen space Refractions

  """

  use_taa_reprojection: bool = ...

  """

  Denoise image using temporal reprojection (can leave some ghosting)

  """

  use_volumetric_lights: bool = ...

  """

  Enable scene light interactions with volumetrics

  """

  use_volumetric_shadows: bool = ...

  """

  Generate shadows from volumetric material (Very expensive)

  """

  volumetric_end: float = ...

  """

  End distance of the volumetric effect

  """

  volumetric_light_clamp: float = ...

  """

  Maximum light contribution, reducing noise

  """

  volumetric_sample_distribution: float = ...

  """

  Distribute more samples closer to the camera

  """

  volumetric_samples: int = ...

  """

  Number of samples to compute volumetric effects

  """

  volumetric_shadow_samples: int = ...

  """

  Number of samples to compute volumetric shadowing

  """

  volumetric_start: float = ...

  """

  Start distance of the volumetric effect

  """

  volumetric_tile_size: str = ...

  """

  Control the quality of the volumetric effects (lower size increase vram usage and quality)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SceneGpencil(bpy_struct):

  """

  Render settings

  """

  antialias_threshold: float = ...

  """

  Threshold for edge detection algorithm (higher values might over-blur some part of the image)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SceneObjects(bpy_struct):

  """

  All of the scene objects

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SceneRenderView(bpy_struct):

  """

  Render viewpoint for 3D stereo and multiview rendering

  """

  camera_suffix: str = ...

  """

  Suffix to identify the cameras to use, and added to the render images for this view

  """

  file_suffix: str = ...

  """

  Suffix added to the render images for this view

  """

  name: str = ...

  """

  Render view name

  """

  use: bool = ...

  """

  Disable or enable the render view

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Scopes(bpy_struct):

  """

  Scopes for statistical view of an image

  """

  accuracy: float = ...

  """

  Proportion of original image source pixel lines to sample

  """

  histogram: Histogram = ...

  """

  Histogram for viewing image statistics

  """

  use_full_resolution: bool = ...

  """

  Sample every pixel of the image

  """

  vectorscope_alpha: float = ...

  """

  Opacity of the points

  """

  waveform_alpha: float = ...

  """

  Opacity of the points

  """

  waveform_mode: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Sequence(bpy_struct):

  """

  Sequence strip in the sequence editor

  """

  blend_alpha: float = ...

  """

  Percentage of how much the strip's colors affect other strips

  """

  blend_type: str = ...

  """

  Method for controlling how the strip combines with other strips

  """

  channel: int = ...

  """

  Y position of the sequence strip

  """

  effect_fader: float = ...

  """

  Custom fade value

  """

  frame_duration: int = ...

  """

  The length of the contents of this strip before the handles are applied

  """

  frame_final_duration: int = ...

  """

  The length of the contents of this strip after the handles are applied

  """

  frame_final_end: int = ...

  """

  End frame displayed in the sequence editor after offsets are applied

  """

  frame_final_start: int = ...

  """

  Start frame displayed in the sequence editor after offsets are applied, setting this is equivalent to moving the handle, not the actual start frame

  """

  frame_offset_end: int = ...

  frame_offset_start: int = ...

  frame_start: int = ...

  """

  X position where the strip begins

  """

  frame_still_end: int = ...

  frame_still_start: int = ...

  lock: bool = ...

  """

  Lock strip so that it cannot be transformed

  """

  modifiers: typing.Union[SequenceModifiers, typing.Sequence[SequenceModifier], typing.Mapping[str, SequenceModifier], bpy_prop_collection] = ...

  """

  Modifiers affecting this strip

  """

  mute: bool = ...

  """

  Disable strip so that it cannot be viewed in the output

  """

  name: str = ...

  override_cache_settings: bool = ...

  """

  Override global cache settings

  """

  select: bool = ...

  select_left_handle: bool = ...

  select_right_handle: bool = ...

  speed_factor: float = ...

  """

  Multiply the current speed of the sequence with this number or remap current frame to this frame

  """

  type: str = ...

  use_cache_composite: bool = ...

  """

  Cache intermediate composited images, for faster tweaking of stacked strips at the cost of memory usage

  """

  use_cache_preprocessed: bool = ...

  """

  Cache pre-processed images, for faster tweaking of effects at the cost of memory usage

  """

  use_cache_raw: bool = ...

  """

  Cache raw images read from disk, for faster tweaking of strip parameters at the cost of memory usage

  """

  use_default_fade: bool = ...

  """

  Fade effect using the built-in default (usually make transition as long as effect strip)

  """

  use_linear_modifiers: bool = ...

  """

  Calculate modifiers in linear space instead of sequencer's space

  """

  def update(self, data: bool = False) -> None:

    """

    Update the strip dimensions

    """

    ...

  def strip_elem_from_frame(self, frame: int) -> SequenceElement:

    """

    Return the strip element from a given frame or None

    """

    ...

  def swap(self, other: Sequence) -> None:

    """

    swap

    """

    ...

  def invalidate_cache(self, type: str) -> None:

    """

    Invalidate cached images for strip and all dependent strips

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequenceColorBalanceData(bpy_struct):

  """

  Color balance parameters for a sequence strip and its modifiers

  """

  gain: typing.Tuple[float, float, float] = ...

  """

  Color balance gain (highlights)

  """

  gamma: typing.Tuple[float, float, float] = ...

  """

  Color balance gamma (midtones)

  """

  invert_gain: bool = ...

  """

  Invert the gain color`

  """

  invert_gamma: bool = ...

  """

  Invert the gamma color

  """

  invert_lift: bool = ...

  """

  Invert the lift color

  """

  lift: typing.Tuple[float, float, float] = ...

  """

  Color balance lift (shadows)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequenceCrop(bpy_struct):

  """

  Cropping parameters for a sequence strip

  """

  max_x: int = ...

  """

  Number of pixels to crop from the right side

  """

  max_y: int = ...

  """

  Number of pixels to crop from the top

  """

  min_x: int = ...

  """

  Number of pixels to crop from the left side

  """

  min_y: int = ...

  """

  Number of pixels to crop from the bottom

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequenceEditor(bpy_struct):

  """

  Sequence editing data for a Scene data-block

  """

  active_strip: Sequence = ...

  """

  Sequencer's active strip

  """

  meta_stack: typing.Union[typing.Sequence[Sequence], typing.Mapping[str, Sequence], bpy_prop_collection] = ...

  """

  Meta strip stack, last is currently edited meta strip

  """

  overlay_frame: int = ...

  """

  Number of frames to offset

  """

  proxy_dir: str = ...

  proxy_storage: str = ...

  """

  How to store proxies for this project

  * ``PER_STRIP``
Per Strip, Store proxies using per strip settings.

  * ``PROJECT``
Project, Store proxies using project directory.

  """

  recycle_max_cost: float = ...

  """

  Only frames with cost lower than this value will be recycled

  """

  sequences: typing.Union[Sequences, typing.Sequence[Sequence], typing.Mapping[str, Sequence], bpy_prop_collection] = ...

  """

  Top-level strips only

  """

  sequences_all: typing.Union[typing.Sequence[Sequence], typing.Mapping[str, Sequence], bpy_prop_collection] = ...

  """

  All strips, recursively including those inside metastrips

  """

  show_cache: bool = ...

  """

  Visualize cached images on the timeline

  """

  show_cache_composite: bool = ...

  """

  Visualize cached composite images

  """

  show_cache_final_out: bool = ...

  """

  Visualize cached complete frames

  """

  show_cache_preprocessed: bool = ...

  """

  Visualize cached pre-processed images

  """

  show_cache_raw: bool = ...

  """

  Visualize cached raw images

  """

  show_overlay: bool = ...

  """

  Partial overlay on top of the sequencer with a frame offset

  """

  use_cache_composite: bool = ...

  """

  Cache intermediate composited images, for faster tweaking of stacked strips at the cost of memory usage

  """

  use_cache_final: bool = ...

  """

  Cache final image for each frame

  """

  use_cache_preprocessed: bool = ...

  """

  Cache pre-processed images, for faster tweaking of effects at the cost of memory usage

  """

  use_cache_raw: bool = ...

  """

  Cache raw images read from disk, for faster tweaking of strip parameters at the cost of memory usage

  """

  use_overlay_lock: bool = ...

  use_prefetch: bool = ...

  """

  Render frames ahead of current frame in the background for faster playback

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequenceElement(bpy_struct):

  """

  Sequence strip data for a single frame

  """

  filename: str = ...

  """

  Name of the source file

  """

  orig_height: int = ...

  """

  Original image height

  """

  orig_width: int = ...

  """

  Original image width

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequenceElements(bpy_struct):

  """

  Collection of SequenceElement

  """

  def append(self, filename: str) -> SequenceElement:

    """

    Push an image from ImageSequence.directory

    """

    ...

  def pop(self, index: int) -> None:

    """

    Pop an image off the collection

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequenceModifier(bpy_struct):

  """

  Modifier for sequence strip

  """

  input_mask_id: Mask = ...

  """

  Mask ID used as mask input for the modifier

  """

  input_mask_strip: Sequence = ...

  """

  Strip used as mask input for the modifier

  """

  input_mask_type: str = ...

  """

  Type of input data used for mask

  * ``STRIP``
Strip, Use sequencer strip as mask input.

  * ``ID``
Mask, Use mask ID as mask input.

  """

  mask_time: str = ...

  """

  Time to use for the Mask animation

  * ``RELATIVE``
Relative, Mask animation is offset to start of strip.

  * ``ABSOLUTE``
Absolute, Mask animation is in sync with scene frame.

  """

  mute: bool = ...

  """

  Mute this modifier

  """

  name: str = ...

  show_expanded: bool = ...

  """

  Mute expanded settings for the modifier

  """

  type: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequenceModifiers(bpy_struct):

  """

  Collection of strip modifiers

  """

  def new(self, name: str, type: str) -> SequenceModifier:

    """

    Add a new modifier

    """

    ...

  def remove(self, modifier: SequenceModifier) -> None:

    """

    Remove an existing modifier from the sequence

    """

    ...

  def clear(self) -> None:

    """

    Remove all modifiers from the sequence

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequenceProxy(bpy_struct):

  """

  Proxy parameters for a sequence strip

  """

  build_100: bool = ...

  """

  Build 100% proxy resolution

  """

  build_25: bool = ...

  """

  Build 25% proxy resolution

  """

  build_50: bool = ...

  """

  Build 50% proxy resolution

  """

  build_75: bool = ...

  """

  Build 75% proxy resolution

  """

  build_free_run: bool = ...

  """

  Build free run time code index

  """

  build_free_run_rec_date: bool = ...

  """

  Build free run time code index using Record Date/Time

  """

  build_record_run: bool = ...

  """

  Build record run time code index

  """

  directory: str = ...

  """

  Location to store the proxy files

  """

  filepath: str = ...

  """

  Location of custom proxy file

  """

  quality: int = ...

  """

  JPEG Quality of proxies to build

  """

  timecode: str = ...

  """

  Method for reading the inputs timecode

  * ``NONE``
No TC in use.

  * ``RECORD_RUN``
Record Run, Use images in the order as they are recorded.

  * ``FREE_RUN``
Free Run, Use global timestamp written by recording device.

  * ``FREE_RUN_REC_DATE``
Free Run (rec date), Interpolate a global timestamp using the record date and time written by recording device.

  * ``RECORD_RUN_NO_GAPS``
Record Run No Gaps, Like record run, but ignore timecode, changes in framerate or dropouts.

  """

  use_overwrite: bool = ...

  """

  Overwrite existing proxy files when building

  """

  use_proxy_custom_directory: bool = ...

  """

  Use a custom directory to store data

  """

  use_proxy_custom_file: bool = ...

  """

  Use a custom file to read proxy data from

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequenceTransform(bpy_struct):

  """

  Transform parameters for a sequence strip

  """

  offset_x: int = ...

  """

  Amount to move the input on the X axis within its boundaries

  """

  offset_y: int = ...

  """

  Amount to move the input on the Y axis within its boundaries

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Sequences(bpy_struct):

  """

  Collection of Sequences

  """

  def new_clip(self, name: str, clip: MovieClip, channel: int, frame_start: int) -> Sequence:

    """

    Add a new movie clip sequence

    """

    ...

  def new_mask(self, name: str, mask: Mask, channel: int, frame_start: int) -> Sequence:

    """

    Add a new mask sequence

    """

    ...

  def new_scene(self, name: str, scene: Scene, channel: int, frame_start: int) -> Sequence:

    """

    Add a new scene sequence

    """

    ...

  def new_image(self, name: str, filepath: str, channel: int, frame_start: int) -> Sequence:

    """

    Add a new image sequence

    """

    ...

  def new_movie(self, name: str, filepath: str, channel: int, frame_start: int) -> Sequence:

    """

    Add a new movie sequence

    """

    ...

  def new_sound(self, name: str, filepath: str, channel: int, frame_start: int) -> Sequence:

    """

    Add a new sound sequence

    """

    ...

  def new_effect(self, name: str, type: str, channel: int, frame_start: int, frame_end: int = 0, seq1: Sequence = None, seq2: Sequence = None, seq3: Sequence = None) -> Sequence:

    """

    Add a new effect sequence

    """

    ...

  def remove(self, sequence: Sequence) -> None:

    """

    Remove a Sequence

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderFx(bpy_struct):

  """

  Effect affecting the grease pencil object

  """

  name: str = ...

  """

  Effect name

  """

  show_expanded: bool = ...

  """

  Set effect expansion in the user interface

  """

  show_in_editmode: bool = ...

  """

  Display effect in Edit mode

  """

  show_render: bool = ...

  """

  Use effect during render

  """

  show_viewport: bool = ...

  """

  Display effect in viewport

  """

  type: str = ...

  """

  * ``FX_BLUR``
Blur, Apply Gaussian Blur to object.

  * ``FX_COLORIZE``
Colorize, Apply different tint effects.

  * ``FX_FLIP``
Flip, Flip image.

  * ``FX_GLOW``
Glow, Create a glow effect.

  * ``FX_PIXEL``
Pixelate, Pixelate image.

  * ``FX_RIM``
Rim, Add a rim to the image.

  * ``FX_SHADOW``
Shadow, Create a shadow effect.

  * ``FX_SWIRL``
Swirl, Create a rotation distortion.

  * ``FX_WAVE``
Wave Distortion, Apply sinusoidal deformation.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShapeKey(bpy_struct):

  """

  Shape key in a shape keys data-block

  """

  data: typing.Union[typing.Sequence[UnknownType], typing.Mapping[str, UnknownType], bpy_prop_collection] = ...

  frame: float = ...

  """

  Frame for absolute keys

  """

  interpolation: str = ...

  """

  Interpolation type for absolute shape keys

  """

  mute: bool = ...

  """

  Toggle this shape key

  """

  name: str = ...

  """

  Name of Shape Key

  """

  relative_key: ShapeKey = ...

  """

  Shape used as a relative key

  """

  slider_max: float = ...

  """

  Maximum for slider

  """

  slider_min: float = ...

  """

  Minimum for slider

  """

  value: float = ...

  """

  Value of shape key at the current frame

  """

  vertex_group: str = ...

  """

  Vertex weight group, to blend with basis shape

  """

  def normals_vertex_get(self) -> float:

    """

    Compute local space vertices' normals for this shape key

    """

    ...

  def normals_polygon_get(self) -> float:

    """

    Compute local space faces' normals for this shape key

    """

    ...

  def normals_split_get(self) -> float:

    """

    Compute local space face corners' normals for this shape key

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShapeKeyBezierPoint(bpy_struct):

  """

  Point in a shape key for Bezier curves

  """

  co: typing.Tuple[float, float, float] = ...

  handle_left: typing.Tuple[float, float, float] = ...

  handle_right: typing.Tuple[float, float, float] = ...

  radius: float = ...

  """

  Radius for beveling

  """

  tilt: float = ...

  """

  Tilt in 3D View

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShapeKeyCurvePoint(bpy_struct):

  """

  Point in a shape key for curves

  """

  co: typing.Tuple[float, float, float] = ...

  radius: float = ...

  """

  Radius for beveling

  """

  tilt: float = ...

  """

  Tilt in 3D View

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShapeKeyPoint(bpy_struct):

  """

  Point in a shape key

  """

  co: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SoftBodySettings(bpy_struct):

  """

  Soft body simulation settings for an object

  """

  aero: int = ...

  """

  Make edges 'sail'

  """

  aerodynamics_type: str = ...

  """

  Method of calculating aerodynamic interaction

  * ``SIMPLE``
Simple, Edges receive a drag force from surrounding media.

  * ``LIFT_FORCE``
Lift Force, Edges receive a lift force when passing through surrounding media.

  """

  ball_damp: float = ...

  """

  Blending to inelastic collision

  """

  ball_size: float = ...

  """

  Absolute ball size or factor if not manually adjusted

  """

  ball_stiff: float = ...

  """

  Ball inflating pressure

  """

  bend: float = ...

  """

  Bending Stiffness

  """

  choke: int = ...

  """

  'Viscosity' inside collision target

  """

  collision_collection: Collection = ...

  """

  Limit colliders to this collection

  """

  collision_type: str = ...

  """

  Choose Collision Type

  * ``MANUAL``
Manual, Manual adjust.

  * ``AVERAGE``
Average, Average Spring length * Ball Size.

  * ``MINIMAL``
Minimal, Minimal Spring length * Ball Size.

  * ``MAXIMAL``
Maximal, Maximal Spring length * Ball Size.

  * ``MINMAX``
AvMinMax, (Min+Max)/2 * Ball Size.

  """

  damping: float = ...

  """

  Edge spring friction

  """

  effector_weights: EffectorWeights = ...

  error_threshold: float = ...

  """

  The Runge-Kutta ODE solver error limit, low value gives more precision, high values speed

  """

  friction: float = ...

  """

  General media friction for point movements

  """

  fuzzy: int = ...

  """

  Fuzziness while on collision, high values make collision handling faster but less stable

  """

  goal_default: float = ...

  """

  Default Goal (vertex target position) value

  """

  goal_friction: float = ...

  """

  Goal (vertex target position) friction

  """

  goal_max: float = ...

  """

  Goal maximum, vertex weights are scaled to match this range

  """

  goal_min: float = ...

  """

  Goal minimum, vertex weights are scaled to match this range

  """

  goal_spring: float = ...

  """

  Goal (vertex target position) spring stiffness

  """

  gravity: float = ...

  """

  Apply gravitation to point movement

  """

  location_mass_center: typing.Tuple[float, float, float] = ...

  """

  Location of center of mass

  """

  mass: float = ...

  """

  General Mass value

  """

  plastic: int = ...

  """

  Permanent deform

  """

  pull: float = ...

  """

  Edge spring stiffness when longer than rest length

  """

  push: float = ...

  """

  Edge spring stiffness when shorter than rest length

  """

  rotation_estimate: typing.Tuple[typing.Tuple[float, float, float], typing.Tuple[float, float, float], typing.Tuple[float, float, float]] = ...

  """

  Estimated rotation matrix

  """

  scale_estimate: typing.Tuple[typing.Tuple[float, float, float], typing.Tuple[float, float, float], typing.Tuple[float, float, float]] = ...

  """

  Estimated scale matrix

  """

  shear: float = ...

  """

  Shear Stiffness

  """

  speed: float = ...

  """

  Tweak timing for physics to control frequency and speed

  """

  spring_length: int = ...

  """

  Alter spring length to shrink/blow up (unit %) 0 to disable

  """

  step_max: int = ...

  """

  Maximal # solver steps/frame

  """

  step_min: int = ...

  """

  Minimal # solver steps/frame

  """

  use_auto_step: bool = ...

  """

  Use velocities for automagic step sizes

  """

  use_diagnose: bool = ...

  """

  Turn on SB diagnose console prints

  """

  use_edge_collision: bool = ...

  """

  Edges collide too

  """

  use_edges: bool = ...

  """

  Use Edges as springs

  """

  use_estimate_matrix: bool = ...

  """

  Estimate matrix... split to COM, ROT, SCALE

  """

  use_face_collision: bool = ...

  """

  Faces collide too, can be very slow

  """

  use_goal: bool = ...

  """

  Define forces for vertices to stick to animated position

  """

  use_self_collision: bool = ...

  """

  Enable naive vertex ball self collision

  """

  use_stiff_quads: bool = ...

  """

  Add diagonal springs on 4-gons

  """

  vertex_group_goal: str = ...

  """

  Control point weight values

  """

  vertex_group_mass: str = ...

  """

  Control point mass values

  """

  vertex_group_spring: str = ...

  """

  Control point spring strength values

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Space(bpy_struct):

  """

  Space data for a screen area

  """

  show_locked_time: bool = ...

  """

  Synchronize the visible timeline range with other time-based editors

  """

  show_region_header: bool = ...

  type: str = ...

  """

  Space data type

  * ``EMPTY``
Empty.

  * ``VIEW_3D``
3D Viewport, Manipulate objects in a 3D environment.

  * ``IMAGE_EDITOR``
UV/Image Editor, View and edit images and UV Maps.

  * ``NODE_EDITOR``
Node Editor, Editor for node-based shading and compositing tools.

  * ``SEQUENCE_EDITOR``
Video Sequencer, Video editing tools.

  * ``CLIP_EDITOR``
Movie Clip Editor, Motion tracking tools.

  * ``DOPESHEET_EDITOR``
Dope Sheet, Adjust timing of keyframes.

  * ``GRAPH_EDITOR``
Graph Editor, Edit drivers and keyframe interpolation.

  * ``NLA_EDITOR``
Nonlinear Animation, Combine and layer Actions.

  * ``TEXT_EDITOR``
Text Editor, Edit scripts and in-file documentation.

  * ``CONSOLE``
Python Console, Interactive programmatic console for advanced editing and script development.

  * ``INFO``
Info, Log of operations, warnings and error messages.

  * ``TOPBAR``
Top Bar, Global bar at the top of the screen for global per-window settings.

  * ``STATUSBAR``
Status Bar, Global bar at the bottom of the screen for general status information.

  * ``OUTLINER``
Outliner, Overview of scene graph and all available data-blocks.

  * ``PROPERTIES``
Properties, Edit properties of active object and related data-blocks.

  * ``FILE_BROWSER``
File Browser, Browse for files and assets.

  * ``PREFERENCES``
Preferences, Edit persistent configuration settings.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceImageOverlay(bpy_struct):

  """

  Settings for display of overlays in the UV/Image editor

  """

  show_overlays: bool = ...

  """

  Display overlays like UV Maps and Metadata

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SpaceNodeEditorPath(bpy_struct):

  """

  Get the node tree path as a string

  """

  to_string: str = ...

  def clear(self) -> None:

    """

    Reset the node tree path

    """

    ...

  def start(self, node_tree: NodeTree) -> None:

    """

    Set the root node tree

    """

    ...

  def append(self, node_tree: NodeTree, node: Node = None) -> None:

    """

    Append a node group tree to the path

    """

    ...

  def pop(self) -> None:

    """

    Remove the last node tree from the path

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SpaceUVEditor(bpy_struct):

  """

  UV editor data for the image editor space

  """

  display_stretch_type: str = ...

  """

  Type of stretch to draw

  * ``ANGLE``
Angle, Angular distortion between UV and 3D angles.

  * ``AREA``
Area, Area distortion between UV and 3D faces.

  """

  edge_display_type: str = ...

  """

  Display style for UV edges

  * ``OUTLINE``
Outline, Display white edges with black outline.

  * ``DASH``
Dash, Display dashed black-white edges.

  * ``BLACK``
Black, Display black edges.

  * ``WHITE``
White, Display white edges.

  """

  lock_bounds: bool = ...

  """

  Constraint to stay within the image bounds while editing

  """

  pixel_snap_mode: str = ...

  """

  Snap UVs to pixels while editing

  * ``DISABLED``
Disabled, Don't snap to pixels.

  * ``CORNER``
Corner, Snap to pixel corners.

  * ``CENTER``
Center, Snap to pixel centers.

  """

  show_faces: bool = ...

  """

  Display faces over the image

  """

  show_metadata: bool = ...

  """

  Display metadata properties of the image

  """

  show_modified_edges: bool = ...

  """

  Display edges after modifiers are applied

  """

  show_pixel_coords: bool = ...

  """

  Display UV coordinates in pixels rather than from 0.0 to 1.0

  """

  show_stretch: bool = ...

  """

  Display faces colored according to the difference in shape between UVs and their 3D coordinates (blue for low distortion, red for high distortion)

  """

  show_texpaint: bool = ...

  """

  Display overlay of texture paint uv layer

  """

  sticky_select_mode: str = ...

  """

  Method for extending UV vertex selection

  * ``DISABLED``
Disabled, Sticky vertex selection disabled.

  * ``SHARED_LOCATION``
Shared Location, Select UVs that are at the same location and share a mesh vertex.

  * ``SHARED_VERTEX``
Shared Vertex, Select UVs that share a mesh vertex, whether or not they are at the same location.

  """

  tile_grid_shape: typing.Tuple[int, int] = ...

  """

  How many tiles will be shown in the background

  """

  use_live_unwrap: bool = ...

  """

  Continuously unwrap the selected UV island while transforming pinned vertices

  """

  uv_opacity: float = ...

  """

  Opacity of UV overlays

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Spline(bpy_struct):

  """

  Element of a curve, either NURBS, Bezier or Polyline or a character with text objects

  """

  bezier_points: typing.Union[SplineBezierPoints, typing.Sequence[BezierSplinePoint], typing.Mapping[str, BezierSplinePoint], bpy_prop_collection] = ...

  """

  Collection of points for Bezier curves only

  """

  character_index: int = ...

  """

  Location of this character in the text data (only for text curves)

  """

  hide: bool = ...

  """

  Hide this curve in Edit mode

  """

  material_index: int = ...

  order_u: int = ...

  """

  NURBS order in the U direction (for splines and surfaces, higher values let points influence a greater area)

  """

  order_v: int = ...

  """

  NURBS order in the V direction (for surfaces only, higher values let points influence a greater area)

  """

  point_count_u: int = ...

  """

  Total number points for the curve or surface in the U direction

  """

  point_count_v: int = ...

  """

  Total number points for the surface on the V direction

  """

  points: typing.Union[SplinePoints, typing.Sequence[SplinePoint], typing.Mapping[str, SplinePoint], bpy_prop_collection] = ...

  """

  Collection of points that make up this poly or nurbs spline

  """

  radius_interpolation: str = ...

  """

  The type of radius interpolation for Bezier curves

  """

  resolution_u: int = ...

  """

  Curve or Surface subdivisions per segment

  """

  resolution_v: int = ...

  """

  Surface subdivisions per segment

  """

  tilt_interpolation: str = ...

  """

  The type of tilt interpolation for 3D, Bezier curves

  """

  type: str = ...

  """

  The interpolation type for this curve element

  """

  use_bezier_u: bool = ...

  """

  Make this nurbs curve or surface act like a Bezier spline in the U direction (Order U must be 3 or 4, Cyclic U must be disabled)

  """

  use_bezier_v: bool = ...

  """

  Make this nurbs surface act like a Bezier spline in the V direction (Order V must be 3 or 4, Cyclic V must be disabled)

  """

  use_cyclic_u: bool = ...

  """

  Make this curve or surface a closed loop in the U direction

  """

  use_cyclic_v: bool = ...

  """

  Make this surface a closed loop in the V direction

  """

  use_endpoint_u: bool = ...

  """

  Make this nurbs curve or surface meet the endpoints in the U direction (Cyclic U must be disabled)

  """

  use_endpoint_v: bool = ...

  """

  Make this nurbs surface meet the endpoints in the V direction (Cyclic V must be disabled)

  """

  use_smooth: bool = ...

  """

  Smooth the normals of the surface or beveled curve

  """

  def calc_length(self, resolution: int = 0) -> float:

    """

    Calculate spline length

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SplineBezierPoints(bpy_struct):

  """

  Collection of spline Bezier points

  """

  def add(self, count: int) -> None:

    """

    Add a number of points to this spline

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SplinePoint(bpy_struct):

  """

  Spline point without handles

  """

  co: typing.Tuple[float, float, float, float] = ...

  """

  Point coordinates

  """

  hide: bool = ...

  """

  Visibility status

  """

  radius: float = ...

  """

  Radius for beveling

  """

  select: bool = ...

  """

  Selection status

  """

  tilt: float = ...

  """

  Tilt in 3D View

  """

  weight: float = ...

  """

  NURBS weight

  """

  weight_softbody: float = ...

  """

  Softbody goal weight

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SplinePoints(bpy_struct):

  """

  Collection of spline points

  """

  def add(self, count: int) -> None:

    """

    Add a number of points to this spline

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Stereo3dDisplay(bpy_struct):

  """

  Settings for stereo 3D display

  """

  anaglyph_type: str = ...

  display_mode: str = ...

  """

  * ``ANAGLYPH``
Anaglyph, Render views for left and right eyes as two differently filtered colors in a single image (anaglyph glasses are required).

  * ``INTERLACE``
Interlace, Render views for left and right eyes interlaced in a single image (3D-ready monitor is required).

  * ``TIMESEQUENTIAL``
Time Sequential, Render alternate eyes (also known as page flip, quad buffer support in the graphic card is required).

  * ``SIDEBYSIDE``
Side-by-Side, Render views for left and right eyes side-by-side.

  * ``TOPBOTTOM``
Top-Bottom, Render views for left and right eyes one above another.

  """

  interlace_type: str = ...

  use_interlace_swap: bool = ...

  """

  Swap left and right stereo channels

  """

  use_sidebyside_crosseyed: bool = ...

  """

  Right eye should see left image and vice-versa

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Stereo3dFormat(bpy_struct):

  """

  Settings for stereo output

  """

  anaglyph_type: str = ...

  display_mode: str = ...

  """

  * ``ANAGLYPH``
Anaglyph, Render views for left and right eyes as two differently filtered colors in a single image (anaglyph glasses are required).

  * ``INTERLACE``
Interlace, Render views for left and right eyes interlaced in a single image (3D-ready monitor is required).

  * ``SIDEBYSIDE``
Side-by-Side, Render views for left and right eyes side-by-side.

  * ``TOPBOTTOM``
Top-Bottom, Render views for left and right eyes one above another.

  """

  interlace_type: str = ...

  use_interlace_swap: bool = ...

  """

  Swap left and right stereo channels

  """

  use_sidebyside_crosseyed: bool = ...

  """

  Right eye should see left image and vice-versa

  """

  use_squeezed_frame: bool = ...

  """

  Combine both views in a squeezed image

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class StringAttributeValue(bpy_struct):

  """

  String value in geometry attribute

  """

  value: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Struct(bpy_struct):

  """

  RNA structure definition

  """

  base: Struct = ...

  """

  Struct definition this is derived from

  """

  description: str = ...

  """

  Description of the Struct's purpose

  """

  functions: typing.Union[typing.Sequence[Function], typing.Mapping[str, Function], bpy_prop_collection] = ...

  identifier: str = ...

  """

  Unique name used in the code and scripting

  """

  name: str = ...

  """

  Human readable name

  """

  name_property: StringProperty = ...

  """

  Property that gives the name of the struct

  """

  nested: Struct = ...

  """

  Struct in which this struct is always nested, and to which it logically belongs

  """

  properties: typing.Union[typing.Sequence[Property], typing.Mapping[str, Property], bpy_prop_collection] = ...

  """

  Properties in the struct

  """

  property_tags: typing.Union[typing.Sequence[EnumPropertyItem], typing.Mapping[str, EnumPropertyItem], bpy_prop_collection] = ...

  """

  Tags that properties can use to influence behavior

  """

  translation_context: str = ...

  """

  Translation context of the struct's name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class StudioLight(bpy_struct):

  """

  Studio light

  """

  has_specular_highlight_pass: bool = ...

  """

  Studio light image file has separate "diffuse" and "specular" passes

  """

  index: int = ...

  is_user_defined: bool = ...

  light_ambient: typing.Tuple[float, float, float] = ...

  """

  Color of the ambient light that uniformly lit the scene

  """

  name: str = ...

  path: str = ...

  path_irr_cache: str = ...

  """

  Path where the irradiance cache is stored

  """

  path_sh_cache: str = ...

  """

  Path where the spherical harmonics cache is stored

  """

  solid_lights: typing.Union[typing.Sequence[UserSolidLight], typing.Mapping[str, UserSolidLight], bpy_prop_collection] = ...

  """

  Lights user to display objects in solid draw mode

  """

  spherical_harmonics_coefficients: typing.Tuple[typing.Tuple[float, float, float], typing.Tuple[float, float, float], typing.Tuple[float, float, float], typing.Tuple[float, float, float]] = ...

  type: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class StudioLights(bpy_struct):

  """

  Collection of studio lights

  """

  def load(self, path: str, type: str) -> StudioLight:

    """

    Load studiolight from file

    """

    ...

  def new(self, path: str) -> StudioLight:

    """

    Create studiolight from default lighting

    """

    ...

  def remove(self, studio_light: StudioLight) -> None:

    """

    Remove a studio light

    """

    ...

  def refresh(self) -> None:

    """

    Refresh Studio Lights from disk

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TexMapping(bpy_struct):

  """

  Texture coordinate mapping settings

  """

  mapping: str = ...

  """

  * ``FLAT``
Flat, Map X and Y coordinates directly.

  * ``CUBE``
Cube, Map using the normal vector.

  * ``TUBE``
Tube, Map with Z as central axis.

  * ``SPHERE``
Sphere, Map with Z as central axis.

  """

  mapping_x: str = ...

  mapping_y: str = ...

  mapping_z: str = ...

  max: typing.Tuple[float, float, float] = ...

  """

  Maximum value for clipping

  """

  min: typing.Tuple[float, float, float] = ...

  """

  Minimum value for clipping

  """

  rotation: typing.Tuple[float, float, float] = ...

  scale: typing.Tuple[float, float, float] = ...

  translation: typing.Tuple[float, float, float] = ...

  use_max: bool = ...

  """

  Whether to use maximum clipping value

  """

  use_min: bool = ...

  """

  Whether to use minimum clipping value

  """

  vector_type: str = ...

  """

  Type of vector that the mapping transforms

  * ``POINT``
Point, Transform a point.

  * ``TEXTURE``
Texture, Transform a texture by inverse mapping the texture coordinate.

  * ``VECTOR``
Vector, Transform a direction vector. Location is ignored.

  * ``NORMAL``
Normal, Transform a unit normal vector. Location is ignored.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TexPaintSlot(bpy_struct):

  """

  Slot that contains information about texture painting

  """

  is_valid: bool = ...

  """

  Slot has a valid image and UV map

  """

  uv_layer: str = ...

  """

  Name of UV map

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextBox(bpy_struct):

  """

  Text bounding box for layout

  """

  height: float = ...

  width: float = ...

  x: float = ...

  y: float = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextCharacterFormat(bpy_struct):

  """

  Text character formatting settings

  """

  kerning: int = ...

  """

  Spacing between characters

  """

  material_index: int = ...

  use_bold: bool = ...

  use_italic: bool = ...

  use_small_caps: bool = ...

  use_underline: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextLine(bpy_struct):

  """

  Line of text in a Text data-block

  """

  body: str = ...

  """

  Text in the line

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureSlot(bpy_struct):

  """

  Texture slot defining the mapping and influence of a texture

  """

  blend_type: str = ...

  """

  Mode used to apply the texture

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Default color for textures that don't return RGB or when RGB to intensity is enabled

  """

  default_value: float = ...

  """

  Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard

  """

  name: str = ...

  """

  Texture slot name

  """

  offset: typing.Tuple[float, float, float] = ...

  """

  Fine tune of the texture mapping X, Y and Z locations

  """

  output_node: str = ...

  """

  Which output node to use, for node-based textures

  """

  scale: typing.Tuple[float, float, float] = ...

  """

  Set scaling for the texture's X, Y and Z sizes

  """

  texture: Texture = ...

  """

  Texture data-block used by this texture slot

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Theme(bpy_struct):

  """

  Theme settings defining draw style and colors in the user interface

  """

  bone_color_sets: typing.Union[typing.Sequence[ThemeBoneColorSet], typing.Mapping[str, ThemeBoneColorSet], bpy_prop_collection] = ...

  clip_editor: ThemeClipEditor = ...

  collection_color: typing.Union[typing.Sequence[ThemeCollectionColor], typing.Mapping[str, ThemeCollectionColor], bpy_prop_collection] = ...

  console: ThemeConsole = ...

  dopesheet_editor: ThemeDopeSheet = ...

  file_browser: ThemeFileBrowser = ...

  graph_editor: ThemeGraphEditor = ...

  image_editor: ThemeImageEditor = ...

  info: ThemeInfo = ...

  name: str = ...

  """

  Name of the theme

  """

  nla_editor: ThemeNLAEditor = ...

  node_editor: ThemeNodeEditor = ...

  outliner: ThemeOutliner = ...

  preferences: ThemePreferences = ...

  properties: ThemeProperties = ...

  sequence_editor: ThemeSequenceEditor = ...

  statusbar: ThemeStatusBar = ...

  text_editor: ThemeTextEditor = ...

  theme_area: str = ...

  topbar: ThemeTopBar = ...

  user_interface: ThemeUserInterface = ...

  view_3d: ThemeView3D = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeBoneColorSet(bpy_struct):

  """

  Theme settings for bone color sets

  """

  active: typing.Tuple[float, float, float] = ...

  """

  Color used for active bones

  """

  normal: typing.Tuple[float, float, float] = ...

  """

  Color used for the surface of bones

  """

  select: typing.Tuple[float, float, float] = ...

  """

  Color used for selected bones

  """

  show_colored_constraints: bool = ...

  """

  Allow the use of colors indicating constraints/keyed status

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeClipEditor(bpy_struct):

  """

  Theme settings for the Movie Clip Editor

  """

  active_marker: typing.Tuple[float, float, float] = ...

  """

  Color of active marker

  """

  disabled_marker: typing.Tuple[float, float, float] = ...

  """

  Color of disabled marker

  """

  frame_current: typing.Tuple[float, float, float] = ...

  grid: typing.Tuple[float, float, float, float] = ...

  handle_align: typing.Tuple[float, float, float] = ...

  handle_auto: typing.Tuple[float, float, float] = ...

  handle_auto_clamped: typing.Tuple[float, float, float] = ...

  handle_free: typing.Tuple[float, float, float] = ...

  handle_sel_align: typing.Tuple[float, float, float] = ...

  handle_sel_auto: typing.Tuple[float, float, float] = ...

  handle_sel_auto_clamped: typing.Tuple[float, float, float] = ...

  handle_sel_free: typing.Tuple[float, float, float] = ...

  handle_vertex: typing.Tuple[float, float, float] = ...

  handle_vertex_select: typing.Tuple[float, float, float] = ...

  handle_vertex_size: int = ...

  locked_marker: typing.Tuple[float, float, float] = ...

  """

  Color of locked marker

  """

  marker: typing.Tuple[float, float, float] = ...

  """

  Color of marker

  """

  marker_outline: typing.Tuple[float, float, float] = ...

  """

  Color of marker's outline

  """

  metadatabg: typing.Tuple[float, float, float] = ...

  metadatatext: typing.Tuple[float, float, float] = ...

  path_after: typing.Tuple[float, float, float] = ...

  """

  Color of path after current frame

  """

  path_before: typing.Tuple[float, float, float] = ...

  """

  Color of path before current frame

  """

  path_keyframe_after: typing.Tuple[float, float, float] = ...

  """

  Color of path after current frame

  """

  path_keyframe_before: typing.Tuple[float, float, float] = ...

  """

  Color of path before current frame

  """

  selected_marker: typing.Tuple[float, float, float] = ...

  """

  Color of selected marker

  """

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  space_list: ThemeSpaceListGeneric = ...

  """

  Settings for space list

  """

  strips: typing.Tuple[float, float, float] = ...

  strips_selected: typing.Tuple[float, float, float] = ...

  time_marker_line: typing.Tuple[float, float, float, float] = ...

  time_marker_line_selected: typing.Tuple[float, float, float, float] = ...

  time_scrub_background: typing.Tuple[float, float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeCollectionColor(bpy_struct):

  """

  Theme settings for collection colors

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Collection Color Tag

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeConsole(bpy_struct):

  """

  Theme settings for the Console

  """

  cursor: typing.Tuple[float, float, float] = ...

  line_error: typing.Tuple[float, float, float] = ...

  line_info: typing.Tuple[float, float, float] = ...

  line_input: typing.Tuple[float, float, float] = ...

  line_output: typing.Tuple[float, float, float] = ...

  select: typing.Tuple[float, float, float, float] = ...

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeDopeSheet(bpy_struct):

  """

  Theme settings for the Dope Sheet

  """

  active_channels_group: typing.Tuple[float, float, float, float] = ...

  channel_group: typing.Tuple[float, float, float, float] = ...

  channels: typing.Tuple[float, float, float, float] = ...

  channels_selected: typing.Tuple[float, float, float, float] = ...

  dopesheet_channel: typing.Tuple[float, float, float, float] = ...

  dopesheet_subchannel: typing.Tuple[float, float, float, float] = ...

  frame_current: typing.Tuple[float, float, float] = ...

  grid: typing.Tuple[float, float, float] = ...

  interpolation_line: typing.Tuple[float, float, float, float] = ...

  """

  Color of lines showing non-bezier interpolation modes

  """

  keyframe: typing.Tuple[float, float, float] = ...

  """

  Color of Keyframe

  """

  keyframe_border: typing.Tuple[float, float, float, float] = ...

  """

  Color of keyframe border

  """

  keyframe_border_selected: typing.Tuple[float, float, float, float] = ...

  """

  Color of selected keyframe border

  """

  keyframe_breakdown: typing.Tuple[float, float, float] = ...

  """

  Color of breakdown keyframe

  """

  keyframe_breakdown_selected: typing.Tuple[float, float, float] = ...

  """

  Color of selected breakdown keyframe

  """

  keyframe_extreme: typing.Tuple[float, float, float] = ...

  """

  Color of extreme keyframe

  """

  keyframe_extreme_selected: typing.Tuple[float, float, float] = ...

  """

  Color of selected extreme keyframe

  """

  keyframe_jitter: typing.Tuple[float, float, float] = ...

  """

  Color of jitter keyframe

  """

  keyframe_jitter_selected: typing.Tuple[float, float, float] = ...

  """

  Color of selected jitter keyframe

  """

  keyframe_movehold: typing.Tuple[float, float, float] = ...

  """

  Color of moving hold keyframe

  """

  keyframe_movehold_selected: typing.Tuple[float, float, float] = ...

  """

  Color of selected moving hold keyframe

  """

  keyframe_scale_factor: float = ...

  """

  Scale factor for adjusting the height of keyframes

  """

  keyframe_selected: typing.Tuple[float, float, float] = ...

  """

  Color of selected keyframe

  """

  long_key: typing.Tuple[float, float, float, float] = ...

  long_key_selected: typing.Tuple[float, float, float, float] = ...

  preview_range: typing.Tuple[float, float, float, float] = ...

  """

  Color of preview range overlay

  """

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  space_list: ThemeSpaceListGeneric = ...

  """

  Settings for space list

  """

  summary: typing.Tuple[float, float, float, float] = ...

  """

  Color of summary channel

  """

  time_marker_line: typing.Tuple[float, float, float, float] = ...

  time_marker_line_selected: typing.Tuple[float, float, float, float] = ...

  time_scrub_background: typing.Tuple[float, float, float, float] = ...

  value_sliders: typing.Tuple[float, float, float] = ...

  view_sliders: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeFileBrowser(bpy_struct):

  """

  Theme settings for the File Browser

  """

  row_alternate: typing.Tuple[float, float, float, float] = ...

  """

  Overlay color on every other row

  """

  selected_file: typing.Tuple[float, float, float] = ...

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeFontStyle(bpy_struct):

  """

  Theme settings for Font

  """

  font_kerning_style: str = ...

  """

  Which style to use for font kerning

  * ``UNFITTED``
Unfitted, Use scaled but un-grid-fitted kerning distances.

  * ``FITTED``
Fitted, Use scaled and grid-fitted kerning distances.

  """

  points: int = ...

  """

  Font size in points

  """

  shadow: int = ...

  """

  Shadow size (0, 3 and 5 supported)

  """

  shadow_alpha: float = ...

  shadow_offset_x: int = ...

  """

  Shadow offset in pixels

  """

  shadow_offset_y: int = ...

  """

  Shadow offset in pixels

  """

  shadow_value: float = ...

  """

  Shadow color in gray value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeGradientColors(bpy_struct):

  """

  Theme settings for background colors and gradient

  """

  background_type: str = ...

  """

  Type of background in the 3D viewport

  * ``SINGLE_COLOR``
Single Color, Use a solid color as viewport background.

  * ``LINEAR``
Linear Gradient, Use a screen space vertical linear gradient as viewport background.

  * ``RADIAL``
Vignette, Use a radial gradient as viewport background.

  """

  gradient: typing.Tuple[float, float, float] = ...

  high_gradient: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeGraphEditor(bpy_struct):

  """

  Theme settings for the graph editor

  """

  active_channels_group: typing.Tuple[float, float, float] = ...

  channel_group: typing.Tuple[float, float, float] = ...

  channels_region: typing.Tuple[float, float, float] = ...

  dopesheet_channel: typing.Tuple[float, float, float] = ...

  dopesheet_subchannel: typing.Tuple[float, float, float] = ...

  frame_current: typing.Tuple[float, float, float] = ...

  grid: typing.Tuple[float, float, float] = ...

  handle_align: typing.Tuple[float, float, float] = ...

  handle_auto: typing.Tuple[float, float, float] = ...

  handle_auto_clamped: typing.Tuple[float, float, float] = ...

  handle_free: typing.Tuple[float, float, float] = ...

  handle_sel_align: typing.Tuple[float, float, float] = ...

  handle_sel_auto: typing.Tuple[float, float, float] = ...

  handle_sel_auto_clamped: typing.Tuple[float, float, float] = ...

  handle_sel_free: typing.Tuple[float, float, float] = ...

  handle_sel_vect: typing.Tuple[float, float, float] = ...

  handle_vect: typing.Tuple[float, float, float] = ...

  handle_vertex: typing.Tuple[float, float, float] = ...

  handle_vertex_select: typing.Tuple[float, float, float] = ...

  handle_vertex_size: int = ...

  lastsel_point: typing.Tuple[float, float, float] = ...

  preview_range: typing.Tuple[float, float, float, float] = ...

  """

  Color of preview range overlay

  """

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  space_list: ThemeSpaceListGeneric = ...

  """

  Settings for space list

  """

  time_marker_line: typing.Tuple[float, float, float, float] = ...

  time_marker_line_selected: typing.Tuple[float, float, float, float] = ...

  time_scrub_background: typing.Tuple[float, float, float, float] = ...

  vertex: typing.Tuple[float, float, float] = ...

  vertex_active: typing.Tuple[float, float, float] = ...

  vertex_bevel: typing.Tuple[float, float, float] = ...

  vertex_select: typing.Tuple[float, float, float] = ...

  vertex_size: int = ...

  vertex_unreferenced: typing.Tuple[float, float, float] = ...

  window_sliders: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeImageEditor(bpy_struct):

  """

  Theme settings for the Image Editor

  """

  edge_select: typing.Tuple[float, float, float] = ...

  editmesh_active: typing.Tuple[float, float, float, float] = ...

  face: typing.Tuple[float, float, float, float] = ...

  face_back: typing.Tuple[float, float, float, float] = ...

  face_dot: typing.Tuple[float, float, float] = ...

  face_front: typing.Tuple[float, float, float, float] = ...

  face_select: typing.Tuple[float, float, float, float] = ...

  facedot_size: int = ...

  frame_current: typing.Tuple[float, float, float] = ...

  freestyle_face_mark: typing.Tuple[float, float, float, float] = ...

  grid: typing.Tuple[float, float, float, float] = ...

  handle_align: typing.Tuple[float, float, float] = ...

  handle_auto: typing.Tuple[float, float, float] = ...

  handle_auto_clamped: typing.Tuple[float, float, float] = ...

  handle_free: typing.Tuple[float, float, float] = ...

  handle_sel_align: typing.Tuple[float, float, float] = ...

  handle_sel_auto: typing.Tuple[float, float, float] = ...

  handle_sel_auto_clamped: typing.Tuple[float, float, float] = ...

  handle_sel_free: typing.Tuple[float, float, float] = ...

  handle_vertex: typing.Tuple[float, float, float] = ...

  handle_vertex_select: typing.Tuple[float, float, float] = ...

  handle_vertex_size: int = ...

  metadatabg: typing.Tuple[float, float, float] = ...

  metadatatext: typing.Tuple[float, float, float] = ...

  paint_curve_handle: typing.Tuple[float, float, float, float] = ...

  paint_curve_pivot: typing.Tuple[float, float, float, float] = ...

  preview_stitch_active: typing.Tuple[float, float, float, float] = ...

  preview_stitch_edge: typing.Tuple[float, float, float, float] = ...

  preview_stitch_face: typing.Tuple[float, float, float, float] = ...

  preview_stitch_stitchable: typing.Tuple[float, float, float, float] = ...

  preview_stitch_unstitchable: typing.Tuple[float, float, float, float] = ...

  preview_stitch_vert: typing.Tuple[float, float, float, float] = ...

  scope_back: typing.Tuple[float, float, float, float] = ...

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  uv_shadow: typing.Tuple[float, float, float, float] = ...

  vertex: typing.Tuple[float, float, float] = ...

  vertex_active: typing.Tuple[float, float, float] = ...

  vertex_bevel: typing.Tuple[float, float, float] = ...

  vertex_select: typing.Tuple[float, float, float] = ...

  vertex_size: int = ...

  vertex_unreferenced: typing.Tuple[float, float, float] = ...

  wire_edit: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeInfo(bpy_struct):

  """

  Theme settings for Info

  """

  info_debug: typing.Tuple[float, float, float, float] = ...

  """

  Background color of Debug icon

  """

  info_debug_text: typing.Tuple[float, float, float] = ...

  """

  Foreground color of Debug icon

  """

  info_error: typing.Tuple[float, float, float, float] = ...

  """

  Background color of Error icon

  """

  info_error_text: typing.Tuple[float, float, float] = ...

  """

  Foreground color of Error icon

  """

  info_info: typing.Tuple[float, float, float, float] = ...

  """

  Background color of Info icon

  """

  info_info_text: typing.Tuple[float, float, float] = ...

  """

  Foreground color of Info icon

  """

  info_operator: typing.Tuple[float, float, float, float] = ...

  """

  Background color of Operator icon

  """

  info_operator_text: typing.Tuple[float, float, float] = ...

  """

  Foreground color of Operator icon

  """

  info_property: typing.Tuple[float, float, float, float] = ...

  """

  Background color of Property icon

  """

  info_property_text: typing.Tuple[float, float, float] = ...

  """

  Foreground color of Property icon

  """

  info_selected: typing.Tuple[float, float, float] = ...

  """

  Background color of selected line

  """

  info_selected_text: typing.Tuple[float, float, float] = ...

  """

  Text color of selected line

  """

  info_warning: typing.Tuple[float, float, float, float] = ...

  """

  Background color of Warning icon

  """

  info_warning_text: typing.Tuple[float, float, float] = ...

  """

  Foreground color of Warning icon

  """

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeNLAEditor(bpy_struct):

  """

  Theme settings for the NLA Editor

  """

  active_action: typing.Tuple[float, float, float, float] = ...

  """

  Animation data-block has active action

  """

  active_action_unset: typing.Tuple[float, float, float, float] = ...

  """

  Animation data-block doesn't have active action

  """

  dopesheet_channel: typing.Tuple[float, float, float] = ...

  """

  Nonlinear Animation Channel

  """

  frame_current: typing.Tuple[float, float, float] = ...

  grid: typing.Tuple[float, float, float] = ...

  keyframe_border: typing.Tuple[float, float, float, float] = ...

  """

  Color of keyframe border

  """

  keyframe_border_selected: typing.Tuple[float, float, float, float] = ...

  """

  Color of selected keyframe border

  """

  meta_strips: typing.Tuple[float, float, float] = ...

  """

  Meta Strip - Unselected (for grouping related strips)

  """

  meta_strips_selected: typing.Tuple[float, float, float] = ...

  """

  Meta Strip - Selected (for grouping related strips)

  """

  nla_track: typing.Tuple[float, float, float] = ...

  """

  Nonlinear Animation Track

  """

  preview_range: typing.Tuple[float, float, float, float] = ...

  """

  Color of preview range overlay

  """

  sound_strips: typing.Tuple[float, float, float] = ...

  """

  Sound Strip - Unselected (for timing speaker sounds)

  """

  sound_strips_selected: typing.Tuple[float, float, float] = ...

  """

  Sound Strip - Selected (for timing speaker sounds)

  """

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  space_list: ThemeSpaceListGeneric = ...

  """

  Settings for space list

  """

  strips: typing.Tuple[float, float, float] = ...

  """

  Action-Clip Strip - Unselected

  """

  strips_selected: typing.Tuple[float, float, float] = ...

  """

  Action-Clip Strip - Selected

  """

  time_marker_line: typing.Tuple[float, float, float, float] = ...

  time_marker_line_selected: typing.Tuple[float, float, float, float] = ...

  time_scrub_background: typing.Tuple[float, float, float, float] = ...

  transition_strips: typing.Tuple[float, float, float] = ...

  """

  Transition Strip - Unselected

  """

  transition_strips_selected: typing.Tuple[float, float, float] = ...

  """

  Transition Strip - Selected

  """

  tweak: typing.Tuple[float, float, float] = ...

  """

  Color for strip/action being 'tweaked' or edited

  """

  tweak_duplicate: typing.Tuple[float, float, float] = ...

  """

  Warning/error indicator color for strips referencing the strip being tweaked

  """

  view_sliders: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeNodeEditor(bpy_struct):

  """

  Theme settings for the Node Editor

  """

  color_node: typing.Tuple[float, float, float] = ...

  converter_node: typing.Tuple[float, float, float] = ...

  distor_node: typing.Tuple[float, float, float] = ...

  filter_node: typing.Tuple[float, float, float] = ...

  frame_node: typing.Tuple[float, float, float, float] = ...

  grid: typing.Tuple[float, float, float] = ...

  grid_levels: int = ...

  """

  Amount of grid lines displayed in the background

  """

  group_node: typing.Tuple[float, float, float, float] = ...

  group_socket_node: typing.Tuple[float, float, float] = ...

  input_node: typing.Tuple[float, float, float] = ...

  layout_node: typing.Tuple[float, float, float] = ...

  matte_node: typing.Tuple[float, float, float] = ...

  node_active: typing.Tuple[float, float, float] = ...

  node_backdrop: typing.Tuple[float, float, float, float] = ...

  node_selected: typing.Tuple[float, float, float] = ...

  noodle_curving: int = ...

  """

  Curving of the noodle

  """

  output_node: typing.Tuple[float, float, float] = ...

  pattern_node: typing.Tuple[float, float, float] = ...

  script_node: typing.Tuple[float, float, float] = ...

  selected_text: typing.Tuple[float, float, float] = ...

  shader_node: typing.Tuple[float, float, float] = ...

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  space_list: ThemeSpaceListGeneric = ...

  """

  Settings for space list

  """

  texture_node: typing.Tuple[float, float, float] = ...

  vector_node: typing.Tuple[float, float, float] = ...

  wire: typing.Tuple[float, float, float] = ...

  wire_inner: typing.Tuple[float, float, float] = ...

  wire_select: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeOutliner(bpy_struct):

  """

  Theme settings for the Outliner

  """

  active: typing.Tuple[float, float, float] = ...

  active_object: typing.Tuple[float, float, float] = ...

  edited_object: typing.Tuple[float, float, float, float] = ...

  match: typing.Tuple[float, float, float] = ...

  row_alternate: typing.Tuple[float, float, float, float] = ...

  """

  Overlay color on every other row

  """

  selected_highlight: typing.Tuple[float, float, float] = ...

  selected_object: typing.Tuple[float, float, float] = ...

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemePanelColors(bpy_struct):

  """

  Theme settings for panel colors

  """

  back: typing.Tuple[float, float, float, float] = ...

  header: typing.Tuple[float, float, float, float] = ...

  sub_back: typing.Tuple[float, float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemePreferences(bpy_struct):

  """

  Theme settings for the Blender Preferences

  """

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeProperties(bpy_struct):

  """

  Theme settings for the Properties

  """

  match: typing.Tuple[float, float, float] = ...

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeSequenceEditor(bpy_struct):

  """

  Theme settings for the Sequence Editor

  """

  active_strip: typing.Tuple[float, float, float] = ...

  audio_strip: typing.Tuple[float, float, float] = ...

  color_strip: typing.Tuple[float, float, float] = ...

  draw_action: typing.Tuple[float, float, float] = ...

  effect_strip: typing.Tuple[float, float, float] = ...

  frame_current: typing.Tuple[float, float, float] = ...

  grid: typing.Tuple[float, float, float] = ...

  image_strip: typing.Tuple[float, float, float] = ...

  keyframe: typing.Tuple[float, float, float] = ...

  mask_strip: typing.Tuple[float, float, float] = ...

  meta_strip: typing.Tuple[float, float, float] = ...

  metadatabg: typing.Tuple[float, float, float] = ...

  metadatatext: typing.Tuple[float, float, float] = ...

  movie_strip: typing.Tuple[float, float, float] = ...

  movieclip_strip: typing.Tuple[float, float, float] = ...

  preview_back: typing.Tuple[float, float, float] = ...

  preview_range: typing.Tuple[float, float, float, float] = ...

  """

  Color of preview range overlay

  """

  scene_strip: typing.Tuple[float, float, float] = ...

  selected_strip: typing.Tuple[float, float, float] = ...

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  text_strip: typing.Tuple[float, float, float] = ...

  time_marker_line: typing.Tuple[float, float, float, float] = ...

  time_marker_line_selected: typing.Tuple[float, float, float, float] = ...

  time_scrub_background: typing.Tuple[float, float, float, float] = ...

  window_sliders: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeSpaceGeneric(bpy_struct):

  back: typing.Tuple[float, float, float] = ...

  button: typing.Tuple[float, float, float, float] = ...

  button_text: typing.Tuple[float, float, float] = ...

  button_text_hi: typing.Tuple[float, float, float] = ...

  button_title: typing.Tuple[float, float, float] = ...

  execution_buts: typing.Tuple[float, float, float, float] = ...

  header: typing.Tuple[float, float, float, float] = ...

  header_text: typing.Tuple[float, float, float] = ...

  header_text_hi: typing.Tuple[float, float, float] = ...

  navigation_bar: typing.Tuple[float, float, float, float] = ...

  panelcolors: ThemePanelColors = ...

  tab_active: typing.Tuple[float, float, float] = ...

  tab_back: typing.Tuple[float, float, float, float] = ...

  tab_inactive: typing.Tuple[float, float, float] = ...

  tab_outline: typing.Tuple[float, float, float] = ...

  text: typing.Tuple[float, float, float] = ...

  text_hi: typing.Tuple[float, float, float] = ...

  title: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeSpaceGradient(bpy_struct):

  button: typing.Tuple[float, float, float, float] = ...

  button_text: typing.Tuple[float, float, float] = ...

  button_text_hi: typing.Tuple[float, float, float] = ...

  button_title: typing.Tuple[float, float, float] = ...

  execution_buts: typing.Tuple[float, float, float, float] = ...

  gradients: ThemeGradientColors = ...

  header: typing.Tuple[float, float, float, float] = ...

  header_text: typing.Tuple[float, float, float] = ...

  header_text_hi: typing.Tuple[float, float, float] = ...

  navigation_bar: typing.Tuple[float, float, float, float] = ...

  panelcolors: ThemePanelColors = ...

  tab_active: typing.Tuple[float, float, float] = ...

  tab_back: typing.Tuple[float, float, float, float] = ...

  tab_inactive: typing.Tuple[float, float, float] = ...

  tab_outline: typing.Tuple[float, float, float] = ...

  text: typing.Tuple[float, float, float] = ...

  text_hi: typing.Tuple[float, float, float] = ...

  title: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeSpaceListGeneric(bpy_struct):

  list: typing.Tuple[float, float, float] = ...

  list_text: typing.Tuple[float, float, float] = ...

  list_text_hi: typing.Tuple[float, float, float] = ...

  list_title: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeStatusBar(bpy_struct):

  """

  Theme settings for the Status Bar

  """

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeStyle(bpy_struct):

  """

  Theme settings for style sets

  """

  panel_title: ThemeFontStyle = ...

  widget: ThemeFontStyle = ...

  widget_label: ThemeFontStyle = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeTextEditor(bpy_struct):

  """

  Theme settings for the Text Editor

  """

  cursor: typing.Tuple[float, float, float] = ...

  line_numbers: typing.Tuple[float, float, float] = ...

  line_numbers_background: typing.Tuple[float, float, float] = ...

  selected_text: typing.Tuple[float, float, float] = ...

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  syntax_builtin: typing.Tuple[float, float, float] = ...

  syntax_comment: typing.Tuple[float, float, float] = ...

  syntax_numbers: typing.Tuple[float, float, float] = ...

  syntax_preprocessor: typing.Tuple[float, float, float] = ...

  syntax_reserved: typing.Tuple[float, float, float] = ...

  syntax_special: typing.Tuple[float, float, float] = ...

  syntax_string: typing.Tuple[float, float, float] = ...

  syntax_symbols: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeTopBar(bpy_struct):

  """

  Theme settings for the Top Bar

  """

  space: ThemeSpaceGeneric = ...

  """

  Settings for space

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeUserInterface(bpy_struct):

  """

  Theme settings for user interface elements

  """

  axis_x: typing.Tuple[float, float, float] = ...

  axis_y: typing.Tuple[float, float, float] = ...

  axis_z: typing.Tuple[float, float, float] = ...

  editor_outline: typing.Tuple[float, float, float] = ...

  """

  Color of the outline of the editors and their round corners

  """

  gizmo_a: typing.Tuple[float, float, float] = ...

  gizmo_b: typing.Tuple[float, float, float] = ...

  gizmo_hi: typing.Tuple[float, float, float] = ...

  gizmo_primary: typing.Tuple[float, float, float] = ...

  gizmo_secondary: typing.Tuple[float, float, float] = ...

  gizmo_view_align: typing.Tuple[float, float, float] = ...

  icon_alpha: float = ...

  """

  Transparency of icons in the interface, to reduce contrast

  """

  icon_border_intensity: float = ...

  """

  Control the intensity of the border around themes icons

  """

  icon_collection: typing.Tuple[float, float, float, float] = ...

  icon_folder: typing.Tuple[float, float, float, float] = ...

  """

  Color of folders in the file browser

  """

  icon_modifier: typing.Tuple[float, float, float, float] = ...

  icon_object: typing.Tuple[float, float, float, float] = ...

  icon_object_data: typing.Tuple[float, float, float, float] = ...

  icon_saturation: float = ...

  """

  Saturation of icons in the interface

  """

  icon_scene: typing.Tuple[float, float, float, float] = ...

  icon_shading: typing.Tuple[float, float, float, float] = ...

  menu_shadow_fac: float = ...

  """

  Blending factor for menu shadows

  """

  menu_shadow_width: int = ...

  """

  Width of menu shadows, set to zero to disable

  """

  transparent_checker_primary: typing.Tuple[float, float, float] = ...

  """

  Primary color of checkerboard pattern indicating transparent areas

  """

  transparent_checker_secondary: typing.Tuple[float, float, float] = ...

  """

  Secondary color of checkerboard pattern indicating transparent areas

  """

  transparent_checker_size: int = ...

  """

  Size of checkerboard pattern indicating transparent areas

  """

  wcol_box: ThemeWidgetColors = ...

  wcol_list_item: ThemeWidgetColors = ...

  wcol_menu: ThemeWidgetColors = ...

  wcol_menu_back: ThemeWidgetColors = ...

  wcol_menu_item: ThemeWidgetColors = ...

  wcol_num: ThemeWidgetColors = ...

  wcol_numslider: ThemeWidgetColors = ...

  wcol_option: ThemeWidgetColors = ...

  wcol_pie_menu: ThemeWidgetColors = ...

  wcol_progress: ThemeWidgetColors = ...

  wcol_pulldown: ThemeWidgetColors = ...

  wcol_radio: ThemeWidgetColors = ...

  wcol_regular: ThemeWidgetColors = ...

  wcol_scroll: ThemeWidgetColors = ...

  wcol_state: ThemeWidgetStateColors = ...

  wcol_tab: ThemeWidgetColors = ...

  wcol_text: ThemeWidgetColors = ...

  wcol_toggle: ThemeWidgetColors = ...

  wcol_tool: ThemeWidgetColors = ...

  wcol_toolbar_item: ThemeWidgetColors = ...

  wcol_tooltip: ThemeWidgetColors = ...

  widget_emboss: typing.Tuple[float, float, float, float] = ...

  """

  Color of the 1px shadow line underlying widgets

  """

  widget_text_cursor: typing.Tuple[float, float, float] = ...

  """

  Color of the interface widgets text insertion cursor (caret)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeView3D(bpy_struct):

  """

  Theme settings for the 3D View

  """

  act_spline: typing.Tuple[float, float, float] = ...

  bone_locked_weight: typing.Tuple[float, float, float, float] = ...

  """

  Shade for bones corresponding to a locked weight group during painting

  """

  bone_pose: typing.Tuple[float, float, float] = ...

  bone_pose_active: typing.Tuple[float, float, float] = ...

  bone_solid: typing.Tuple[float, float, float] = ...

  bundle_solid: typing.Tuple[float, float, float] = ...

  camera: typing.Tuple[float, float, float] = ...

  camera_path: typing.Tuple[float, float, float] = ...

  clipping_border_3d: typing.Tuple[float, float, float, float] = ...

  edge_bevel: typing.Tuple[float, float, float] = ...

  edge_crease: typing.Tuple[float, float, float] = ...

  edge_facesel: typing.Tuple[float, float, float] = ...

  edge_seam: typing.Tuple[float, float, float] = ...

  edge_select: typing.Tuple[float, float, float] = ...

  edge_sharp: typing.Tuple[float, float, float] = ...

  editmesh_active: typing.Tuple[float, float, float, float] = ...

  empty: typing.Tuple[float, float, float] = ...

  extra_edge_angle: typing.Tuple[float, float, float] = ...

  extra_edge_len: typing.Tuple[float, float, float] = ...

  extra_face_angle: typing.Tuple[float, float, float] = ...

  extra_face_area: typing.Tuple[float, float, float] = ...

  face: typing.Tuple[float, float, float, float] = ...

  face_back: typing.Tuple[float, float, float, float] = ...

  face_dot: typing.Tuple[float, float, float] = ...

  face_front: typing.Tuple[float, float, float, float] = ...

  face_select: typing.Tuple[float, float, float, float] = ...

  facedot_size: int = ...

  frame_current: typing.Tuple[float, float, float] = ...

  freestyle_edge_mark: typing.Tuple[float, float, float] = ...

  freestyle_face_mark: typing.Tuple[float, float, float, float] = ...

  gp_vertex: typing.Tuple[float, float, float] = ...

  gp_vertex_select: typing.Tuple[float, float, float] = ...

  gp_vertex_size: int = ...

  grid: typing.Tuple[float, float, float, float] = ...

  handle_align: typing.Tuple[float, float, float] = ...

  handle_auto: typing.Tuple[float, float, float] = ...

  handle_free: typing.Tuple[float, float, float] = ...

  handle_sel_align: typing.Tuple[float, float, float] = ...

  handle_sel_auto: typing.Tuple[float, float, float] = ...

  handle_sel_free: typing.Tuple[float, float, float] = ...

  handle_sel_vect: typing.Tuple[float, float, float] = ...

  handle_vect: typing.Tuple[float, float, float] = ...

  lastsel_point: typing.Tuple[float, float, float] = ...

  light: typing.Tuple[float, float, float, float] = ...

  normal: typing.Tuple[float, float, float] = ...

  nurb_sel_uline: typing.Tuple[float, float, float] = ...

  nurb_sel_vline: typing.Tuple[float, float, float] = ...

  nurb_uline: typing.Tuple[float, float, float] = ...

  nurb_vline: typing.Tuple[float, float, float] = ...

  object_active: typing.Tuple[float, float, float] = ...

  object_origin_size: int = ...

  """

  Diameter in Pixels for Object/Light origin display

  """

  object_selected: typing.Tuple[float, float, float] = ...

  outline_width: int = ...

  paint_curve_handle: typing.Tuple[float, float, float, float] = ...

  paint_curve_pivot: typing.Tuple[float, float, float, float] = ...

  skin_root: typing.Tuple[float, float, float] = ...

  space: ThemeSpaceGradient = ...

  """

  Settings for space

  """

  speaker: typing.Tuple[float, float, float] = ...

  split_normal: typing.Tuple[float, float, float] = ...

  text_grease_pencil: typing.Tuple[float, float, float] = ...

  """

  Color for indicating Grease Pencil keyframes

  """

  text_keyframe: typing.Tuple[float, float, float] = ...

  """

  Color for indicating Object keyframes

  """

  transform: typing.Tuple[float, float, float] = ...

  vertex: typing.Tuple[float, float, float] = ...

  vertex_active: typing.Tuple[float, float, float] = ...

  vertex_bevel: typing.Tuple[float, float, float] = ...

  vertex_normal: typing.Tuple[float, float, float] = ...

  vertex_select: typing.Tuple[float, float, float] = ...

  vertex_size: int = ...

  vertex_unreferenced: typing.Tuple[float, float, float] = ...

  view_overlay: typing.Tuple[float, float, float] = ...

  wire: typing.Tuple[float, float, float] = ...

  wire_edit: typing.Tuple[float, float, float] = ...

  """

  Color for wireframe when in edit mode, but edge selection is active

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeWidgetColors(bpy_struct):

  """

  Theme settings for widget color sets

  """

  inner: typing.Tuple[float, float, float, float] = ...

  inner_sel: typing.Tuple[float, float, float, float] = ...

  item: typing.Tuple[float, float, float, float] = ...

  outline: typing.Tuple[float, float, float] = ...

  roundness: float = ...

  """

  Amount of edge rounding

  """

  shadedown: int = ...

  shadetop: int = ...

  show_shaded: bool = ...

  text: typing.Tuple[float, float, float] = ...

  text_sel: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThemeWidgetStateColors(bpy_struct):

  """

  Theme settings for widget state colors

  """

  blend: float = ...

  inner_anim: typing.Tuple[float, float, float] = ...

  inner_anim_sel: typing.Tuple[float, float, float] = ...

  inner_changed: typing.Tuple[float, float, float] = ...

  inner_changed_sel: typing.Tuple[float, float, float] = ...

  inner_driven: typing.Tuple[float, float, float] = ...

  inner_driven_sel: typing.Tuple[float, float, float] = ...

  inner_key: typing.Tuple[float, float, float] = ...

  inner_key_sel: typing.Tuple[float, float, float] = ...

  inner_overridden: typing.Tuple[float, float, float] = ...

  inner_overridden_sel: typing.Tuple[float, float, float] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TimelineMarker(bpy_struct):

  """

  Marker for noting points in the timeline

  """

  camera: Object = ...

  """

  Camera that becomes active on this frame

  """

  frame: int = ...

  """

  The frame on which the timeline marker appears

  """

  name: str = ...

  select: bool = ...

  """

  Marker selection state

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TimelineMarkers(bpy_struct):

  """

  Collection of timeline markers

  """

  def new(self, name: str, frame: int = 1) -> TimelineMarker:

    """

    Add a keyframe to the curve

    """

    ...

  def remove(self, marker: TimelineMarker) -> None:

    """

    Remove a timeline marker

    """

    ...

  def clear(self) -> None:

    """

    Remove all timeline markers

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Timer(bpy_struct):

  """

  Window event timer

  """

  time_delta: float = ...

  """

  Time since last step in seconds

  """

  time_duration: float = ...

  """

  Time since last step in seconds

  """

  time_step: float = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ToolSettings(bpy_struct):

  annotation_stroke_placement_image_editor: str = ...

  """

  * ``CURSOR``
3D Cursor, Draw stroke at 3D cursor location.

  * ``VIEW``
View, Stick stroke to the view.

  * ``SURFACE``
Surface, Stick stroke to surfaces.

  """

  annotation_stroke_placement_sequencer_preview: str = ...

  """

  * ``CURSOR``
3D Cursor, Draw stroke at 3D cursor location.

  * ``VIEW``
View, Stick stroke to the view.

  * ``SURFACE``
Surface, Stick stroke to surfaces.

  """

  annotation_stroke_placement_view2d: str = ...

  """

  * ``CURSOR``
3D Cursor, Draw stroke at 3D cursor location.

  * ``VIEW``
View, Stick stroke to the view.

  * ``SURFACE``
Surface, Stick stroke to surfaces.

  """

  annotation_stroke_placement_view3d: str = ...

  """

  How annotation strokes are orientated in 3D space

  * ``CURSOR``
3D Cursor, Draw stroke at 3D cursor location.

  * ``VIEW``
View, Stick stroke to the view.

  * ``SURFACE``
Surface, Stick stroke to surfaces.

  """

  annotation_thickness: int = ...

  """

  Thickness of annotation strokes

  """

  auto_keying_mode: str = ...

  """

  Mode of automatic keyframe insertion for Objects, Bones and Masks

  """

  curve_paint_settings: CurvePaintSettings = ...

  custom_bevel_profile_preset: CurveProfile = ...

  """

  Used for defining a profile's path

  """

  double_threshold: float = ...

  """

  Threshold distance for Auto Merge

  """

  gpencil_interpolate: GPencilInterpolateSettings = ...

  """

  Settings for Grease Pencil Interpolation tools

  """

  gpencil_paint: GpPaint = ...

  gpencil_sculpt: GPencilSculptSettings = ...

  """

  Settings for stroke sculpting tools and brushes

  """

  gpencil_sculpt_paint: GpSculptPaint = ...

  gpencil_selectmode_edit: str = ...

  """

  * ``POINT``
Point, Select only points.

  * ``STROKE``
Stroke, Select all stroke points.

  * ``SEGMENT``
Segment, Select all stroke points between other strokes.

  """

  gpencil_stroke_placement_view3d: str = ...

  """

  * ``ORIGIN``
Origin, Draw stroke at Object origin.

  * ``CURSOR``
3D Cursor, Draw stroke at 3D cursor location.

  * ``SURFACE``
Surface, Stick stroke to surfaces.

  * ``STROKE``
Stroke, Stick stroke to other strokes.

  """

  gpencil_stroke_snap_mode: str = ...

  """

  * ``NONE``
All points, Snap to all points.

  * ``ENDS``
End points, Snap to first and last points and interpolate.

  * ``FIRST``
First point, Snap to first point.

  """

  gpencil_vertex_paint: GpVertexPaint = ...

  gpencil_weight_paint: GpWeightPaint = ...

  image_paint: ImagePaint = ...

  keyframe_type: str = ...

  """

  Type of keyframes to create when inserting keyframes

  * ``KEYFRAME``
Keyframe, Normal keyframe - e.g. for key poses.

  * ``BREAKDOWN``
Breakdown, A breakdown pose - e.g. for transitions between key poses.

  * ``MOVING_HOLD``
Moving Hold, A keyframe that is part of a moving hold.

  * ``EXTREME``
Extreme, An 'extreme' pose, or some other purpose as needed.

  * ``JITTER``
Jitter, A filler or baked keyframe for keying on ones, or some other purpose as needed.

  """

  lock_markers: bool = ...

  """

  Prevent marker editing

  """

  lock_object_mode: bool = ...

  """

  Restrict select to the current mode

  """

  mesh_select_mode: typing.Tuple[bool, bool, bool] = ...

  """

  Which mesh elements selection works on

  """

  normal_vector: typing.Tuple[float, float, float] = ...

  """

  Normal Vector used to copy, add or multiply

  """

  particle_edit: ParticleEdit = ...

  proportional_edit_falloff: str = ...

  """

  Falloff type for proportional editing mode

  * ``SMOOTH``
Smooth, Smooth falloff.

  * ``SPHERE``
Sphere, Spherical falloff.

  * ``ROOT``
Root, Root falloff.

  * ``INVERSE_SQUARE``
Inverse Square, Inverse Square falloff.

  * ``SHARP``
Sharp, Sharp falloff.

  * ``LINEAR``
Linear, Linear falloff.

  * ``CONSTANT``
Constant, Constant falloff.

  * ``RANDOM``
Random, Random falloff.

  """

  proportional_size: float = ...

  """

  Display size for proportional editing circle

  """

  sculpt: Sculpt = ...

  show_uv_local_view: bool = ...

  """

  Display only faces with the currently displayed image assigned

  """

  snap_elements: typing.Set[str] = ...

  """

  Type of element to snap to

  * ``INCREMENT``
Increment, Snap to increments of grid.

  * ``VERTEX``
Vertex, Snap to vertices.

  * ``EDGE``
Edge, Snap to edges.

  * ``FACE``
Face, Snap to faces.

  * ``VOLUME``
Volume, Snap to volume.

  * ``EDGE_MIDPOINT``
Edge Center, Snap to the middle of edges.

  * ``EDGE_PERPENDICULAR``
Edge Perpendicular, Snap to the nearest point on an edge.

  """

  snap_node_element: str = ...

  """

  Type of element to snap to

  * ``GRID``
Grid, Snap to grid.

  * ``NODE_X``
Node X, Snap to left/right node border.

  * ``NODE_Y``
Node Y, Snap to top/bottom node border.

  * ``NODE_XY``
Node X / Y, Snap to any node border.

  """

  snap_target: str = ...

  """

  Which part to snap onto the target

  * ``CLOSEST``
Closest, Snap closest point onto target.

  * ``CENTER``
Center, Snap transformation center onto target.

  * ``MEDIAN``
Median, Snap median onto target.

  * ``ACTIVE``
Active, Snap active onto target.

  """

  snap_uv_element: str = ...

  """

  Type of element to snap to

  * ``INCREMENT``
Increment, Snap to increments of grid.

  * ``VERTEX``
Vertex, Snap to vertices.

  """

  statvis: MeshStatVis = ...

  transform_pivot_point: str = ...

  """

  Pivot center for rotation/scaling

  * ``BOUNDING_BOX_CENTER``
Bounding Box Center, Pivot around bounding box center of selected object(s).

  * ``CURSOR``
3D Cursor, Pivot around the 3D cursor.

  * ``INDIVIDUAL_ORIGINS``
Individual Origins, Pivot around each object's own origin.

  * ``MEDIAN_POINT``
Median Point, Pivot around the median point of selected objects.

  * ``ACTIVE_ELEMENT``
Active Element, Pivot around active object.

  """

  unified_paint_settings: UnifiedPaintSettings = ...

  use_auto_normalize: bool = ...

  """

  Ensure all bone-deforming vertex groups add up to 1.0 while weight painting

  """

  use_edge_path_live_unwrap: bool = ...

  """

  Changing edge seams recalculates UV unwrap

  """

  use_gpencil_draw_additive: bool = ...

  """

  When creating new frames, the strokes from the previous/active frame are included as the basis for the new one

  """

  use_gpencil_draw_onback: bool = ...

  """

  When draw new strokes, the new stroke is drawn below of all strokes in the layer

  """

  use_gpencil_select_mask_point: bool = ...

  """

  Only sculpt selected stroke points

  """

  use_gpencil_select_mask_segment: bool = ...

  """

  Only sculpt selected stroke points between other strokes

  """

  use_gpencil_select_mask_stroke: bool = ...

  """

  Only sculpt selected stroke

  """

  use_gpencil_stroke_endpoints: bool = ...

  """

  Only use the first and last parts of the stroke for snapping

  """

  use_gpencil_thumbnail_list: bool = ...

  """

  Show compact list of color instead of thumbnails

  """

  use_gpencil_vertex_select_mask_point: bool = ...

  """

  Only paint selected stroke points

  """

  use_gpencil_vertex_select_mask_segment: bool = ...

  """

  Only paint selected stroke points between other strokes

  """

  use_gpencil_vertex_select_mask_stroke: bool = ...

  """

  Only paint selected stroke

  """

  use_gpencil_weight_data_add: bool = ...

  """

  When creating new strokes, the weight data is added according to the current vertex group and weight, if no vertex group selected, weight is not added

  """

  use_keyframe_cycle_aware: bool = ...

  """

  For channels with cyclic extrapolation, keyframe insertion is automatically remapped inside the cycle time range, and keeps ends in sync

  """

  use_keyframe_insert_auto: bool = ...

  """

  Automatic keyframe insertion for Objects, Bones and Masks

  """

  use_keyframe_insert_keyingset: bool = ...

  """

  Automatic keyframe insertion using active Keying Set only

  """

  use_lock_relative: bool = ...

  """

  Display bone-deforming groups as if all locked deform groups were deleted, and the remaining ones were re-normalized

  """

  use_mesh_automerge: bool = ...

  """

  Automatically merge vertices moved to the same location

  """

  use_mesh_automerge_and_split: bool = ...

  """

  Automatically split edges and faces

  """

  use_multipaint: bool = ...

  """

  Paint across the weights of all selected bones, maintaining their relative influence

  """

  use_proportional_action: bool = ...

  """

  Proportional editing in action editor

  """

  use_proportional_connected: bool = ...

  """

  Proportional Editing using connected geometry only

  """

  use_proportional_edit: bool = ...

  """

  Proportional edit mode

  """

  use_proportional_edit_mask: bool = ...

  """

  Proportional editing mask mode

  """

  use_proportional_edit_objects: bool = ...

  """

  Proportional editing object mode

  """

  use_proportional_fcurve: bool = ...

  """

  Proportional editing in FCurve editor

  """

  use_proportional_projected: bool = ...

  """

  Proportional Editing using screen space locations

  """

  use_record_with_nla: bool = ...

  """

  Add a new NLA Track + Strip for every loop/pass made over the animation to allow non-destructive tweaking

  """

  use_snap: bool = ...

  """

  Snap during transform

  """

  use_snap_align_rotation: bool = ...

  """

  Align rotation with the snapping target

  """

  use_snap_backface_culling: bool = ...

  """

  Exclude back facing geometry from snapping

  """

  use_snap_grid_absolute: bool = ...

  """

  Absolute grid alignment while translating (based on the pivot center)

  """

  use_snap_peel_object: bool = ...

  """

  Consider objects as whole when finding volume center

  """

  use_snap_project: bool = ...

  """

  Project individual elements on the surface of other objects

  """

  use_snap_rotate: bool = ...

  """

  Rotate is affected by the snapping settings

  """

  use_snap_scale: bool = ...

  """

  Scale is affected by snapping settings

  """

  use_snap_self: bool = ...

  """

  Snap onto itself (Edit Mode Only)

  """

  use_snap_translate: bool = ...

  """

  Move is affected by snapping settings

  """

  use_transform_correct_face_attributes: bool = ...

  """

  Correct data such as UV's and vertex colors when transforming

  """

  use_transform_correct_keep_connected: bool = ...

  """

  During the Face Attributes correction, merge attributes connected to the same vertex

  """

  use_transform_data_origin: bool = ...

  """

  Transform object origins, while leaving the shape in place

  """

  use_transform_pivot_point_align: bool = ...

  """

  Only transform object locations, without affecting rotation or scaling

  """

  use_transform_skip_children: bool = ...

  """

  Transform the parents, leaving the children in place

  """

  use_uv_select_sync: bool = ...

  """

  Keep UV and edit mode mesh selection in sync

  """

  uv_relax_method: str = ...

  """

  Algorithm used for UV relaxation

  * ``LAPLACIAN``
Laplacian, Use Laplacian method for relaxation.

  * ``HC``
HC, Use HC method for relaxation.

  """

  uv_sculpt: UvSculpt = ...

  uv_sculpt_all_islands: bool = ...

  """

  Brush operates on all islands

  """

  uv_sculpt_lock_borders: bool = ...

  """

  Disable editing of boundary edges

  """

  uv_select_mode: str = ...

  """

  UV selection and display mode

  * ``VERTEX``
Vertex, Vertex selection mode.

  * ``EDGE``
Edge, Edge selection mode.

  * ``FACE``
Face, Face selection mode.

  * ``ISLAND``
Island, Island selection mode.

  """

  vertex_group_subset: str = ...

  """

  Filter Vertex groups for Display

  * ``ALL``
All, All Vertex Groups.

  * ``BONE_DEFORM``
Deform, Vertex Groups assigned to Deform Bones.

  * ``OTHER_DEFORM``
Other, Vertex Groups assigned to non Deform Bones.

  """

  vertex_group_user: str = ...

  """

  Display unweighted vertices

  * ``NONE``
None.

  * ``ACTIVE``
Active, Show vertices with no weights in the active group.

  * ``ALL``
All, Show vertices with no weights in any group.

  """

  vertex_group_weight: float = ...

  """

  Weight to assign in vertex groups

  """

  vertex_paint: VertexPaint = ...

  weight_paint: VertexPaint = ...

  workspace_tool_type: str = ...

  """

  Action when dragging in the viewport

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TransformOrientation(bpy_struct):

  matrix: typing.Tuple[typing.Tuple[float, float, float], typing.Tuple[float, float, float], typing.Tuple[float, float, float]] = ...

  name: str = ...

  """

  Name of the custom transform orientation

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TransformOrientationSlot(bpy_struct):

  custom_orientation: TransformOrientation = ...

  type: str = ...

  """

  Transformation orientation

  * ``GLOBAL``
Global, Align the transformation axes to world space.

  * ``LOCAL``
Local, Align the transformation axes to the selected objects' local space.

  * ``NORMAL``
Normal, Align the transformation axes to average normal of selected elements (bone Y axis for pose mode).

  * ``GIMBAL``
Gimbal, Align each axis to the Euler rotation axis as used for input.

  * ``VIEW``
View, Align the transformation axes to the window.

  * ``CURSOR``
Cursor, Align the transformation axes to the 3D cursor.

  """

  use: bool = ...

  """

  Use scene orientation instead of a custom setting

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UDIMTile(bpy_struct):

  """

  Properties of the UDIM tile

  """

  label: str = ...

  """

  Tile label

  """

  number: int = ...

  """

  Number of the position that this tile covers

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UDIMTiles(bpy_struct):

  """

  Collection of UDIM tiles

  """

  active: UDIMTile = ...

  """

  Active Image Tile

  """

  active_index: int = ...

  """

  Active index in tiles array

  """

  def new(self, tile_number: int, label: str = '') -> UDIMTile:

    """

    Add a tile to the image

    """

    ...

  def get(self, tile_number: int) -> UDIMTile:

    """

    Get a tile based on its tile number

    """

    ...

  def remove(self, tile: UDIMTile) -> None:

    """

    Remove an image tile

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UILayout(bpy_struct):

  """

  User interface layout in a panel or header

  """

  activate_init: bool = ...

  """

  When true, buttons defined in popups will be activated on first display (use so you can type into a field without having to click on it first)

  """

  active: bool = ...

  active_default: bool = ...

  """

  When true, an operator button defined after this will be activated when pressing return(use with popup dialogs)

  """

  alert: bool = ...

  alignment: str = ...

  direction: str = ...

  emboss: str = ...

  """

  * ``NORMAL``
Regular, Draw standard button emboss style.

  * ``NONE``
None, Draw only text and icons.

  * ``PULLDOWN_MENU``
Pulldown Menu, Draw pulldown menu style.

  * ``RADIAL_MENU``
Radial Menu, Draw radial menu style.

  """

  enabled: bool = ...

  """

  When false, this (sub)layout is grayed out

  """

  operator_context: str = ...

  scale_x: float = ...

  """

  Scale factor along the X for items in this (sub)layout

  """

  scale_y: float = ...

  """

  Scale factor along the Y for items in this (sub)layout

  """

  ui_units_x: float = ...

  """

  Fixed Size along the X for items in this (sub)layout

  """

  ui_units_y: float = ...

  """

  Fixed Size along the Y for items in this (sub)layout

  """

  use_property_decorate: bool = ...

  use_property_split: bool = ...

  def row(self, align: bool = False, heading: str = '', heading_ctxt: str = '', translate: bool = True) -> UILayout:

    """

    Sub-layout. Items placed in this sublayout are placed next to each other in a row

    """

    ...

  def column(self, align: bool = False, heading: str = '', heading_ctxt: str = '', translate: bool = True) -> UILayout:

    """

    Sub-layout. Items placed in this sublayout are placed under each other in a column

    """

    ...

  def column_flow(self, columns: int = 0, align: bool = False) -> UILayout:

    """

    column_flow

    """

    ...

  def grid_flow(self, row_major: bool = False, columns: int = 0, even_columns: bool = False, even_rows: bool = False, align: bool = False) -> UILayout:

    """

    grid_flow

    """

    ...

  def box(self) -> UILayout:

    """

    Sublayout (items placed in this sublayout are placed under each other in a column and are surrounded by a box)

    """

    ...

  def split(self, factor: float = 0.0, align: bool = False) -> UILayout:

    """

    split

    """

    ...

  def menu_pie(self) -> UILayout:

    """

    Sublayout. Items placed in this sublayout are placed in a radial fashion around the menu center)

    """

    ...

  @classmethod

  def icon(cls, data: typing.Any) -> int:

    """

    Return the custom icon for this data, use it e.g. to get materials or texture icons

    """

    ...

  @classmethod

  def enum_item_name(cls, data: typing.Any, property: str, identifier: str) -> str:

    """

    Return the UI name for this enum item

    """

    ...

  @classmethod

  def enum_item_description(cls, data: typing.Any, property: str, identifier: str) -> str:

    """

    Return the UI description for this enum item

    """

    ...

  @classmethod

  def enum_item_icon(cls, data: typing.Any, property: str, identifier: str) -> int:

    """

    Return the icon for this enum item

    """

    ...

  def prop(self, data: typing.Any, property: str, text: str = '', text_ctxt: str = '', translate: bool = True, icon: str = 'NONE', expand: bool = False, slider: bool = False, toggle: int = -1, icon_only: bool = False, event: bool = False, full_event: bool = False, emboss: bool = True, index: int = -1, icon_value: int = 0, invert_checkbox: bool = False) -> None:

    """

    Item. Exposes an RNA item and places it into the layout

    """

    ...

  def props_enum(self, data: typing.Any, property: str) -> None:

    """

    props_enum

    """

    ...

  def prop_menu_enum(self, data: typing.Any, property: str, text: str = '', text_ctxt: str = '', translate: bool = True, icon: str = 'NONE') -> None:

    """

    prop_menu_enum

    """

    ...

  def prop_tabs_enum(self, data: typing.Any, property: str, data_highlight: typing.Any = None, property_highlight: str = '', icon_only: bool = False) -> None:

    """

    prop_tabs_enum

    """

    ...

  def prop_enum(self, data: typing.Any, property: str, value: str, text: str = '', text_ctxt: str = '', translate: bool = True, icon: str = 'NONE') -> None:

    """

    prop_enum

    """

    ...

  def prop_search(self, data: typing.Any, property: str, search_data: typing.Any, search_property: str, text: str = '', text_ctxt: str = '', translate: bool = True, icon: str = 'NONE') -> None:

    """

    prop_search

    """

    ...

  def prop_decorator(self, data: typing.Any, property: str, index: int = -1) -> None:

    """

    prop_decorator

    """

    ...

  def operator(self, operator: str, text: str = '', text_ctxt: str = '', translate: bool = True, icon: str = 'NONE', emboss: bool = True, depress: bool = False, icon_value: int = 0) -> OperatorProperties:

    """

    Item. Places a button into the layout to call an Operator

    """

    ...

  def operator_enum(self, operator: str, property: str, icon_only: bool = False) -> None:

    """

    operator_enum

    """

    ...

  def operator_menu_enum(self, operator: str, property: str, text: str = '', text_ctxt: str = '', translate: bool = True, icon: str = 'NONE') -> None:

    """

    operator_menu_enum

    """

    ...

  def label(self, text: str = '', text_ctxt: str = '', translate: bool = True, icon: str = 'NONE', icon_value: int = 0) -> None:

    """

    Item. Displays text and/or icon in the layout

    """

    ...

  def menu(self, menu: str, text: str = '', text_ctxt: str = '', translate: bool = True, icon: str = 'NONE', icon_value: int = 0) -> None:

    """

    menu

    """

    ...

  def menu_contents(self, menu: str) -> None:

    """

    menu_contents

    """

    ...

  def popover(self, panel: str, text: str = '', text_ctxt: str = '', translate: bool = True, icon: str = 'NONE', icon_value: int = 0) -> None:

    """

    popover

    """

    ...

  def popover_group(self, space_type: str, region_type: str, context: str, category: str) -> None:

    """

    popover_group

    """

    ...

  def separator(self, factor: float = 1.0) -> None:

    """

    Item. Inserts empty space into the layout between items

    """

    ...

  def separator_spacer(self) -> None:

    """

    Item. Inserts horizontal spacing empty space into the layout between items

    """

    ...

  def context_pointer_set(self, name: str, data: typing.Any) -> None:

    """

    context_pointer_set

    """

    ...

  def template_header(self) -> None:

    """

    Inserts common Space header UI (editor type selector)

    """

    ...

  def template_ID(self, data: typing.Any, property: str, new: str = '', open: str = '', unlink: str = '', filter: str = 'ALL', live_icon: bool = False, text: str = '', text_ctxt: str = '', translate: bool = True) -> None:

    """

    template_ID

    """

    ...

  def template_ID_preview(self, data: typing.Any, property: str, new: str = '', open: str = '', unlink: str = '', rows: int = 0, cols: int = 0, filter: str = 'ALL', hide_buttons: bool = False) -> None:

    """

    template_ID_preview

    """

    ...

  def template_any_ID(self, data: typing.Any, property: str, type_property: str, text: str = '', text_ctxt: str = '', translate: bool = True) -> None:

    """

    template_any_ID

    """

    ...

  def template_ID_tabs(self, data: typing.Any, property: str, new: str = '', menu: str = '', filter: str = 'ALL') -> None:

    """

    template_ID_tabs

    """

    ...

  def template_search(self, data: typing.Any, property: str, search_data: typing.Any, search_property: str, new: str = '', unlink: str = '') -> None:

    """

    template_search

    """

    ...

  def template_search_preview(self, data: typing.Any, property: str, search_data: typing.Any, search_property: str, new: str = '', unlink: str = '', rows: int = 0, cols: int = 0) -> None:

    """

    template_search_preview

    """

    ...

  def template_path_builder(self, data: typing.Any, property: str, root: ID, text: str = '', text_ctxt: str = '', translate: bool = True) -> None:

    """

    template_path_builder

    """

    ...

  def template_modifiers(self) -> None:

    """

    Generates the UI layout for the modifier stack

    """

    ...

  def template_constraints(self, use_bone_constraints: bool = True) -> None:

    """

    Generates the panels for the constraint stack

    """

    ...

  def template_grease_pencil_modifiers(self) -> None:

    """

    Generates the panels for the grease pencil modifier stack

    """

    ...

  def template_shaderfx(self) -> None:

    """

    Generates the panels for the shader effect stack

    """

    ...

  def template_greasepencil_color(self, data: typing.Any, property: str, rows: int = 0, cols: int = 0, scale: float = 1.0, filter: str = 'ALL') -> None:

    """

    template_greasepencil_color

    """

    ...

  def template_constraint_header(self, data: Constraint) -> None:

    """

    Generates the header for constraint panels

    """

    ...

  def template_preview(self, id: ID, show_buttons: bool = True, parent: ID = None, slot: TextureSlot = None, preview_id: str = '') -> None:

    """

    Item. A preview window for materials, textures, lights or worlds

    """

    ...

  def template_curve_mapping(self, data: typing.Any, property: str, type: str = 'NONE', levels: bool = False, brush: bool = False, use_negative_slope: bool = False, show_tone: bool = False) -> None:

    """

    Item. A curve mapping widget used for e.g falloff curves for lights

    """

    ...

  def template_curveprofile(self, data: typing.Any, property: str) -> None:

    """

    A profile path editor used for custom profiles

    """

    ...

  def template_color_ramp(self, data: typing.Any, property: str, expand: bool = False) -> None:

    """

    Item. A color ramp widget

    """

    ...

  def template_icon(self, icon_value: int, scale: float = 1.0) -> None:

    """

    Display a large icon

    """

    ...

  def template_icon_view(self, data: typing.Any, property: str, show_labels: bool = False, scale: float = 6.0, scale_popup: float = 5.0) -> None:

    """

    Enum. Large widget showing Icon previews

    """

    ...

  def template_histogram(self, data: typing.Any, property: str) -> None:

    """

    Item. A histogramm widget to analyze imaga data

    """

    ...

  def template_waveform(self, data: typing.Any, property: str) -> None:

    """

    Item. A waveform widget to analyze imaga data

    """

    ...

  def template_vectorscope(self, data: typing.Any, property: str) -> None:

    """

    Item. A vectorscope widget to analyze imaga data

    """

    ...

  def template_layers(self, data: typing.Any, property: str, used_layers_data: typing.Any, used_layers_property: str, active_layer: int) -> None:

    """

    template_layers

    """

    ...

  def template_color_picker(self, data: typing.Any, property: str, value_slider: bool = False, lock: bool = False, lock_luminosity: bool = False, cubic: bool = False) -> None:

    """

    Item. A color wheel widget to pick colors

    """

    ...

  def template_palette(self, data: typing.Any, property: str, color: bool = False) -> None:

    """

    Item. A palette used to pick colors

    """

    ...

  def template_image_layers(self, image: Image, image_user: ImageUser) -> None:

    """

    template_image_layers

    """

    ...

  def template_image(self, data: typing.Any, property: str, image_user: ImageUser, compact: bool = False, multiview: bool = False) -> None:

    """

    Item(s). User interface for selecting images and their source paths

    """

    ...

  def template_image_settings(self, image_settings: ImageFormatSettings, color_management: bool = False) -> None:

    """

    User interface for setting image format options

    """

    ...

  def template_image_stereo_3d(self, stereo_3d_format: Stereo3dFormat) -> None:

    """

    User interface for setting image stereo 3d options

    """

    ...

  def template_image_views(self, image_settings: ImageFormatSettings) -> None:

    """

    User interface for setting image views output options

    """

    ...

  def template_movieclip(self, data: typing.Any, property: str, compact: bool = False) -> None:

    """

    Item(s). User interface for selecting movie clips and their source paths

    """

    ...

  def template_track(self, data: typing.Any, property: str) -> None:

    """

    Item. A movie-track widget to preview tracking image.

    """

    ...

  def template_marker(self, data: typing.Any, property: str, clip_user: MovieClipUser, track: MovieTrackingTrack, compact: bool = False) -> None:

    """

    Item. A widget to control single marker settings.

    """

    ...

  def template_movieclip_information(self, data: typing.Any, property: str, clip_user: MovieClipUser) -> None:

    """

    Item. Movie clip information data.

    """

    ...

  def template_list(self, listtype_name: str, list_id: str, dataptr: typing.Any, propname: str, active_dataptr: typing.Any, active_propname: str, item_dyntip_propname: str = '', rows: int = 5, maxrows: int = 5, type: str = 'DEFAULT', columns: int = 9, sort_reverse: bool = False, sort_lock: bool = False) -> None:

    """

    Item. A list widget to display data, e.g. vertexgroups.

    """

    ...

  def template_running_jobs(self) -> None:

    """

    template_running_jobs

    """

    ...

  def template_operator_search(self) -> None:

    """

    template_operator_search

    """

    ...

  def template_menu_search(self) -> None:

    """

    template_menu_search

    """

    ...

  def template_header_3D_mode(self) -> None:

    ...

  def template_edit_mode_selection(self) -> None:

    """

    Inserts common 3DView Edit modes header UI (selector for selection mode)

    """

    ...

  def template_reports_banner(self) -> None:

    """

    template_reports_banner

    """

    ...

  def template_input_status(self) -> None:

    """

    template_input_status

    """

    ...

  def template_node_link(self, ntree: NodeTree, node: Node, socket: NodeSocket) -> None:

    """

    template_node_link

    """

    ...

  def template_node_view(self, ntree: NodeTree, node: Node, socket: NodeSocket) -> None:

    """

    template_node_view

    """

    ...

  def template_texture_user(self) -> None:

    """

    template_texture_user

    """

    ...

  def template_keymap_item_properties(self, item: KeyMapItem) -> None:

    """

    template_keymap_item_properties

    """

    ...

  def template_component_menu(self, data: typing.Any, property: str, name: str = '') -> None:

    """

    Item. Display expanded property in a popup menu

    """

    ...

  def template_colorspace_settings(self, data: typing.Any, property: str) -> None:

    """

    Item. A widget to control input color space settings.

    """

    ...

  def template_colormanaged_view_settings(self, data: typing.Any, property: str) -> None:

    """

    Item. A widget to control color managed view settings settings.

    """

    ...

  def template_node_socket(self, color: typing.Tuple[float, float, float, float] = (0.0, 0.0, 0.0, 1.0)) -> None:

    """

    Node Socket Icon

    """

    ...

  def template_cache_file(self, data: typing.Any, property: str) -> None:

    """

    Item(s). User interface for selecting cache files and their source paths

    """

    ...

  def template_recent_files(self, rows: int = 5) -> int:

    """

    Show list of recently saved .blend files

    """

    ...

  def template_file_select_path(self, params: FileSelectParams) -> None:

    """

    Item. A text button to set the active file browser path.

    """

    ...

  def template_event_from_keymap_item(self, item: KeyMapItem, text: str = '', text_ctxt: str = '', translate: bool = True) -> None:

    """

    Display keymap item as icons/text

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UIList(bpy_struct):

  """

  UI list containing the elements of a collection

  """

  bitflag_filter_item: int = ...

  """

  The value of the reserved bitflag 'FILTER_ITEM' (in filter_flags values)

  """

  bl_idname: str = ...

  """

  If this is set, the uilist gets a custom ID, otherwise it takes the name of the class used to define the uilist (for example, if the class name is "OBJECT_UL_vgroups", and bl_idname is not set by the script, then bl_idname = "OBJECT_UL_vgroups")

  """

  filter_name: str = ...

  """

  Only show items matching this name (use '*' as wildcard)

  """

  layout_type: str = ...

  """

  * ``DEFAULT``
Default Layout, Use the default, multi-rows layout.

  * ``COMPACT``
Compact Layout, Use the compact, single-row layout.

  * ``GRID``
Grid Layout, Use the grid-based layout.

  """

  use_filter_invert: bool = ...

  """

  Invert filtering (show hidden items, and vice-versa)

  """

  use_filter_show: bool = ...

  """

  Show filtering options

  """

  use_filter_sort_alpha: bool = ...

  """

  Sort items by their name

  """

  use_filter_sort_lock: bool = ...

  """

  Lock the order of shown items (user cannot change it)

  """

  use_filter_sort_reverse: bool = ...

  """

  Reverse the order of shown items

  """

  def draw_item(self, context: Context, layout: UILayout, data: typing.Any, item: typing.Any, icon: int, active_data: typing.Any, active_property: str, index: int = 0, flt_flag: int = 0) -> None:

    """

    Draw an item in the list (NOTE: when you define your own draw_item function, you may want to check given 'item' is of the right type...)

    """

    ...

  def draw_filter(self, context: Context, layout: UILayout) -> None:

    """

    Draw filtering options

    """

    ...

  def filter_items(self, context: Context, data: typing.Any, property: str) -> None:

    """

    Filter and/or re-order items of the collection (output filter results in filter_flags, and reorder results in filter_neworder arrays)

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UIPieMenu(bpy_struct):

  layout: UILayout = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UIPopover(bpy_struct):

  layout: UILayout = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UIPopupMenu(bpy_struct):

  layout: UILayout = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UVLoopLayers(bpy_struct):

  """

  Collection of uv loop layers

  """

  active: MeshUVLoopLayer = ...

  """

  Active UV loop layer

  """

  active_index: int = ...

  """

  Active UV loop layer index

  """

  def new(self, name: str = 'UVMap', do_init: bool = True) -> MeshUVLoopLayer:

    """

    Add a UV map layer to Mesh

    """

    ...

  def remove(self, layer: MeshUVLoopLayer) -> None:

    """

    Remove a vertex color layer

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UVProjector(bpy_struct):

  """

  UV projector used by the UV project modifier

  """

  object: Object = ...

  """

  Object to use as projector transform

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UnifiedPaintSettings(bpy_struct):

  """

  Overrides for some of the active brush's settings

  """

  color: typing.Tuple[float, float, float] = ...

  secondary_color: typing.Tuple[float, float, float] = ...

  size: int = ...

  """

  Radius of the brush

  """

  strength: float = ...

  """

  How powerful the effect of the brush is when applied

  """

  unprojected_radius: float = ...

  """

  Radius of brush in Blender units

  """

  use_locked_size: str = ...

  """

  Measure brush size relative to the view or the scene

  * ``VIEW``
View, Measure brush size relative to the view.

  * ``SCENE``
Scene, Measure brush size relative to the scene.

  """

  use_unified_color: bool = ...

  """

  Instead of per-brush color, the color is shared across brushes

  """

  use_unified_size: bool = ...

  """

  Instead of per-brush radius, the radius is shared across brushes

  """

  use_unified_strength: bool = ...

  """

  Instead of per-brush strength, the strength is shared across brushes

  """

  use_unified_weight: bool = ...

  """

  Instead of per-brush weight, the weight is shared across brushes

  """

  weight: float = ...

  """

  Weight to assign in vertex groups

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UnitSettings(bpy_struct):

  length_unit: str = ...

  """

  Unit that will be used to display length values

  """

  mass_unit: str = ...

  """

  Unit that will be used to display mass values

  """

  scale_length: float = ...

  """

  Scale to use when converting between blender units and dimensions. When working at microscopic or astronomical scale, a small or large unit scale respectively can be used to avoid numerical precision problems

  """

  system: str = ...

  """

  The unit system to use for user interface controls

  """

  system_rotation: str = ...

  """

  Unit to use for displaying/editing rotation values

  * ``DEGREES``
Degrees, Use degrees for measuring angles and rotations.

  * ``RADIANS``
Radians.

  """

  temperature_unit: str = ...

  """

  Unit that will be used to display temperature values

  """

  time_unit: str = ...

  """

  Unit that will be used to display time values

  """

  use_separate: bool = ...

  """

  Display units in pairs (e.g. 1m 0cm)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UnknownType(bpy_struct):

  """

  Stub RNA type used for pointers to unknown or internal data

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UserSolidLight(bpy_struct):

  """

  Light used for Studio lighting in solid draw mode

  """

  diffuse_color: typing.Tuple[float, float, float] = ...

  """

  Color of the light's diffuse highlight

  """

  direction: typing.Tuple[float, float, float] = ...

  """

  Direction that the light is shining

  """

  smooth: float = ...

  """

  Smooth the lighting from this light

  """

  specular_color: typing.Tuple[float, float, float] = ...

  """

  Color of the light's specular highlight

  """

  use: bool = ...

  """

  Enable this light in solid draw mode

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertColors(bpy_struct):

  """

  Collection of sculpt vertex colors

  """

  active: MeshVertColorLayer = ...

  """

  Active sculpt vertex color layer

  """

  active_index: int = ...

  """

  Active sculpt vertex color index

  """

  def new(self, name: str = 'Col', do_init: bool = True) -> MeshVertColorLayer:

    """

    Add a sculpt vertex color layer to Mesh

    """

    ...

  def remove(self, layer: MeshVertColorLayer) -> None:

    """

    Remove a vertex color layer

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertexFloatProperties(bpy_struct):

  """

  Collection of float properties

  """

  def new(self, name: str = 'Float Prop') -> MeshVertexFloatPropertyLayer:

    """

    Add a float property layer to Mesh

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertexGroup(bpy_struct):

  """

  Group of vertices, used for armature deform and other purposes

  """

  index: int = ...

  """

  Index number of the vertex group

  """

  lock_weight: bool = ...

  """

  Maintain the relative weights for the group

  """

  name: str = ...

  """

  Vertex group name

  """

  def add(self, index: typing.Tuple[int], weight: float, type: str) -> None:

    """

    Add vertices to the group

    """

    ...

  def remove(self, index: typing.Tuple[int]) -> None:

    """

    Remove a vertex from the group

    """

    ...

  def weight(self, index: int) -> float:

    """

    Get a vertex weight from the group

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertexGroupElement(bpy_struct):

  """

  Weight value of a vertex in a vertex group

  """

  group: int = ...

  weight: float = ...

  """

  Vertex Weight

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertexGroups(bpy_struct):

  """

  Collection of vertex groups

  """

  active: VertexGroup = ...

  """

  Vertex groups of the object

  """

  active_index: int = ...

  """

  Active index in vertex group array

  """

  def new(self, name: str = 'Group') -> VertexGroup:

    """

    Add vertex group to object

    """

    ...

  def remove(self, group: VertexGroup) -> None:

    """

    Delete vertex group from object

    """

    ...

  def clear(self) -> None:

    """

    Delete all vertex groups from object

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertexIntProperties(bpy_struct):

  """

  Collection of int properties

  """

  def new(self, name: str = 'Int Prop') -> MeshVertexIntPropertyLayer:

    """

    Add a integer property layer to Mesh

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertexStringProperties(bpy_struct):

  """

  Collection of string properties

  """

  def new(self, name: str = 'String Prop') -> MeshVertexStringPropertyLayer:

    """

    Add a string property layer to Mesh

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class View2D(bpy_struct):

  """

  Scroll and zoom for a 2D region

  """

  def region_to_view(self, x: float, y: float) -> typing.Tuple[float, float]:

    """

    Transform region coordinates to 2D view

    """

    ...

  def view_to_region(self, x: float, y: float, clip: bool = True) -> typing.Tuple[int, int]:

    """

    Transform 2D view coordinates to region

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class View3DCursor(bpy_struct):

  location: typing.Tuple[float, float, float] = ...

  matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Matrix combining loc/rot of the cursor

  """

  rotation_axis_angle: typing.Tuple[float, float, float, float] = ...

  """

  Angle of Rotation for Axis-Angle rotation representation

  """

  rotation_euler: typing.Tuple[float, float, float] = ...

  """

  3D rotation

  """

  rotation_mode: str = ...

  """

  * ``QUATERNION``
Quaternion (WXYZ), No Gimbal Lock.

  * ``XYZ``
XYZ Euler, XYZ Rotation Order - prone to Gimbal Lock (default).

  * ``XZY``
XZY Euler, XZY Rotation Order - prone to Gimbal Lock.

  * ``YXZ``
YXZ Euler, YXZ Rotation Order - prone to Gimbal Lock.

  * ``YZX``
YZX Euler, YZX Rotation Order - prone to Gimbal Lock.

  * ``ZXY``
ZXY Euler, ZXY Rotation Order - prone to Gimbal Lock.

  * ``ZYX``
ZYX Euler, ZYX Rotation Order - prone to Gimbal Lock.

  * ``AXIS_ANGLE``
Axis Angle, Axis Angle (W+XYZ), defines a rotation around some axis defined by 3D-Vector.

  """

  rotation_quaternion: typing.Tuple[float, float, float, float] = ...

  """

  Rotation in quaternions (keep normalized)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class View3DOverlay(bpy_struct):

  """

  Settings for display of overlays in the 3D viewport

  """

  backwire_opacity: float = ...

  """

  Opacity when rendering transparent wires

  """

  display_handle: str = ...

  """

  Limit the display of curve handles in edit mode

  """

  fade_inactive_alpha: float = ...

  """

  Strength of the fade effect

  """

  gpencil_fade_layer: float = ...

  """

  Fade layer opacity for Grease Pencil layers except the active one

  """

  gpencil_fade_objects: float = ...

  """

  Fade factor

  """

  gpencil_grid_opacity: float = ...

  """

  Canvas grid opacity

  """

  gpencil_vertex_paint_opacity: float = ...

  """

  Vertex Paint mix factor

  """

  grid_lines: int = ...

  """

  Number of grid lines to display in perspective view

  """

  grid_scale: float = ...

  """

  Multiplier for the distance between 3D View grid lines

  """

  grid_scale_unit: float = ...

  """

  Grid cell size scaled by scene unit system settings

  """

  grid_subdivisions: int = ...

  """

  Number of subdivisions between grid lines

  """

  normals_length: float = ...

  """

  Display size for normals in the 3D view

  """

  sculpt_mode_face_sets_opacity: float = ...

  sculpt_mode_mask_opacity: float = ...

  show_annotation: bool = ...

  """

  Show annotations for this view

  """

  show_axis_x: bool = ...

  """

  Show the X axis line

  """

  show_axis_y: bool = ...

  """

  Show the Y axis line

  """

  show_axis_z: bool = ...

  """

  Show the Z axis line

  """

  show_bones: bool = ...

  """

  Display bones (disable to show motion paths only)

  """

  show_cursor: bool = ...

  """

  Display 3D Cursor Overlay

  """

  show_curve_normals: bool = ...

  """

  Display 3D curve normals in editmode

  """

  show_edge_bevel_weight: bool = ...

  """

  Display weights created for the Bevel modifier

  """

  show_edge_crease: bool = ...

  """

  Display creases created for Subdivision Surface modifier

  """

  show_edge_seams: bool = ...

  """

  Display UV unwrapping seams

  """

  show_edge_sharp: bool = ...

  """

  Display sharp edges, used with the Edge Split modifier

  """

  show_edges: bool = ...

  """

  Highlight selected edges

  """

  show_extra_edge_angle: bool = ...

  """

  Display selected edge angle, using global values when set in the transform panel

  """

  show_extra_edge_length: bool = ...

  """

  Display selected edge lengths, using global values when set in the transform panel

  """

  show_extra_face_angle: bool = ...

  """

  Display the angles in the selected edges, using global values when set in the transform panel

  """

  show_extra_face_area: bool = ...

  """

  Display the area of selected faces, using global values when set in the transform panel

  """

  show_extra_indices: bool = ...

  """

  Display the index numbers of selected vertices, edges, and faces

  """

  show_extras: bool = ...

  """

  Object details, including empty wire, cameras and other visual guides

  """

  show_face_center: bool = ...

  """

  Display face center

  """

  show_face_normals: bool = ...

  """

  Display face normals as lines

  """

  show_face_orientation: bool = ...

  """

  Show the Face Orientation Overlay

  """

  show_faces: bool = ...

  """

  Highlight selected faces

  """

  show_fade_inactive: bool = ...

  """

  Fade inactive geometry using the viewport background color

  """

  show_floor: bool = ...

  """

  Show the ground plane grid

  """

  show_freestyle_edge_marks: bool = ...

  """

  Display Freestyle edge marks, used with the Freestyle renderer

  """

  show_freestyle_face_marks: bool = ...

  """

  Display Freestyle face marks, used with the Freestyle renderer

  """

  show_look_dev: bool = ...

  """

  Show HDRI preview spheres

  """

  show_motion_paths: bool = ...

  """

  Show the Motion Paths Overlay

  """

  show_object_origins: bool = ...

  """

  Show object center dots

  """

  show_object_origins_all: bool = ...

  """

  Show the object origin center dot for all (selected and unselected) objects

  """

  show_occlude_wire: bool = ...

  """

  Use hidden wireframe display

  """

  show_onion_skins: bool = ...

  """

  Show the Onion Skinning Overlay

  """

  show_ortho_grid: bool = ...

  """

  Show grid in orthographic side view

  """

  show_outline_selected: bool = ...

  """

  Show an outline highlight around selected objects

  """

  show_overlays: bool = ...

  """

  Display overlays like gizmos and outlines

  """

  show_paint_wire: bool = ...

  """

  Use wireframe display in painting modes

  """

  show_relationship_lines: bool = ...

  """

  Show dashed lines indicating parent or constraint relationships

  """

  show_split_normals: bool = ...

  """

  Display vertex-per-face normals as lines

  """

  show_stats: bool = ...

  """

  Display scene statistics overlay text

  """

  show_statvis: bool = ...

  """

  Display statistical information about the mesh

  """

  show_text: bool = ...

  """

  Display overlay text

  """

  show_vertex_normals: bool = ...

  """

  Display vertex normals as lines

  """

  show_weight: bool = ...

  """

  Display weights in editmode

  """

  show_wireframes: bool = ...

  """

  Show face edges wires

  """

  show_wpaint_contours: bool = ...

  """

  Show contour lines formed by points with the same interpolated weight

  """

  show_xray_bone: bool = ...

  """

  Show the bone selection overlay

  """

  texture_paint_mode_opacity: float = ...

  """

  Opacity of the texture paint mode stencil mask overlay

  """

  use_gpencil_canvas_xray: bool = ...

  """

  Show Canvas grid in front

  """

  use_gpencil_edit_lines: bool = ...

  """

  Show Edit Lines when editing strokes

  """

  use_gpencil_fade_gp_objects: bool = ...

  """

  Fade Grease Pencil Objects, except the active one

  """

  use_gpencil_fade_layers: bool = ...

  """

  Toggle fading of Grease Pencil layers except the active one

  """

  use_gpencil_fade_objects: bool = ...

  """

  Fade all viewport objects with a full color layer to improve visibility

  """

  use_gpencil_grid: bool = ...

  """

  Display a grid over grease pencil paper

  """

  use_gpencil_multiedit_line_only: bool = ...

  """

  Show Edit Lines only in multiframe

  """

  use_gpencil_onion_skin: bool = ...

  """

  Show ghosts of the keyframes before and after the current frame

  """

  use_gpencil_show_directions: bool = ...

  """

  Show stroke drawing direction with a bigger green dot (start) and smaller red dot (end) points

  """

  use_gpencil_show_material_name: bool = ...

  """

  Show material name assigned to each stroke

  """

  vertex_opacity: float = ...

  """

  Opacity for edit vertices

  """

  vertex_paint_mode_opacity: float = ...

  """

  Opacity of the texture paint mode stencil mask overlay

  """

  weight_paint_mode_opacity: float = ...

  """

  Opacity of the weight paint mode overlay

  """

  wireframe_threshold: float = ...

  """

  Adjust the angle threshold for displaying edges (1.0 for all)

  """

  xray_alpha_bone: float = ...

  """

  Opacity to use for bone selection

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class View3DShading(bpy_struct):

  """

  Settings for shading in the 3D viewport

  """

  background_color: typing.Tuple[float, float, float] = ...

  """

  Color for custom background color

  """

  background_type: str = ...

  """

  Way to draw the background

  * ``THEME``
Theme, Use the theme for background color.

  * ``WORLD``
World, Use the world for background color.

  * ``VIEWPORT``
Viewport, Use a custom color limited to this viewport only.

  """

  cavity_ridge_factor: float = ...

  """

  Factor for the cavity ridges

  """

  cavity_type: str = ...

  """

  Way to draw the cavity shading

  * ``WORLD``
World, Cavity shading computed in world space, useful for larger-scale occlusion.

  * ``SCREEN``
Screen, Curvature-based shading, useful for making fine details more visible.

  * ``BOTH``
Both, Use both effects simultaneously.

  """

  cavity_valley_factor: float = ...

  """

  Factor for the cavity valleys

  """

  color_type: str = ...

  """

  Color Type

  * ``MATERIAL``
Material, Show material color.

  * ``SINGLE``
Single, Show scene in a single color.

  * ``OBJECT``
Object, Show object color.

  * ``RANDOM``
Random, Show random object color.

  * ``VERTEX``
Vertex, Show active vertex color.

  * ``TEXTURE``
Texture, Show texture.

  """

  curvature_ridge_factor: float = ...

  """

  Factor for the curvature ridges

  """

  curvature_valley_factor: float = ...

  """

  Factor for the curvature valleys

  """

  cycles: CyclesView3DShadingSettings = ...

  light: str = ...

  """

  Lighting Method for Solid/Texture Viewport Shading

  * ``STUDIO``
Studio, Display using studio lighting.

  * ``MATCAP``
MatCap, Display using matcap material and lighting.

  * ``FLAT``
Flat, Display using flat lighting.

  """

  object_outline_color: typing.Tuple[float, float, float] = ...

  """

  Color for object outline

  """

  render_pass: str = ...

  """

  Render Pass to show in the viewport

  """

  selected_studio_light: StudioLight = ...

  """

  Selected StudioLight

  """

  shadow_intensity: float = ...

  """

  Darkness of shadows

  """

  show_backface_culling: bool = ...

  """

  Use back face culling to hide the back side of faces

  """

  show_cavity: bool = ...

  """

  Show Cavity

  """

  show_object_outline: bool = ...

  """

  Show Object Outline

  """

  show_shadows: bool = ...

  """

  Show Shadow

  """

  show_specular_highlight: bool = ...

  """

  Render specular highlights

  """

  show_xray: bool = ...

  """

  Show whole scene transparent

  """

  show_xray_wireframe: bool = ...

  """

  Show whole scene transparent

  """

  single_color: typing.Tuple[float, float, float] = ...

  """

  Color for single color mode

  """

  studio_light: str = ...

  """

  Studio lighting setup

  """

  studiolight_background_alpha: float = ...

  """

  Show the studiolight in the background

  """

  studiolight_background_blur: float = ...

  """

  Blur the studiolight in the background

  """

  studiolight_intensity: float = ...

  """

  Strength of the studiolight

  """

  studiolight_rotate_z: float = ...

  """

  Rotation of the studiolight around the Z-Axis

  """

  type: str = ...

  """

  Method to display/shade objects in the 3D View

  * ``WIREFRAME``
Wireframe, Display the object as wire edges.

  * ``SOLID``
Solid, Display in solid mode.

  * ``MATERIAL``
Material Preview, Display in Material Preview mode.

  * ``RENDERED``
Rendered, Display render preview.

  """

  use_dof: bool = ...

  """

  Use depth of field on viewport using the values from the active camera

  """

  use_scene_lights: bool = ...

  """

  Render lights and light probes of the scene

  """

  use_scene_lights_render: bool = ...

  """

  Render lights and light probes of the scene

  """

  use_scene_world: bool = ...

  """

  Use scene world for lighting

  """

  use_scene_world_render: bool = ...

  """

  Use scene world for lighting

  """

  use_studiolight_view_rotation: bool = ...

  """

  Make the HDR rotation fixed and not follow the camera

  """

  use_world_space_lighting: bool = ...

  """

  Make the lighting fixed and not follow the camera

  """

  wireframe_color_type: str = ...

  """

  Color Type

  * ``MATERIAL``
Material, Show material color.

  * ``SINGLE``
Single, Show scene in a single color.

  * ``OBJECT``
Object, Show object color.

  * ``RANDOM``
Random, Show random object color.

  * ``VERTEX``
Vertex, Show active vertex color.

  * ``TEXTURE``
Texture, Show texture.

  """

  xray_alpha: float = ...

  """

  Amount of alpha to use

  """

  xray_alpha_wireframe: float = ...

  """

  Amount of alpha to use

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ViewLayer(bpy_struct):

  """

  View layer

  """

  active_layer_collection: LayerCollection = ...

  """

  Active layer collection in this view layer's hierarchy

  """

  cycles: CyclesRenderLayerSettings = ...

  """

  Cycles ViewLayer Settings

  """

  depsgraph: Depsgraph = ...

  """

  Dependencies in the scene data

  """

  eevee: ViewLayerEEVEE = ...

  """

  View layer settings for EEVEE

  """

  freestyle_settings: FreestyleSettings = ...

  invert_zmask: bool = ...

  """

  For Zmask, only render what is behind solid z values instead of in front

  """

  layer_collection: LayerCollection = ...

  """

  Root of collections hierarchy of this view layer,its 'collection' pointer property is the same as the scene's master collection

  """

  material_override: Material = ...

  """

  Material to override all other materials in this view layer

  """

  name: str = ...

  """

  View layer name

  """

  objects: typing.Union[LayerObjects, typing.Sequence[Object], typing.Mapping[str, Object], bpy_prop_collection] = ...

  """

  All the objects in this layer

  """

  pass_alpha_threshold: float = ...

  """

  Z, Index, normal, UV and vector passes are only affected by surfaces with alpha transparency equal to or higher than this threshold

  """

  samples: int = ...

  """

  Override number of render samples for this view layer, 0 will use the scene setting

  """

  use: bool = ...

  """

  Enable or disable rendering of this View Layer

  """

  use_all_z: bool = ...

  """

  Fill in Z values for solid faces in invisible layers, for masking

  """

  use_ao: bool = ...

  """

  Render Ambient Occlusion in this Layer

  """

  use_edge_enhance: bool = ...

  """

  Render Edge-enhance in this Layer (only works for Solid faces)

  """

  use_freestyle: bool = ...

  """

  Render stylized strokes in this Layer

  """

  use_halo: bool = ...

  """

  Render Halos in this Layer (on top of Solid)

  """

  use_pass_ambient_occlusion: bool = ...

  """

  Deliver Ambient Occlusion pass

  """

  use_pass_combined: bool = ...

  """

  Deliver full combined RGBA buffer

  """

  use_pass_diffuse_color: bool = ...

  """

  Deliver diffuse color pass

  """

  use_pass_diffuse_direct: bool = ...

  """

  Deliver diffuse direct pass

  """

  use_pass_diffuse_indirect: bool = ...

  """

  Deliver diffuse indirect pass

  """

  use_pass_emit: bool = ...

  """

  Deliver emission pass

  """

  use_pass_environment: bool = ...

  """

  Deliver environment lighting pass

  """

  use_pass_glossy_color: bool = ...

  """

  Deliver glossy color pass

  """

  use_pass_glossy_direct: bool = ...

  """

  Deliver glossy direct pass

  """

  use_pass_glossy_indirect: bool = ...

  """

  Deliver glossy indirect pass

  """

  use_pass_material_index: bool = ...

  """

  Deliver material index pass

  """

  use_pass_mist: bool = ...

  """

  Deliver mist factor pass (0.0-1.0)

  """

  use_pass_normal: bool = ...

  """

  Deliver normal pass

  """

  use_pass_object_index: bool = ...

  """

  Deliver object index pass

  """

  use_pass_shadow: bool = ...

  """

  Deliver shadow pass

  """

  use_pass_subsurface_color: bool = ...

  """

  Deliver subsurface color pass

  """

  use_pass_subsurface_direct: bool = ...

  """

  Deliver subsurface direct pass

  """

  use_pass_subsurface_indirect: bool = ...

  """

  Deliver subsurface indirect pass

  """

  use_pass_transmission_color: bool = ...

  """

  Deliver transmission color pass

  """

  use_pass_transmission_direct: bool = ...

  """

  Deliver transmission direct pass

  """

  use_pass_transmission_indirect: bool = ...

  """

  Deliver transmission indirect pass

  """

  use_pass_uv: bool = ...

  """

  Deliver texture UV pass

  """

  use_pass_vector: bool = ...

  """

  Deliver speed vector pass

  """

  use_pass_z: bool = ...

  """

  Deliver Z values pass

  """

  use_sky: bool = ...

  """

  Render Sky in this Layer

  """

  use_solid: bool = ...

  """

  Render Solid faces in this Layer

  """

  use_strand: bool = ...

  """

  Render Strands in this Layer

  """

  use_volumes: bool = ...

  """

  Render volumes in this Layer

  """

  use_zmask: bool = ...

  """

  Only render what's in front of the solid z values

  """

  use_ztransp: bool = ...

  """

  Render Z-Transparent faces in this Layer (on top of Solid and Halos)

  """

  @classmethod

  def update_render_passes(cls) -> None:

    """

    Requery the enabled render passes from the render engine

    """

    ...

  def update(self) -> None:

    """

    Update data tagged to be updated from previous access to data or operators

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ViewLayerEEVEE(bpy_struct):

  """

  View layer settings for EEVEE

  """

  use_pass_bloom: bool = ...

  """

  Deliver bloom pass

  """

  use_pass_volume_scatter: bool = ...

  """

  Deliver volume scattering pass

  """

  use_pass_volume_transmittance: bool = ...

  """

  Deliver volume transmittance pass

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ViewLayers(bpy_struct):

  """

  Collection of render layers

  """

  def new(self, name: str) -> ViewLayer:

    """

    Add a view layer to scene

    """

    ...

  def remove(self, layer: ViewLayer) -> None:

    """

    Remove a view layer

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VolumeDisplay(bpy_struct):

  """

  Volume object display settings for 3d viewport

  """

  density: float = ...

  """

  Thickness of volume drawing in the viewport

  """

  interpolation_method: str = ...

  """

  Interpolation method to use for volumes in solid mode

  * ``LINEAR``
Linear, Good smoothness and speed.

  * ``CUBIC``
Cubic, Smoothed high quality interpolation, but slower.

  * ``CLOSEST``
Closest, No interpolation.

  """

  slice_axis: str = ...

  """

  * ``AUTO``
Auto, Adjust slice direction according to the view direction.

  * ``X``
X, Slice along the X axis.

  * ``Y``
Y, Slice along the Y axis.

  * ``Z``
Z, Slice along the Z axis.

  """

  slice_depth: float = ...

  """

  Position of the slice

  """

  use_slice: bool = ...

  """

  Perform a single slice of the domain object

  """

  wireframe_detail: str = ...

  """

  Amount of detail for wireframe display

  * ``COARSE``
Coarse, Display one box or point for each intermediate tree node.

  * ``FINE``
Fine, Display box for each leaf node containing 8x8 voxels.

  """

  wireframe_type: str = ...

  """

  Type of wireframe display

  * ``NONE``
None, Don't display volume in wireframe mode.

  * ``BOUNDS``
Bounds, Display single bounding box for the entire grid.

  * ``BOXES``
Boxes, Display bounding boxes for nodes in the volume tree.

  * ``POINTS``
Points, Display points for nodes in the volume tree.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VolumeGrid(bpy_struct):

  """

  3D volume grid

  """

  channels: int = ...

  """

  Number of dimensions of the grid data type

  """

  data_type: str = ...

  """

  Data type of voxel values

  * ``BOOLEAN``
Boolean, Boolean.

  * ``FLOAT``
Float, Single precision float.

  * ``DOUBLE``
Double, Double precision.

  * ``INT``
Integer, 32 bit integer.

  * ``INT64``
Integer 64 bit, 64 bit integer.

  * ``MASK``
Mask, No data, boolean mask of active voxels.

  * ``STRING``
String, Text string.

  * ``VECTOR_FLOAT``
Float Vector, 3D float vector.

  * ``VECTOR_DOUBLE``
Double Vector, 3D double vector.

  * ``VECTOR_INT``
Integer Vector, 3D integer vector.

  * ``POINTS``
Points (Unsupported), Points grid, currently unsupported by volume objects.

  * ``UNKNOWN``
Unknown, Unsupported data type.

  """

  is_loaded: bool = ...

  """

  Grid tree is loaded in memory

  """

  matrix_object: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Transformation matrix from voxel index to object space

  """

  name: str = ...

  """

  Volume grid name

  """

  def load(self) -> bool:

    """

    Load grid tree from file

    """

    ...

  def unload(self) -> None:

    """

    Unload grid tree and voxel data from memory, leaving only metadata

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VolumeGrids(bpy_struct):

  """

  3D volume grids

  """

  active_index: int = ...

  """

  Index of active volume grid

  """

  error_message: str = ...

  """

  If loading grids failed, error message with details

  """

  frame: int = ...

  """

  Frame number that volume grids will be loaded at, based on scene time and volume parameters

  """

  frame_filepath: str = ...

  """

  Volume file used for loading the volume at the current frame. Empty if the volume has not be loaded or the frame only exists in memory

  """

  is_loaded: bool = ...

  """

  List of grids and metadata are loaded in memory

  """

  def load(self) -> bool:

    """

    Load list of grids and metadata from file

    """

    ...

  def unload(self) -> None:

    """

    Unload all grid and voxel data from memory

    """

    ...

  def save(self, filepath: str) -> bool:

    """

    Save grids and metadata to file

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VolumeRender(bpy_struct):

  """

  Volume object render settings

  """

  clipping: float = ...

  """

  Value under which voxels are considered empty space to optimize rendering

  """

  space: str = ...

  """

  Specify volume density and step size  in object or world space

  * ``OBJECT``
Object, Keep volume opacity and detail the same regardless of object scale.

  * ``WORLD``
World, Specify volume step size and density in world space.

  """

  step_size: float = ...

  """

  Distance between volume samples. Lower values render more detail at the cost of performance. If set to zero, the step size is automatically determined based on voxel size

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WalkNavigation(bpy_struct):

  """

  Walk navigation settings

  """

  jump_height: float = ...

  """

  Maximum height of a jump

  """

  mouse_speed: float = ...

  """

  Speed factor for when looking around, high values mean faster mouse movement

  """

  teleport_time: float = ...

  """

  Interval of time warp when teleporting in navigation mode

  """

  use_gravity: bool = ...

  """

  Walk with gravity, or free navigate

  """

  use_mouse_reverse: bool = ...

  """

  Reverse the vertical movement of the mouse

  """

  view_height: float = ...

  """

  View distance from the floor when walking

  """

  walk_speed: float = ...

  """

  Base speed for walking and flying

  """

  walk_speed_factor: float = ...

  """

  Multiplication factor when using the fast or slow modifiers

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Window(bpy_struct):

  """

  Open window

  """

  height: int = ...

  """

  Window height

  """

  parent: Window = ...

  """

  Active workspace and scene follow this window

  """

  scene: Scene = ...

  """

  Active scene to be edited in the window

  """

  screen: Screen = ...

  """

  Active workspace screen showing in the window

  """

  stereo_3d_display: Stereo3dDisplay = ...

  """

  Settings for stereo 3d display

  """

  view_layer: ViewLayer = ...

  """

  The active workspace view layer showing in the window

  """

  width: int = ...

  """

  Window width

  """

  workspace: WorkSpace = ...

  """

  Active workspace showing in the window

  """

  x: int = ...

  """

  Horizontal location of the window

  """

  y: int = ...

  """

  Vertical location of the window

  """

  def cursor_warp(self, x: int, y: int) -> None:

    """

    Set the cursor position

    """

    ...

  def cursor_set(self, cursor: str) -> None:

    """

    Set the cursor

    """

    ...

  def cursor_modal_set(self, cursor: str) -> None:

    """

    Restore the previous cursor after calling ``cursor_modal_set``

    """

    ...

  def cursor_modal_restore(self) -> None:

    """

    cursor_modal_restore

    """

    ...

  def event_simulate(self, type: str, value: str, unicode: str = '', x: int = 0, y: int = 0, shift: bool = False, ctrl: bool = False, alt: bool = False, oskey: bool = False) -> Event:

    """

    event_simulate

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WorkSpaceTool(bpy_struct):

  has_datablock: bool = ...

  idname: str = ...

  idname_fallback: str = ...

  index: int = ...

  mode: str = ...

  space_type: str = ...

  """

  * ``EMPTY``
Empty.

  * ``VIEW_3D``
3D Viewport, Manipulate objects in a 3D environment.

  * ``IMAGE_EDITOR``
UV/Image Editor, View and edit images and UV Maps.

  * ``NODE_EDITOR``
Node Editor, Editor for node-based shading and compositing tools.

  * ``SEQUENCE_EDITOR``
Video Sequencer, Video editing tools.

  * ``CLIP_EDITOR``
Movie Clip Editor, Motion tracking tools.

  * ``DOPESHEET_EDITOR``
Dope Sheet, Adjust timing of keyframes.

  * ``GRAPH_EDITOR``
Graph Editor, Edit drivers and keyframe interpolation.

  * ``NLA_EDITOR``
Nonlinear Animation, Combine and layer Actions.

  * ``TEXT_EDITOR``
Text Editor, Edit scripts and in-file documentation.

  * ``CONSOLE``
Python Console, Interactive programmatic console for advanced editing and script development.

  * ``INFO``
Info, Log of operations, warnings and error messages.

  * ``TOPBAR``
Top Bar, Global bar at the top of the screen for global per-window settings.

  * ``STATUSBAR``
Status Bar, Global bar at the bottom of the screen for general status information.

  * ``OUTLINER``
Outliner, Overview of scene graph and all available data-blocks.

  * ``PROPERTIES``
Properties, Edit properties of active object and related data-blocks.

  * ``FILE_BROWSER``
File Browser, Browse for files and assets.

  * ``PREFERENCES``
Preferences, Edit persistent configuration settings.

  """

  widget: str = ...

  def setup(self, idname: str, cursor: str = 'DEFAULT', keymap: str = '', gizmo_group: str = '', data_block: str = '', operator: str = '', index: int = 0, idname_fallback: str = '', keymap_fallback: str = '') -> None:

    """

    Set the tool settings

    """

    ...

  def operator_properties(self, operator: str) -> OperatorProperties:

    """

    operator_properties

    """

    ...

  def gizmo_group_properties(self, group: str) -> GizmoGroupProperties:

    """

    gizmo_group_properties

    """

    ...

  def refresh_from_context(self) -> None:

    """

    refresh_from_context

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WorldLighting(bpy_struct):

  """

  Lighting for a World data-block

  """

  ao_factor: float = ...

  """

  Factor for ambient occlusion blending

  """

  distance: float = ...

  """

  Length of rays, defines how far away other faces give occlusion effect

  """

  use_ambient_occlusion: bool = ...

  """

  Use Ambient Occlusion to add shadowing based on distance between objects

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WorldMistSettings(bpy_struct):

  """

  Mist settings for a World data-block

  """

  depth: float = ...

  """

  Distance over which the mist effect fades in

  """

  falloff: str = ...

  """

  Type of transition used to fade mist

  * ``QUADRATIC``
Quadratic, Use quadratic progression.

  * ``LINEAR``
Linear, Use linear progression.

  * ``INVERSE_QUADRATIC``
Inverse Quadratic, Use inverse quadratic progression.

  """

  height: float = ...

  """

  Control how much mist density decreases with height

  """

  intensity: float = ...

  """

  Overall minimum intensity of the mist effect

  """

  start: float = ...

  """

  Starting distance of the mist, measured from the camera

  """

  use_mist: bool = ...

  """

  Occlude objects with the environment color as they are further away

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class XrSessionSettings(bpy_struct):

  base_pose_angle: float = ...

  """

  Rotation angle around the Z-Axis to apply the rotation deltas from the VR headset to

  """

  base_pose_location: typing.Tuple[float, float, float] = ...

  """

  Coordinates to apply translation deltas from the VR headset to

  """

  base_pose_object: Object = ...

  """

  Object to take the location and rotation to which translation and rotation deltas from the VR headset will be applied to

  """

  base_pose_type: str = ...

  """

  Define where the location and rotation for the VR view come from, to which translation and rotation deltas from the VR headset will be applied to

  * ``SCENE_CAMERA``
Scene Camera, Follow the active scene camera to define the VR view's base pose.

  * ``OBJECT``
Object, Follow the transformation of an object to define the VR view's base pose.

  * ``CUSTOM``
Custom, Follow a custom transformation to define the VR view's base pose.

  """

  clip_end: float = ...

  """

  VR viewport far clipping distance

  """

  clip_start: float = ...

  """

  VR viewport near clipping distance

  """

  shading: View3DShading = ...

  show_annotation: bool = ...

  """

  Show annotations for this view

  """

  show_floor: bool = ...

  """

  Show the ground plane grid

  """

  use_positional_tracking: bool = ...

  """

  Allow VR headsets to affect the location in virtual space, in addition to the rotation

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class XrSessionState(bpy_struct):

  """

  Runtime state information about the VR session

  """

  viewer_pose_location: typing.Tuple[float, float, float] = ...

  """

  Last known location of the viewer pose (center between the eyes) in world space

  """

  viewer_pose_rotation: typing.Tuple[float, float, float, float] = ...

  """

  Last known rotation of the viewer pose (center between the eyes) in world space

  """

  @classmethod

  def is_running(cls, context: Context) -> bool:

    """

    Query if the VR session is currently running

    """

    ...

  @classmethod

  def reset_to_base_pose(cls, context: Context) -> None:

    """

    Force resetting of position and rotation deltas

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class wmOwnerID(bpy_struct):

  name: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class wmOwnerIDs(bpy_struct):

  def new(self, name: str) -> wmOwnerID:

    """

    Add ui tag

    """

    ...

  def remove(self, owner_id: wmOwnerID) -> None:

    """

    Remove ui tag

    """

    ...

  def clear(self) -> None:

    """

    Remove all tags

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class wmTools(bpy_struct):

  def from_space_view3d_mode(self, mode: str, create: bool = False) -> WorkSpaceTool:

    ...

  def from_space_image_mode(self, mode: str, create: bool = False) -> WorkSpaceTool:

    ...

  def from_space_node(self, create: bool = False) -> WorkSpaceTool:

    ...

  def from_space_sequencer(self, mode: str, create: bool = False) -> WorkSpaceTool:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ByteColorAttribute(bpy_struct, Attribute):

  """

  Color geometry attribute, with 8-bit precision

  """

  data: typing.Union[typing.Sequence[ByteColorAttributeValue], typing.Mapping[str, ByteColorAttributeValue], bpy_prop_collection] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FloatAttribute(bpy_struct, Attribute):

  """

  Geometry attribute with floating point values

  """

  data: typing.Union[typing.Sequence[FloatAttributeValue], typing.Mapping[str, FloatAttributeValue], bpy_prop_collection] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FloatColorAttribute(bpy_struct, Attribute):

  """

  Color geometry attribute, with floating point precision

  """

  data: typing.Union[typing.Sequence[FloatColorAttributeValue], typing.Mapping[str, FloatColorAttributeValue], bpy_prop_collection] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FloatVectorAttribute(bpy_struct, Attribute):

  """

  Vector geometry attribute, with floating point precision

  """

  data: typing.Union[typing.Sequence[FloatVectorAttributeValue], typing.Mapping[str, FloatVectorAttributeValue], bpy_prop_collection] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IntAttribute(bpy_struct, Attribute):

  """

  Integer geometry attribute

  """

  data: typing.Union[typing.Sequence[IntAttributeValue], typing.Mapping[str, IntAttributeValue], bpy_prop_collection] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class StringAttribute(bpy_struct, Attribute):

  """

  String geometry attribute

  """

  data: typing.Union[typing.Sequence[StringAttributeValue], typing.Mapping[str, StringAttributeValue], bpy_prop_collection] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoidRuleAverageSpeed(bpy_struct, BoidRule):

  level: float = ...

  """

  How much velocity's z-component is kept constant

  """

  speed: float = ...

  """

  Percentage of maximum speed

  """

  wander: float = ...

  """

  How fast velocity's direction is randomized

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoidRuleAvoid(bpy_struct, BoidRule):

  fear_factor: float = ...

  """

  Avoid object if danger from it is above this threshold

  """

  object: Object = ...

  """

  Object to avoid

  """

  use_predict: bool = ...

  """

  Predict target movement

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoidRuleAvoidCollision(bpy_struct, BoidRule):

  look_ahead: float = ...

  """

  Time to look ahead in seconds

  """

  use_avoid: bool = ...

  """

  Avoid collision with other boids

  """

  use_avoid_collision: bool = ...

  """

  Avoid collision with deflector objects

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoidRuleFight(bpy_struct, BoidRule):

  distance: float = ...

  """

  Attack boids at max this distance

  """

  flee_distance: float = ...

  """

  Flee to this distance

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoidRuleFollowLeader(bpy_struct, BoidRule):

  distance: float = ...

  """

  Distance behind leader to follow

  """

  object: Object = ...

  """

  Follow this object instead of a boid

  """

  queue_count: int = ...

  """

  How many boids in a line

  """

  use_line: bool = ...

  """

  Follow leader in a line

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoidRuleGoal(bpy_struct, BoidRule):

  object: Object = ...

  """

  Goal object

  """

  use_predict: bool = ...

  """

  Predict target movement

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ActionConstraint(bpy_struct, Constraint):

  """

  Map an action to the transform axes of a bone

  """

  action: Action = ...

  """

  The constraining action

  """

  eval_time: float = ...

  """

  Interpolates between Action Start and End frames

  """

  frame_end: int = ...

  """

  Last frame of the Action to use

  """

  frame_start: int = ...

  """

  First frame of the Action to use

  """

  max: float = ...

  """

  Maximum value for target channel range

  """

  min: float = ...

  """

  Minimum value for target channel range

  """

  mix_mode: str = ...

  """

  Specify how existing transformations and the action channels are combined

  * ``BEFORE``
Before Original, Apply the action channels before the original transformation, as if applied to an imaginary parent with Aligned Inherit Scale.

  * ``AFTER``
After Original, Apply the action channels after the original transformation, as if applied to an imaginary child with Aligned Inherit Scale.

  * ``AFTER_FULL``
After Original (Full Scale), Apply the action channels after the original transformation, as if applied to an imaginary child with Full Inherit Scale. This mode can create shear and is provided only for backward compatibility.

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  transform_channel: str = ...

  """

  Transformation channel from the target that is used to key the Action

  """

  use_bone_object_action: bool = ...

  """

  Bones only: apply the object's transformation channels of the action to the constrained bone, instead of bone's channels

  """

  use_eval_time: bool = ...

  """

  Interpolate between Action Start and End frames, with the Evaluation Time slider instead of the Target object/bone

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ArmatureConstraint(bpy_struct, Constraint):

  """

  Applies transformations done by the Armature modifier

  """

  targets: typing.Union[ArmatureConstraintTargets, typing.Sequence[ConstraintTargetBone], typing.Mapping[str, ConstraintTargetBone], bpy_prop_collection] = ...

  """

  Target Bones

  """

  use_bone_envelopes: bool = ...

  """

  Multiply weights by envelope for all bones, instead of acting like Vertex Group based blending. The specified weights are still used, and only the listed bones are considered

  """

  use_current_location: bool = ...

  """

  Use the current bone location for envelopes and choosing B-Bone segments instead of rest position

  """

  use_deform_preserve_volume: bool = ...

  """

  Deform rotation interpolation with quaternions

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CameraSolverConstraint(bpy_struct, Constraint):

  """

  Lock motion to the reconstructed camera movement

  """

  clip: MovieClip = ...

  """

  Movie Clip to get tracking data from

  """

  use_active_clip: bool = ...

  """

  Use active clip defined in scene

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ChildOfConstraint(bpy_struct, Constraint):

  """

  Create constraint-based parent-child relationship

  """

  inverse_matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Transformation matrix to apply before

  """

  set_inverse_pending: bool = ...

  """

  Set to true to request recalculation of the inverse matrix

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  use_location_x: bool = ...

  """

  Use X Location of Parent

  """

  use_location_y: bool = ...

  """

  Use Y Location of Parent

  """

  use_location_z: bool = ...

  """

  Use Z Location of Parent

  """

  use_rotation_x: bool = ...

  """

  Use X Rotation of Parent

  """

  use_rotation_y: bool = ...

  """

  Use Y Rotation of Parent

  """

  use_rotation_z: bool = ...

  """

  Use Z Rotation of Parent

  """

  use_scale_x: bool = ...

  """

  Use X Scale of Parent

  """

  use_scale_y: bool = ...

  """

  Use Y Scale of Parent

  """

  use_scale_z: bool = ...

  """

  Use Z Scale of Parent

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ClampToConstraint(bpy_struct, Constraint):

  """

  Constrain an object's location to the nearest point along the target path

  """

  main_axis: str = ...

  """

  Main axis of movement

  """

  target: Object = ...

  """

  Target Object (Curves only)

  """

  use_cyclic: bool = ...

  """

  Treat curve as cyclic curve (no clamping to curve bounding box)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CopyLocationConstraint(bpy_struct, Constraint):

  """

  Copy the location of the target

  """

  head_tail: float = ...

  """

  Target along length of bone: Head=0, Tail=1

  """

  invert_x: bool = ...

  """

  Invert the X location

  """

  invert_y: bool = ...

  """

  Invert the Y location

  """

  invert_z: bool = ...

  """

  Invert the Z location

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  use_bbone_shape: bool = ...

  """

  Follow shape of B-Bone segments when calculating Head/Tail position

  """

  use_offset: bool = ...

  """

  Add original location into copied location

  """

  use_x: bool = ...

  """

  Copy the target's X location

  """

  use_y: bool = ...

  """

  Copy the target's Y location

  """

  use_z: bool = ...

  """

  Copy the target's Z location

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CopyRotationConstraint(bpy_struct, Constraint):

  """

  Copy the rotation of the target

  """

  euler_order: str = ...

  """

  Explicitly specify the euler rotation order

  * ``AUTO``
Default, Euler using the default rotation order.

  * ``XYZ``
XYZ Euler, Euler using the XYZ rotation order.

  * ``XZY``
XZY Euler, Euler using the XZY rotation order.

  * ``YXZ``
YXZ Euler, Euler using the YXZ rotation order.

  * ``YZX``
YZX Euler, Euler using the YZX rotation order.

  * ``ZXY``
ZXY Euler, Euler using the ZXY rotation order.

  * ``ZYX``
ZYX Euler, Euler using the ZYX rotation order.

  """

  invert_x: bool = ...

  """

  Invert the X rotation

  """

  invert_y: bool = ...

  """

  Invert the Y rotation

  """

  invert_z: bool = ...

  """

  Invert the Z rotation

  """

  mix_mode: str = ...

  """

  Specify how the copied and existing rotations are combined

  * ``REPLACE``
Replace, Replace the original rotation with copied.

  * ``ADD``
Add, Add euler component values together.

  * ``BEFORE``
Before Original, Apply copied rotation before original, as if the constraint target is a parent.

  * ``AFTER``
After Original, Apply copied rotation after original, as if the constraint target is a child.

  * ``OFFSET``
Offset (Legacy), Combine rotations like the original Offset checkbox. Does not work well for multiple axis rotations.

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  use_offset: bool = ...

  """

  DEPRECATED: Add original rotation into copied rotation

  """

  use_x: bool = ...

  """

  Copy the target's X rotation

  """

  use_y: bool = ...

  """

  Copy the target's Y rotation

  """

  use_z: bool = ...

  """

  Copy the target's Z rotation

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CopyScaleConstraint(bpy_struct, Constraint):

  """

  Copy the scale of the target

  """

  power: float = ...

  """

  Raise the target's scale to the specified power

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  use_add: bool = ...

  """

  Use addition instead of multiplication to combine scale (2.7 compatibility)

  """

  use_make_uniform: bool = ...

  """

  Redistribute the copied change in volume equally between the three axes of the owner

  """

  use_offset: bool = ...

  """

  Combine original scale with copied scale

  """

  use_x: bool = ...

  """

  Copy the target's X scale

  """

  use_y: bool = ...

  """

  Copy the target's Y scale

  """

  use_z: bool = ...

  """

  Copy the target's Z scale

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CopyTransformsConstraint(bpy_struct, Constraint):

  """

  Copy all the transforms of the target

  """

  head_tail: float = ...

  """

  Target along length of bone: Head=0, Tail=1

  """

  mix_mode: str = ...

  """

  Specify how the copied and existing transformations are combined

  * ``REPLACE``
Replace, Replace the original transformation with copied.

  * ``BEFORE``
Before Original, Apply copied transformation before original, as if the constraint target is a parent. Scale is handled specially to avoid creating shear.

  * ``AFTER``
After Original, Apply copied transformation after original, as if the constraint target is a child. Scale is handled specially to avoid creating shear.

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  use_bbone_shape: bool = ...

  """

  Follow shape of B-Bone segments when calculating Head/Tail position

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DampedTrackConstraint(bpy_struct, Constraint):

  """

  Point toward target by taking the shortest rotation path

  """

  head_tail: float = ...

  """

  Target along length of bone: Head=0, Tail=1

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  track_axis: str = ...

  """

  Axis that points to the target object

  """

  use_bbone_shape: bool = ...

  """

  Follow shape of B-Bone segments when calculating Head/Tail position

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FloorConstraint(bpy_struct, Constraint):

  """

  Use the target object for location limitation

  """

  floor_location: str = ...

  """

  Location of target that object will not pass through

  """

  offset: float = ...

  """

  Offset of floor from object origin

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  use_rotation: bool = ...

  """

  Use the target's rotation to determine floor

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FollowPathConstraint(bpy_struct, Constraint):

  """

  Lock motion to the target path

  """

  forward_axis: str = ...

  """

  Axis that points forward along the path

  """

  offset: float = ...

  """

  Offset from the position corresponding to the time frame

  """

  offset_factor: float = ...

  """

  Percentage value defining target position along length of curve

  """

  target: Object = ...

  """

  Target Curve object

  """

  up_axis: str = ...

  """

  Axis that points upward

  """

  use_curve_follow: bool = ...

  """

  Object will follow the heading and banking of the curve

  """

  use_curve_radius: bool = ...

  """

  Object is scaled by the curve radius

  """

  use_fixed_location: bool = ...

  """

  Object will stay locked to a single point somewhere along the length of the curve regardless of time

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FollowTrackConstraint(bpy_struct, Constraint):

  """

  Lock motion to the target motion track

  """

  camera: Object = ...

  """

  Camera to which motion is parented (if empty active scene camera is used)

  """

  clip: MovieClip = ...

  """

  Movie Clip to get tracking data from

  """

  depth_object: Object = ...

  """

  Object used to define depth in camera space by projecting onto surface of this object

  """

  frame_method: str = ...

  """

  How the footage fits in the camera frame

  """

  object: str = ...

  """

  Movie tracking object to follow (if empty, camera object is used)

  """

  track: str = ...

  """

  Movie tracking track to follow

  """

  use_3d_position: bool = ...

  """

  Use 3D position of track to parent to

  """

  use_active_clip: bool = ...

  """

  Use active clip defined in scene

  """

  use_undistorted_position: bool = ...

  """

  Parent to undistorted position of 2D track

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class KinematicConstraint(bpy_struct, Constraint):

  """

  Inverse Kinematics

  """

  chain_count: int = ...

  """

  How many bones are included in the IK effect - 0 uses all bones

  """

  distance: float = ...

  """

  Radius of limiting sphere

  """

  ik_type: str = ...

  iterations: int = ...

  """

  Maximum number of solving iterations

  """

  limit_mode: str = ...

  """

  Distances in relation to sphere of influence to allow

  * ``LIMITDIST_INSIDE``
Inside, The object is constrained inside a virtual sphere around the target object, with a radius defined by the limit distance.

  * ``LIMITDIST_OUTSIDE``
Outside, The object is constrained outside a virtual sphere around the target object, with a radius defined by the limit distance.

  * ``LIMITDIST_ONSURFACE``
On Surface, The object is constrained on the surface of a virtual sphere around the target object, with a radius defined by the limit distance.

  """

  lock_location_x: bool = ...

  """

  Constraint position along X axis

  """

  lock_location_y: bool = ...

  """

  Constraint position along Y axis

  """

  lock_location_z: bool = ...

  """

  Constraint position along Z axis

  """

  lock_rotation_x: bool = ...

  """

  Constraint rotation along X axis

  """

  lock_rotation_y: bool = ...

  """

  Constraint rotation along Y axis

  """

  lock_rotation_z: bool = ...

  """

  Constraint rotation along Z axis

  """

  orient_weight: float = ...

  """

  For Tree-IK: Weight of orientation control for this target

  """

  pole_angle: float = ...

  """

  Pole rotation offset

  """

  pole_subtarget: str = ...

  pole_target: Object = ...

  """

  Object for pole rotation

  """

  reference_axis: str = ...

  """

  Constraint axis Lock options relative to Bone or Target reference

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  use_location: bool = ...

  """

  Chain follows position of target

  """

  use_rotation: bool = ...

  """

  Chain follows rotation of target

  """

  use_stretch: bool = ...

  """

  Enable IK Stretching

  """

  use_tail: bool = ...

  """

  Include bone's tail as last element in chain

  """

  weight: float = ...

  """

  For Tree-IK: Weight of position control for this target

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LimitDistanceConstraint(bpy_struct, Constraint):

  """

  Limit the distance from target object

  """

  distance: float = ...

  """

  Radius of limiting sphere

  """

  head_tail: float = ...

  """

  Target along length of bone: Head=0, Tail=1

  """

  limit_mode: str = ...

  """

  Distances in relation to sphere of influence to allow

  * ``LIMITDIST_INSIDE``
Inside, The object is constrained inside a virtual sphere around the target object, with a radius defined by the limit distance.

  * ``LIMITDIST_OUTSIDE``
Outside, The object is constrained outside a virtual sphere around the target object, with a radius defined by the limit distance.

  * ``LIMITDIST_ONSURFACE``
On Surface, The object is constrained on the surface of a virtual sphere around the target object, with a radius defined by the limit distance.

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  use_bbone_shape: bool = ...

  """

  Follow shape of B-Bone segments when calculating Head/Tail position

  """

  use_transform_limit: bool = ...

  """

  Transforms are affected by this constraint as well

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LimitLocationConstraint(bpy_struct, Constraint):

  """

  Limit the location of the constrained object

  """

  max_x: float = ...

  """

  Highest X value to allow

  """

  max_y: float = ...

  """

  Highest Y value to allow

  """

  max_z: float = ...

  """

  Highest Z value to allow

  """

  min_x: float = ...

  """

  Lowest X value to allow

  """

  min_y: float = ...

  """

  Lowest Y value to allow

  """

  min_z: float = ...

  """

  Lowest Z value to allow

  """

  use_max_x: bool = ...

  """

  Use the maximum X value

  """

  use_max_y: bool = ...

  """

  Use the maximum Y value

  """

  use_max_z: bool = ...

  """

  Use the maximum Z value

  """

  use_min_x: bool = ...

  """

  Use the minimum X value

  """

  use_min_y: bool = ...

  """

  Use the minimum Y value

  """

  use_min_z: bool = ...

  """

  Use the minimum Z value

  """

  use_transform_limit: bool = ...

  """

  Transforms are affected by this constraint as well

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LimitRotationConstraint(bpy_struct, Constraint):

  """

  Limit the rotation of the constrained object

  """

  max_x: float = ...

  """

  Highest X value to allow

  """

  max_y: float = ...

  """

  Highest Y value to allow

  """

  max_z: float = ...

  """

  Highest Z value to allow

  """

  min_x: float = ...

  """

  Lowest X value to allow

  """

  min_y: float = ...

  """

  Lowest Y value to allow

  """

  min_z: float = ...

  """

  Lowest Z value to allow

  """

  use_limit_x: bool = ...

  """

  Use the minimum X value

  """

  use_limit_y: bool = ...

  """

  Use the minimum Y value

  """

  use_limit_z: bool = ...

  """

  Use the minimum Z value

  """

  use_transform_limit: bool = ...

  """

  Transforms are affected by this constraint as well

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LimitScaleConstraint(bpy_struct, Constraint):

  """

  Limit the scaling of the constrained object

  """

  max_x: float = ...

  """

  Highest X value to allow

  """

  max_y: float = ...

  """

  Highest Y value to allow

  """

  max_z: float = ...

  """

  Highest Z value to allow

  """

  min_x: float = ...

  """

  Lowest X value to allow

  """

  min_y: float = ...

  """

  Lowest Y value to allow

  """

  min_z: float = ...

  """

  Lowest Z value to allow

  """

  use_max_x: bool = ...

  """

  Use the maximum X value

  """

  use_max_y: bool = ...

  """

  Use the maximum Y value

  """

  use_max_z: bool = ...

  """

  Use the maximum Z value

  """

  use_min_x: bool = ...

  """

  Use the minimum X value

  """

  use_min_y: bool = ...

  """

  Use the minimum Y value

  """

  use_min_z: bool = ...

  """

  Use the minimum Z value

  """

  use_transform_limit: bool = ...

  """

  Transforms are affected by this constraint as well

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LockedTrackConstraint(bpy_struct, Constraint):

  """

  Point toward the target along the track axis, while locking the other axis

  """

  head_tail: float = ...

  """

  Target along length of bone: Head=0, Tail=1

  """

  lock_axis: str = ...

  """

  Axis that points upward

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  track_axis: str = ...

  """

  Axis that points to the target object

  """

  use_bbone_shape: bool = ...

  """

  Follow shape of B-Bone segments when calculating Head/Tail position

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaintainVolumeConstraint(bpy_struct, Constraint):

  """

  Maintain a constant volume along a single scaling axis

  """

  free_axis: str = ...

  """

  The free scaling axis of the object

  """

  mode: str = ...

  """

  The way the constraint treats original non-free axis scaling

  * ``STRICT``
Strict, Volume is strictly preserved, overriding the scaling of non-free axes.

  * ``UNIFORM``
Uniform, Volume is preserved when the object is scaled uniformly. Deviations from uniform scale on non-free axes are passed through.

  * ``SINGLE_AXIS``
Single Axis, Volume is preserved when the object is scaled only on the free axis. Non-free axis scaling is passed through.

  """

  volume: float = ...

  """

  Volume of the bone at rest

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ObjectSolverConstraint(bpy_struct, Constraint):

  """

  Lock motion to the reconstructed object movement

  """

  camera: Object = ...

  """

  Camera to which motion is parented (if empty active scene camera is used)

  """

  clip: MovieClip = ...

  """

  Movie Clip to get tracking data from

  """

  object: str = ...

  """

  Movie tracking object to follow

  """

  set_inverse_pending: bool = ...

  """

  Set to true to request recalculation of the inverse matrix

  """

  use_active_clip: bool = ...

  """

  Use active clip defined in scene

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PivotConstraint(bpy_struct, Constraint):

  """

  Rotate around a different point

  """

  head_tail: float = ...

  """

  Target along length of bone: Head=0, Tail=1

  """

  offset: typing.Tuple[float, float, float] = ...

  """

  Offset of pivot from target (when set), or from owner's location (when Fixed Position is off), or the absolute pivot point

  """

  rotation_range: str = ...

  """

  Rotation range on which pivoting should occur

  * ``ALWAYS_ACTIVE``
Always, Use the pivot point in every rotation.

  * ``NX``
-X Rotation, Use the pivot point in the negative rotation range around the X-axis.

  * ``NY``
-Y Rotation, Use the pivot point in the negative rotation range around the Y-axis.

  * ``NZ``
-Z Rotation, Use the pivot point in the negative rotation range around the Z-axis.

  * ``X``
X Rotation, Use the pivot point in the positive rotation range around the X-axis.

  * ``Y``
Y Rotation, Use the pivot point in the positive rotation range around the Y-axis.

  * ``Z``
Z Rotation, Use the pivot point in the positive rotation range around the Z-axis.

  """

  subtarget: str = ...

  target: Object = ...

  """

  Target Object, defining the position of the pivot when defined

  """

  use_bbone_shape: bool = ...

  """

  Follow shape of B-Bone segments when calculating Head/Tail position

  """

  use_relative_location: bool = ...

  """

  Offset will be an absolute point in space instead of relative to the target

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PythonConstraint(bpy_struct, Constraint):

  """

  Use Python script for constraint evaluation

  """

  has_script_error: bool = ...

  """

  The linked Python script has thrown an error

  """

  target_count: int = ...

  """

  Usually only 1-3 are needed

  """

  targets: typing.Union[typing.Sequence[ConstraintTarget], typing.Mapping[str, ConstraintTarget], bpy_prop_collection] = ...

  """

  Target Objects

  """

  text: Text = ...

  """

  The text object that contains the Python script

  """

  use_targets: bool = ...

  """

  Use the targets indicated in the constraint panel

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShrinkwrapConstraint(bpy_struct, Constraint):

  """

  Create constraint-based shrinkwrap relationship

  """

  cull_face: str = ...

  """

  Stop vertices from projecting to a face on the target when facing towards/away

  * ``OFF``
Off, No culling.

  * ``FRONT``
Front, No projection when in front of the face.

  * ``BACK``
Back, No projection when behind the face.

  """

  distance: float = ...

  """

  Distance to Target

  """

  project_axis: str = ...

  """

  Axis constrain to

  """

  project_axis_space: str = ...

  """

  Space for the projection axis

  * ``WORLD``
World Space, The constraint is applied relative to the world coordinate system.

  * ``POSE``
Pose Space, The constraint is applied in Pose Space, the object transformation is ignored.

  * ``LOCAL_WITH_PARENT``
Local With Parent, The constraint is applied relative to the rest pose local coordinate system of the bone, thus including the parent-induced transformation.

  * ``LOCAL``
Local Space, The constraint is applied relative to the local coordinate system of the object.

  """

  project_limit: float = ...

  """

  Limit the distance used for projection (zero disables)

  """

  shrinkwrap_type: str = ...

  """

  Select type of shrinkwrap algorithm for target position

  * ``NEAREST_SURFACE``
Nearest Surface Point, Shrink the location to the nearest target surface.

  * ``PROJECT``
Project, Shrink the location to the nearest target surface along a given axis.

  * ``NEAREST_VERTEX``
Nearest Vertex, Shrink the location to the nearest target vertex.

  * ``TARGET_PROJECT``
Target Normal Project, Shrink the location to the nearest target surface along the interpolated vertex normals of the target.

  """

  target: Object = ...

  """

  Target Mesh object

  """

  track_axis: str = ...

  """

  Axis that is aligned to the normal

  """

  use_invert_cull: bool = ...

  """

  When projecting in the opposite direction invert the face cull mode

  """

  use_project_opposite: bool = ...

  """

  Project in both specified and opposite directions

  """

  use_track_normal: bool = ...

  """

  Align the specified axis to the surface normal

  """

  wrap_mode: str = ...

  """

  Select how to constrain the object to the target surface

  * ``ON_SURFACE``
On Surface, The point is constrained to the surface of the target object, with distance offset towards the original point location.

  * ``INSIDE``
Inside, The point is constrained to be inside the target object.

  * ``OUTSIDE``
Outside, The point is constrained to be outside the target object.

  * ``OUTSIDE_SURFACE``
Outside Surface, The point is constrained to the surface of the target object, with distance offset always to the outside, towards or away from the original location.

  * ``ABOVE_SURFACE``
Above Surface, The point is constrained to the surface of the target object, with distance offset applied exactly along the target normal.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SplineIKConstraint(bpy_struct, Constraint):

  """

  Align 'n' bones along a curve

  """

  bulge: float = ...

  """

  Factor between volume variation and stretching

  """

  bulge_max: float = ...

  """

  Maximum volume stretching factor

  """

  bulge_min: float = ...

  """

  Minimum volume stretching factor

  """

  bulge_smooth: float = ...

  """

  Strength of volume stretching clamping

  """

  chain_count: int = ...

  """

  How many bones are included in the chain

  """

  joint_bindings: typing.Tuple[float, ...] = ...

  """

  (EXPERIENCED USERS ONLY) The relative positions of the joints along the chain, as percentages

  """

  target: Object = ...

  """

  Curve that controls this relationship

  """

  use_bulge_max: bool = ...

  """

  Use upper limit for volume variation

  """

  use_bulge_min: bool = ...

  """

  Use lower limit for volume variation

  """

  use_chain_offset: bool = ...

  """

  Offset the entire chain relative to the root joint

  """

  use_curve_radius: bool = ...

  """

  Average radius of the endpoints is used to tweak the X and Z Scaling of the bones, on top of XZ Scale mode

  """

  use_even_divisions: bool = ...

  """

  Ignore the relative lengths of the bones when fitting to the curve

  """

  use_original_scale: bool = ...

  """

  Apply volume preservation over the original scaling

  """

  xz_scale_mode: str = ...

  """

  Method used for determining the scaling of the X and Z axes of the bones

  * ``NONE``
None, Don't scale the X and Z axes (Default).

  * ``BONE_ORIGINAL``
Bone Original, Use the original scaling of the bones.

  * ``INVERSE_PRESERVE``
Inverse Scale, Scale of the X and Z axes is the inverse of the Y-Scale.

  * ``VOLUME_PRESERVE``
Volume Preservation, Scale of the X and Z axes are adjusted to preserve the volume of the bones.

  """

  y_scale_mode: str = ...

  """

  Method used for determining the scaling of the Y axis of the bones, on top of the shape and scaling of the curve itself

  * ``NONE``
None, Don't scale in the Y axis.

  * ``FIT_CURVE``
Fit Curve, Scale the bones to fit the entire length of the curve.

  * ``BONE_ORIGINAL``
Bone Original, Use the original Y scale of the bone.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class StretchToConstraint(bpy_struct, Constraint):

  """

  Stretch to meet the target object

  """

  bulge: float = ...

  """

  Factor between volume variation and stretching

  """

  bulge_max: float = ...

  """

  Maximum volume stretching factor

  """

  bulge_min: float = ...

  """

  Minimum volume stretching factor

  """

  bulge_smooth: float = ...

  """

  Strength of volume stretching clamping

  """

  head_tail: float = ...

  """

  Target along length of bone: Head=0, Tail=1

  """

  keep_axis: str = ...

  """

  The rotation type and axis order to use

  * ``PLANE_X``
XZ, Rotate around local X, then Z.

  * ``PLANE_Z``
ZX, Rotate around local Z, then X.

  * ``SWING_Y``
Swing, Use the smallest single axis rotation, similar to Damped Track.

  """

  rest_length: float = ...

  """

  Length at rest position

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  use_bbone_shape: bool = ...

  """

  Follow shape of B-Bone segments when calculating Head/Tail position

  """

  use_bulge_max: bool = ...

  """

  Use upper limit for volume variation

  """

  use_bulge_min: bool = ...

  """

  Use lower limit for volume variation

  """

  volume: str = ...

  """

  Maintain the object's volume as it stretches

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TrackToConstraint(bpy_struct, Constraint):

  """

  Aim the constrained object toward the target

  """

  head_tail: float = ...

  """

  Target along length of bone: Head=0, Tail=1

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  track_axis: str = ...

  """

  Axis that points to the target object

  """

  up_axis: str = ...

  """

  Axis that points upward

  """

  use_bbone_shape: bool = ...

  """

  Follow shape of B-Bone segments when calculating Head/Tail position

  """

  use_target_z: bool = ...

  """

  Target's Z axis, not World Z axis, will constraint the Up direction

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TransformCacheConstraint(bpy_struct, Constraint):

  """

  Look up transformation from an external file

  """

  cache_file: CacheFile = ...

  object_path: str = ...

  """

  Path to the object in the Alembic archive used to lookup the transform matrix

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TransformConstraint(bpy_struct, Constraint):

  """

  Map transformations of the target to the object

  """

  from_max_x: float = ...

  """

  Top range of X axis source motion

  """

  from_max_x_rot: float = ...

  """

  Top range of X axis source motion

  """

  from_max_x_scale: float = ...

  """

  Top range of X axis source motion

  """

  from_max_y: float = ...

  """

  Top range of Y axis source motion

  """

  from_max_y_rot: float = ...

  """

  Top range of Y axis source motion

  """

  from_max_y_scale: float = ...

  """

  Top range of Y axis source motion

  """

  from_max_z: float = ...

  """

  Top range of Z axis source motion

  """

  from_max_z_rot: float = ...

  """

  Top range of Z axis source motion

  """

  from_max_z_scale: float = ...

  """

  Top range of Z axis source motion

  """

  from_min_x: float = ...

  """

  Bottom range of X axis source motion

  """

  from_min_x_rot: float = ...

  """

  Bottom range of X axis source motion

  """

  from_min_x_scale: float = ...

  """

  Bottom range of X axis source motion

  """

  from_min_y: float = ...

  """

  Bottom range of Y axis source motion

  """

  from_min_y_rot: float = ...

  """

  Bottom range of Y axis source motion

  """

  from_min_y_scale: float = ...

  """

  Bottom range of Y axis source motion

  """

  from_min_z: float = ...

  """

  Bottom range of Z axis source motion

  """

  from_min_z_rot: float = ...

  """

  Bottom range of Z axis source motion

  """

  from_min_z_scale: float = ...

  """

  Bottom range of Z axis source motion

  """

  from_rotation_mode: str = ...

  """

  Specify the type of rotation channels to use

  * ``AUTO``
Auto Euler, Euler using the rotation order of the target.

  * ``XYZ``
XYZ Euler, Euler using the XYZ rotation order.

  * ``XZY``
XZY Euler, Euler using the XZY rotation order.

  * ``YXZ``
YXZ Euler, Euler using the YXZ rotation order.

  * ``YZX``
YZX Euler, Euler using the YZX rotation order.

  * ``ZXY``
ZXY Euler, Euler using the ZXY rotation order.

  * ``ZYX``
ZYX Euler, Euler using the ZYX rotation order.

  * ``QUATERNION``
Quaternion, Quaternion rotation.

  * ``SWING_TWIST_X``
Swing and X Twist, Decompose into a swing rotation to aim the X axis, followed by twist around it.

  * ``SWING_TWIST_Y``
Swing and Y Twist, Decompose into a swing rotation to aim the Y axis, followed by twist around it.

  * ``SWING_TWIST_Z``
Swing and Z Twist, Decompose into a swing rotation to aim the Z axis, followed by twist around it.

  """

  map_from: str = ...

  """

  The transformation type to use from the target

  """

  map_to: str = ...

  """

  The transformation type to affect of the constrained object

  """

  map_to_x_from: str = ...

  """

  The source axis constrained object's X axis uses

  """

  map_to_y_from: str = ...

  """

  The source axis constrained object's Y axis uses

  """

  map_to_z_from: str = ...

  """

  The source axis constrained object's Z axis uses

  """

  mix_mode: str = ...

  """

  Specify how to combine the new location with original

  * ``REPLACE``
Replace, Replace component values.

  * ``ADD``
Add, Add component values together.

  """

  mix_mode_rot: str = ...

  """

  Specify how to combine the new rotation with original

  * ``REPLACE``
Replace, Replace component values.

  * ``ADD``
Add, Add component values together.

  * ``BEFORE``
Before Original, Apply new rotation before original, as if it was on a parent.

  * ``AFTER``
After Original, Apply new rotation after original, as if it was on a child.

  """

  mix_mode_scale: str = ...

  """

  Specify how to combine the new scale with original

  * ``REPLACE``
Replace, Replace component values.

  * ``MULTIPLY``
Multiply, Multiply component values together.

  """

  subtarget: str = ...

  """

  Armature bone, mesh or lattice vertex group, ...

  """

  target: Object = ...

  """

  Target object

  """

  to_euler_order: str = ...

  """

  Explicitly specify the output euler rotation order

  * ``AUTO``
Default, Euler using the default rotation order.

  * ``XYZ``
XYZ Euler, Euler using the XYZ rotation order.

  * ``XZY``
XZY Euler, Euler using the XZY rotation order.

  * ``YXZ``
YXZ Euler, Euler using the YXZ rotation order.

  * ``YZX``
YZX Euler, Euler using the YZX rotation order.

  * ``ZXY``
ZXY Euler, Euler using the ZXY rotation order.

  * ``ZYX``
ZYX Euler, Euler using the ZYX rotation order.

  """

  to_max_x: float = ...

  """

  Top range of X axis destination motion

  """

  to_max_x_rot: float = ...

  """

  Top range of X axis destination motion

  """

  to_max_x_scale: float = ...

  """

  Top range of X axis destination motion

  """

  to_max_y: float = ...

  """

  Top range of Y axis destination motion

  """

  to_max_y_rot: float = ...

  """

  Top range of Y axis destination motion

  """

  to_max_y_scale: float = ...

  """

  Top range of Y axis destination motion

  """

  to_max_z: float = ...

  """

  Top range of Z axis destination motion

  """

  to_max_z_rot: float = ...

  """

  Top range of Z axis destination motion

  """

  to_max_z_scale: float = ...

  """

  Top range of Z axis destination motion

  """

  to_min_x: float = ...

  """

  Bottom range of X axis destination motion

  """

  to_min_x_rot: float = ...

  """

  Bottom range of X axis destination motion

  """

  to_min_x_scale: float = ...

  """

  Bottom range of X axis destination motion

  """

  to_min_y: float = ...

  """

  Bottom range of Y axis destination motion

  """

  to_min_y_rot: float = ...

  """

  Bottom range of Y axis destination motion

  """

  to_min_y_scale: float = ...

  """

  Bottom range of Y axis destination motion

  """

  to_min_z: float = ...

  """

  Bottom range of Z axis destination motion

  """

  to_min_z_rot: float = ...

  """

  Bottom range of Z axis destination motion

  """

  to_min_z_scale: float = ...

  """

  Bottom range of Z axis destination motion

  """

  use_motion_extrapolate: bool = ...

  """

  Extrapolate ranges

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifierCycles(bpy_struct, FModifier):

  """

  Repeat the values of the modified F-Curve

  """

  cycles_after: int = ...

  """

  Maximum number of cycles to allow after last keyframe (0 = infinite)

  """

  cycles_before: int = ...

  """

  Maximum number of cycles to allow before first keyframe (0 = infinite)

  """

  mode_after: str = ...

  """

  Cycling mode to use after last keyframe

  * ``NONE``
No Cycles, Don't do anything.

  * ``REPEAT``
Repeat Motion, Repeat keyframe range as-is.

  * ``REPEAT_OFFSET``
Repeat with Offset, Repeat keyframe range, but with offset based on gradient between start and end values.

  * ``MIRROR``
Repeat Mirrored, Alternate between forward and reverse playback of keyframe range.

  """

  mode_before: str = ...

  """

  Cycling mode to use before first keyframe

  * ``NONE``
No Cycles, Don't do anything.

  * ``REPEAT``
Repeat Motion, Repeat keyframe range as-is.

  * ``REPEAT_OFFSET``
Repeat with Offset, Repeat keyframe range, but with offset based on gradient between start and end values.

  * ``MIRROR``
Repeat Mirrored, Alternate between forward and reverse playback of keyframe range.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifierEnvelope(bpy_struct, FModifier):

  """

  Scale the values of the modified F-Curve

  """

  control_points: typing.Union[FModifierEnvelopeControlPoints, typing.Sequence[FModifierEnvelopeControlPoint], typing.Mapping[str, FModifierEnvelopeControlPoint], bpy_prop_collection] = ...

  """

  Control points defining the shape of the envelope

  """

  default_max: float = ...

  """

  Upper distance from Reference Value for 1:1 default influence

  """

  default_min: float = ...

  """

  Lower distance from Reference Value for 1:1 default influence

  """

  reference_value: float = ...

  """

  Value that envelope's influence is centered around / based on

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifierFunctionGenerator(bpy_struct, FModifier):

  """

  Generate values using a Built-In Function

  """

  amplitude: float = ...

  """

  Scale factor determining the maximum/minimum values

  """

  function_type: str = ...

  """

  Type of built-in function to use

  * ``SIN``
Sine.

  * ``COS``
Cosine.

  * ``TAN``
Tangent.

  * ``SQRT``
Square Root.

  * ``LN``
Natural Logarithm.

  * ``SINC``
Normalized Sine, sin(x) / x.

  """

  phase_multiplier: float = ...

  """

  Scale factor determining the 'speed' of the function

  """

  phase_offset: float = ...

  """

  Constant factor to offset time by for function

  """

  use_additive: bool = ...

  """

  Values generated by this modifier are applied on top of the existing values instead of overwriting them

  """

  value_offset: float = ...

  """

  Constant factor to offset values by

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifierGenerator(bpy_struct, FModifier):

  """

  Deterministically generate values for the modified F-Curve

  """

  coefficients: typing.Tuple[float, ...] = ...

  """

  Coefficients for 'x' (starting from lowest power of x^0)

  """

  mode: str = ...

  """

  Type of generator to use

  """

  poly_order: int = ...

  """

  The highest power of 'x' for this polynomial (number of coefficients - 1)

  """

  use_additive: bool = ...

  """

  Values generated by this modifier are applied on top of the existing values instead of overwriting them

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifierLimits(bpy_struct, FModifier):

  """

  Limit the time/value ranges of the modified F-Curve

  """

  max_x: float = ...

  """

  Highest X value to allow

  """

  max_y: float = ...

  """

  Highest Y value to allow

  """

  min_x: float = ...

  """

  Lowest X value to allow

  """

  min_y: float = ...

  """

  Lowest Y value to allow

  """

  use_max_x: bool = ...

  """

  Use the maximum X value

  """

  use_max_y: bool = ...

  """

  Use the maximum Y value

  """

  use_min_x: bool = ...

  """

  Use the minimum X value

  """

  use_min_y: bool = ...

  """

  Use the minimum Y value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifierNoise(bpy_struct, FModifier):

  """

  Give randomness to the modified F-Curve

  """

  blend_type: str = ...

  """

  Method of modifying the existing F-Curve

  """

  depth: int = ...

  """

  Amount of fine level detail present in the noise

  """

  offset: float = ...

  """

  Time offset for the noise effect

  """

  phase: float = ...

  """

  A random seed for the noise effect

  """

  scale: float = ...

  """

  Scaling (in time) of the noise

  """

  strength: float = ...

  """

  Amplitude of the noise - the amount that it modifies the underlying curve

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifierPython(bpy_struct, FModifier):

  """

  Perform user-defined operation on the modified F-Curve

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FModifierStepped(bpy_struct, FModifier):

  """

  Hold each interpolated value from the F-Curve for several frames without changing the timing

  """

  frame_end: float = ...

  """

  Frame that modifier's influence ends (if applicable)

  """

  frame_offset: float = ...

  """

  Reference number of frames before frames get held (use to get hold for '1-3' vs '5-7' holding patterns)

  """

  frame_start: float = ...

  """

  Frame that modifier's influence starts (if applicable)

  """

  frame_step: float = ...

  """

  Number of frames to hold each value

  """

  use_frame_end: bool = ...

  """

  Restrict modifier to only act before its 'end' frame

  """

  use_frame_start: bool = ...

  """

  Restrict modifier to only act after its 'start' frame

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ArmatureGpencilModifier(bpy_struct, GpencilModifier):

  """

  Change stroke using armature to deform modifier

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  object: Object = ...

  """

  Armature object to deform with

  """

  use_bone_envelopes: bool = ...

  """

  Bind Bone envelopes to armature modifier

  """

  use_deform_preserve_volume: bool = ...

  """

  Deform rotation interpolation with quaternions

  """

  use_vertex_groups: bool = ...

  """

  Bind vertex groups to armature modifier

  """

  vertex_group: str = ...

  """

  Name of Vertex Group which determines influence of modifier per point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ArrayGpencilModifier(bpy_struct, GpencilModifier):

  """

  Create grid of duplicate instances

  """

  constant_offset: typing.Tuple[float, float, float] = ...

  """

  Value for the distance between items

  """

  count: int = ...

  """

  Number of items

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  offset_object: Object = ...

  """

  Use the location and rotation of another object to determine the distance and rotational change between arrayed items

  """

  pass_index: int = ...

  """

  Pass index

  """

  random_offset: typing.Tuple[float, float, float] = ...

  """

  Value for changes in location

  """

  random_rotation: typing.Tuple[float, float, float] = ...

  """

  Value for changes in rotation

  """

  random_scale: typing.Tuple[float, float, float] = ...

  """

  Value for changes in scale

  """

  relative_offset: typing.Tuple[float, float, float] = ...

  """

  The size of the geometry will determine the distance between arrayed items

  """

  replace_material: int = ...

  """

  Index of the material used for generated strokes (0 keep original material)

  """

  seed: int = ...

  """

  Random seed

  """

  use_constant_offset: bool = ...

  """

  Enable offset

  """

  use_object_offset: bool = ...

  """

  Enable object offset

  """

  use_relative_offset: bool = ...

  """

  Enable shift

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BuildGpencilModifier(bpy_struct, GpencilModifier):

  """

  Animate strokes appearing and disappearing

  """

  concurrent_time_alignment: str = ...

  """

  When should strokes start to appear/disappear

  * ``START``
Align Start, All strokes start at same time (i.e. short strokes finish earlier).

  * ``END``
Align End, All strokes end at same time (i.e. short strokes start later).

  """

  frame_end: float = ...

  """

  End Frame (when Restrict Frame Range is enabled)

  """

  frame_start: float = ...

  """

  Start Frame (when Restrict Frame Range is enabled)

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  length: float = ...

  """

  Maximum number of frames that the build effect can run for (unless another GP keyframe occurs before this time has elapsed)

  """

  mode: str = ...

  """

  How many strokes are being animated at a time

  * ``SEQUENTIAL``
Sequential, Strokes appear/disappear one after the other, but only a single one changes at a time.

  * ``CONCURRENT``
Concurrent, Multiple strokes appear/disappear at once.

  """

  percentage_factor: float = ...

  """

  Defines how much of the stroke is visible

  """

  start_delay: float = ...

  """

  Number of frames after each GP keyframe before the modifier has any effect

  """

  transition: str = ...

  """

  How are strokes animated (i.e. are they appearing or disappearing)

  * ``GROW``
Grow, Show points in the order they occur in each stroke (e.g. for animating lines being drawn).

  * ``SHRINK``
Shrink, Hide points from the end of each stroke to the start (e.g. for animating lines being erased).

  * ``FADE``
Fade, Hide points in the order they occur in each stroke (e.g. for animating ink fading or vanishing after getting drawn).

  """

  use_percentage: bool = ...

  """

  Use a percentage factor to determine the visible points

  """

  use_restrict_frame_range: bool = ...

  """

  Only modify strokes during the specified frame range

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorGpencilModifier(bpy_struct, GpencilModifier):

  """

  Change Hue/Saturation modifier

  """

  curve: CurveMapping = ...

  """

  Custom curve to apply effect

  """

  hue: float = ...

  """

  Color Hue

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  modify_color: str = ...

  """

  Set what colors of the stroke are affected

  * ``BOTH``
Stroke and Fill, Modify fill and stroke colors.

  * ``STROKE``
Stroke, Modify stroke color only.

  * ``FILL``
Fill, Modify fill color only.

  """

  pass_index: int = ...

  """

  Pass index

  """

  saturation: float = ...

  """

  Color Saturation

  """

  use_custom_curve: bool = ...

  """

  Use a custom curve to define color effect along the strokes

  """

  value: float = ...

  """

  Color Value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class HookGpencilModifier(bpy_struct, GpencilModifier):

  """

  Hook modifier to modify the location of stroke points

  """

  center: typing.Tuple[float, float, float] = ...

  falloff_curve: CurveMapping = ...

  """

  Custom light falloff curve

  """

  falloff_radius: float = ...

  """

  If not zero, the distance from the hook where influence ends

  """

  falloff_type: str = ...

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  invert_vertex: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  matrix_inverse: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Reverse the transformation between this object and its target

  """

  object: Object = ...

  """

  Parent Object for hook, also recalculates and clears offset

  """

  pass_index: int = ...

  """

  Pass index

  """

  strength: float = ...

  """

  Relative force of the hook

  """

  subtarget: str = ...

  """

  Name of Parent Bone for hook (if applicable), also recalculates and clears offset

  """

  use_falloff_uniform: bool = ...

  """

  Compensate for non-uniform object scale

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the deform

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LatticeGpencilModifier(bpy_struct, GpencilModifier):

  """

  Change stroke using lattice to deform modifier

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  invert_vertex: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  object: Object = ...

  """

  Lattice object to deform with

  """

  pass_index: int = ...

  """

  Pass index

  """

  strength: float = ...

  """

  Strength of modifier effect

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the deform

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MirrorGpencilModifier(bpy_struct, GpencilModifier):

  """

  Create mirroring strokes

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  object: Object = ...

  """

  Object used as center

  """

  pass_index: int = ...

  """

  Pass index

  """

  use_axis_x: bool = ...

  """

  Mirror the X axis

  """

  use_axis_y: bool = ...

  """

  Mirror the Y axis

  """

  use_axis_z: bool = ...

  """

  Mirror the Z axis

  """

  use_clip: bool = ...

  """

  Clip points

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MultiplyGpencilModifier(bpy_struct, GpencilModifier):

  """

  Generate multiple strokes from one stroke

  """

  distance: float = ...

  """

  Distance of duplications

  """

  duplicates: int = ...

  """

  How many copies of strokes be displayed

  """

  enable_angle_splitting: bool = ...

  """

  Enable angle splitting

  """

  fading_center: float = ...

  """

  Fade center

  """

  fading_opacity: float = ...

  """

  Fade influence of stroke's opacity

  """

  fading_thickness: float = ...

  """

  Fade influence of stroke's thickness

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  offset: float = ...

  """

  Offset of duplicates. -1 to 1: inner to outer

  """

  pass_index: int = ...

  """

  Pass index

  """

  split_angle: float = ...

  """

  Split angle for segments

  """

  use_fade: bool = ...

  """

  Fade the stroke thickness for each generated stroke

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NoiseGpencilModifier(bpy_struct, GpencilModifier):

  """

  Noise effect modifier

  """

  curve: CurveMapping = ...

  """

  Custom curve to apply effect

  """

  factor: float = ...

  """

  Amount of noise to apply

  """

  factor_strength: float = ...

  """

  Amount of noise to apply to opacity

  """

  factor_thickness: float = ...

  """

  Amount of noise to apply to thickness

  """

  factor_uvs: float = ...

  """

  Amount of noise to apply uv rotation

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  invert_vertex: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  noise_scale: float = ...

  """

  Scale the noise frequency

  """

  pass_index: int = ...

  """

  Pass index

  """

  random: bool = ...

  """

  Use random values over time

  """

  seed: int = ...

  """

  Random seed

  """

  step: int = ...

  """

  Number of frames before recalculate random values again

  """

  use_custom_curve: bool = ...

  """

  Use a custom curve to define noise effect along the strokes

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the deform

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class OffsetGpencilModifier(bpy_struct, GpencilModifier):

  """

  Offset Stroke modifier

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  invert_vertex: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  location: typing.Tuple[float, float, float] = ...

  """

  Values for change location

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  pass_index: int = ...

  """

  Pass index

  """

  rotation: typing.Tuple[float, float, float] = ...

  """

  Values for changes in rotation

  """

  scale: typing.Tuple[float, float, float] = ...

  """

  Values for changes in scale

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the deform

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class OpacityGpencilModifier(bpy_struct, GpencilModifier):

  """

  Opacity of Strokes modifier

  """

  curve: CurveMapping = ...

  """

  Custom curve to apply effect

  """

  factor: float = ...

  """

  Factor of Opacity

  """

  hardness: float = ...

  """

  Factor of stroke hardness

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  invert_vertex: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  modify_color: str = ...

  """

  Set what colors of the stroke are affected

  * ``BOTH``
Stroke and Fill, Modify fill and stroke colors.

  * ``STROKE``
Stroke, Modify stroke color only.

  * ``FILL``
Fill, Modify fill color only.

  * ``HARDNESS``
Hardness, Modify stroke hardness.

  """

  normalize_opacity: bool = ...

  """

  Replace the stroke opacity

  """

  pass_index: int = ...

  """

  Pass index

  """

  use_custom_curve: bool = ...

  """

  Use a custom curve to define opacity effect along the strokes

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the deform

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SimplifyGpencilModifier(bpy_struct, GpencilModifier):

  """

  Simplify Stroke modifier

  """

  distance: float = ...

  """

  Distance between points

  """

  factor: float = ...

  """

  Factor of Simplify

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  length: float = ...

  """

  Length of each segment

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  mode: str = ...

  """

  How to simplify the stroke

  * ``FIXED``
Fixed, Delete alternating vertices in the stroke, except extremes.

  * ``ADAPTIVE``
Adaptive, Use a Ramer-Douglas-Peucker algorithm to simplify the stroke preserving main shape.

  * ``SAMPLE``
Sample, Re-sample the stroke with segments of the specified length.

  * ``MERGE``
Merge, Simplify the stroke by merging vertices closer than a given distance.

  """

  pass_index: int = ...

  """

  Pass index

  """

  step: int = ...

  """

  Number of times to apply simplify

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SmoothGpencilModifier(bpy_struct, GpencilModifier):

  """

  Smooth effect modifier

  """

  curve: CurveMapping = ...

  """

  Custom curve to apply effect

  """

  factor: float = ...

  """

  Amount of smooth to apply

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  invert_vertex: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  pass_index: int = ...

  """

  Pass index

  """

  step: int = ...

  """

  Number of times to apply smooth (high numbers can reduce fps)

  """

  use_custom_curve: bool = ...

  """

  Use a custom curve to define smooth effect along the strokes

  """

  use_edit_position: bool = ...

  """

  The modifier affects the position of the point

  """

  use_edit_strength: bool = ...

  """

  The modifier affects the color strength of the point

  """

  use_edit_thickness: bool = ...

  """

  The modifier affects the thickness of the point

  """

  use_edit_uv: bool = ...

  """

  The modifier affects the UV rotation factor of the point

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the deform

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SubdivGpencilModifier(bpy_struct, GpencilModifier):

  """

  Subdivide Stroke modifier

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  level: int = ...

  """

  Number of subdivisions

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  pass_index: int = ...

  """

  Pass index

  """

  subdivision_type: str = ...

  """

  Select type of subdivision algorithm

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureGpencilModifier(bpy_struct, GpencilModifier):

  """

  Transform stroke texture coordinates Modifier

  """

  fill_offset: typing.Tuple[float, float] = ...

  """

  Additional offset of the fill UV

  """

  fill_rotation: float = ...

  """

  Additional rotation of the fill UV

  """

  fill_scale: float = ...

  """

  Additional scale of the fill UV

  """

  fit_method: str = ...

  """

  * ``CONSTANT_LENGTH``
Constant Length, Keep the texture at a constant length regardless of the length of each stroke.

  * ``FIT_STROKE``
Stroke Length, Scale the texture to fit the length of each stroke.

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  invert_vertex: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  mode: str = ...

  """

  * ``STROKE``
Stroke, Manipulate only stroke texture coordinates.

  * ``FILL``
Fill, Manipulate only fill texture coordinates.

  * ``STROKE_AND_FILL``
Stroke and Fill, Manipulate both stroke and fill texture coordinates.

  """

  pass_index: int = ...

  """

  Pass index

  """

  uv_offset: float = ...

  """

  Offset value to add to stroke UVs

  """

  uv_scale: float = ...

  """

  Factor to scale the UVs

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the deform

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ThickGpencilModifier(bpy_struct, GpencilModifier):

  """

  Subdivide and Smooth Stroke modifier

  """

  curve: CurveMapping = ...

  """

  Custom curve to apply effect

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  invert_vertex: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  normalize_thickness: bool = ...

  """

  Replace the stroke thickness

  """

  pass_index: int = ...

  """

  Pass index

  """

  thickness: int = ...

  """

  Absolute thickness to apply everywhere

  """

  thickness_factor: float = ...

  """

  Factor to multiply the thickness with

  """

  use_custom_curve: bool = ...

  """

  Use a custom curve to define thickness change along the strokes

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the deform

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TimeGpencilModifier(bpy_struct, GpencilModifier):

  """

  Time offset modifier

  """

  frame_end: int = ...

  """

  Final frame of the range

  """

  frame_scale: float = ...

  """

  Evaluation time in seconds

  """

  frame_start: int = ...

  """

  First frame of the range

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  mode: str = ...

  """

  * ``NORMAL``
Regular, Apply offset in usual animation direction.

  * ``REVERSE``
Reverse, Apply offset in reverse animation direction.

  * ``FIX``
Fixed Frame, Keep frame and do not change with time.

  """

  offset: int = ...

  """

  Number of frames to offset original keyframe number or frame to fix

  """

  use_custom_frame_range: bool = ...

  """

  Define a custom range of frames to use in modifier

  """

  use_keep_loop: bool = ...

  """

  Retiming end frames and move to start of animation to keep loop

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TintGpencilModifier(bpy_struct, GpencilModifier):

  """

  Tint modifier

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Color used for tinting

  """

  colors: ColorRamp = ...

  """

  Color ramp used to define tinting colors

  """

  curve: CurveMapping = ...

  """

  Custom curve to apply effect

  """

  factor: float = ...

  """

  Factor for tinting

  """

  invert_layer_pass: bool = ...

  """

  Inverse filter

  """

  invert_layers: bool = ...

  """

  Inverse filter

  """

  invert_material_pass: bool = ...

  """

  Inverse filter

  """

  invert_materials: bool = ...

  """

  Inverse filter

  """

  invert_vertex: bool = ...

  """

  Inverse filter

  """

  layer: str = ...

  """

  Layer name

  """

  layer_pass: int = ...

  """

  Layer pass index

  """

  material: Material = ...

  """

  Material used for filtering effect

  """

  object: Object = ...

  """

  Parent object to define the center of the effect

  """

  pass_index: int = ...

  """

  Pass index

  """

  radius: float = ...

  """

  Defines the maximum distance of the effect

  """

  tint_type: str = ...

  """

  Select type of tinting algorithm

  """

  use_custom_curve: bool = ...

  """

  Use a custom curve to define vertex color effect along the strokes

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the deform

  """

  vertex_mode: str = ...

  """

  Defines how vertex color affect to the strokes

  * ``STROKE``
Stroke, Vertex Color affects to Stroke only.

  * ``FILL``
Fill, Vertex Color affects to Fill only.

  * ``BOTH``
Stroke and Fill, Vertex Color affects to Stroke and Fill.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Action(bpy_struct, ID):

  """

  A collection of F-Curves for animation

  """

  fcurves: typing.Union[ActionFCurves, typing.Sequence[FCurve], typing.Mapping[str, FCurve], bpy_prop_collection] = ...

  """

  The individual F-Curves that make up the action

  """

  frame_range: typing.Tuple[float, float] = ...

  """

  The final frame range of all F-Curves within this action

  """

  groups: typing.Union[ActionGroups, typing.Sequence[ActionGroup], typing.Mapping[str, ActionGroup], bpy_prop_collection] = ...

  """

  Convenient groupings of F-Curves

  """

  id_root: str = ...

  """

  Type of ID block that action can be used on - DO NOT CHANGE UNLESS YOU KNOW WHAT YOU ARE DOING

  """

  pose_markers: typing.Union[ActionPoseMarkers, typing.Sequence[TimelineMarker], typing.Mapping[str, TimelineMarker], bpy_prop_collection] = ...

  """

  Markers specific to this action, for labeling poses

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Armature(bpy_struct, ID):

  """

  Armature data-block containing a hierarchy of bones, usually used for rigging characters

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  bones: typing.Union[ArmatureBones, typing.Sequence[Bone], typing.Mapping[str, Bone], bpy_prop_collection] = ...

  display_type: str = ...

  """

  * ``OCTAHEDRAL``
Octahedral, Display bones as octahedral shape (default).

  * ``STICK``
Stick, Display bones as simple 2D lines with dots.

  * ``BBONE``
B-Bone, Display bones as boxes, showing subdivision and B-Splines.

  * ``ENVELOPE``
Envelope, Display bones as extruded spheres, showing deformation influence volume.

  * ``WIRE``
Wire, Display bones as thin wires, showing subdivision and B-Splines.

  """

  edit_bones: typing.Union[ArmatureEditBones, typing.Sequence[EditBone], typing.Mapping[str, EditBone], bpy_prop_collection] = ...

  is_editmode: bool = ...

  """

  True when used in editmode

  """

  layers: typing.Tuple[bool, ...] = ...

  """

  Armature layer visibility

  """

  layers_protected: typing.Tuple[bool, ...] = ...

  """

  Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo

  """

  pose_position: str = ...

  """

  Show armature in binding pose or final posed state

  * ``POSE``
Pose Position, Show armature in posed state.

  * ``REST``
Rest Position, Show Armature in binding pose state (no posing possible).

  """

  show_axes: bool = ...

  """

  Display bone axes

  """

  show_bone_custom_shapes: bool = ...

  """

  Display bones with their custom shapes

  """

  show_group_colors: bool = ...

  """

  Display bone group colors

  """

  show_names: bool = ...

  """

  Display bone names

  """

  use_mirror_x: bool = ...

  """

  Apply changes to matching bone on opposite side of X-Axis

  """

  def transform(self, matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]]) -> None:

    """

    Transform armature bones by a matrix

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Brush(bpy_struct, ID):

  """

  Brush data-block for storing brush settings for painting and sculpting

  """

  area_radius_factor: float = ...

  """

  Ratio between the brush radius and the radius that is going to be used to sample the area center

  """

  auto_smooth_factor: float = ...

  """

  Amount of smoothing to automatically apply to each stroke

  """

  automasking_boundary_edges_propagation_steps: int = ...

  """

  Distance where boundary edge automasking is going to protect vertices from the fully masked edge

  """

  blend: str = ...

  """

  Brush blending mode

  * ``MIX``
Mix, Use Mix blending mode while painting.

  * ``DARKEN``
Darken, Use Darken blending mode while painting.

  * ``MUL``
Multiply, Use Multiply blending mode while painting.

  * ``COLORBURN``
Color Burn, Use Color Burn blending mode while painting.

  * ``LINEARBURN``
Linear Burn, Use Linear Burn blending mode while painting.

  * ``LIGHTEN``
Lighten, Use Lighten blending mode while painting.

  * ``SCREEN``
Screen, Use Screen blending mode while painting.

  * ``COLORDODGE``
Color Dodge, Use Color Dodge blending mode while painting.

  * ``ADD``
Add, Use Add blending mode while painting.

  * ``OVERLAY``
Overlay, Use Overlay blending mode while painting.

  * ``SOFTLIGHT``
Soft Light, Use Soft Light blending mode while painting.

  * ``HARDLIGHT``
Hard Light, Use Hard Light blending mode while painting.

  * ``VIVIDLIGHT``
Vivid Light, Use Vivid Light blending mode while painting.

  * ``LINEARLIGHT``
Linear Light, Use Linear Light blending mode while painting.

  * ``PINLIGHT``
Pin Light, Use Pin Light blending mode while painting.

  * ``DIFFERENCE``
Difference, Use Difference blending mode while painting.

  * ``EXCLUSION``
Exclusion, Use Exclusion blending mode while painting.

  * ``SUB``
Subtract, Use Subtract blending mode while painting.

  * ``HUE``
Hue, Use Hue blending mode while painting.

  * ``SATURATION``
Saturation, Use Saturation blending mode while painting.

  * ``COLOR``
Color, Use Color blending mode while painting.

  * ``LUMINOSITY``
Value, Use Value blending mode while painting.

  * ``ERASE_ALPHA``
Erase Alpha, Erase alpha while painting.

  * ``ADD_ALPHA``
Add Alpha, Add alpha while painting.

  """

  blur_kernel_radius: int = ...

  """

  Radius of kernel used for soften and sharpen in pixels

  """

  blur_mode: str = ...

  boundary_deform_type: str = ...

  """

  Deformation type that is used in the brush

  """

  boundary_falloff_type: str = ...

  """

  How the brush falloff is applied across the boundary

  * ``CONSTANT``
Constant, Applies the same deformation in the entire boundary.

  * ``RADIUS``
Brush Radius, Applies the deformation in a localized area limited by the brush radius.

  * ``LOOP``
Loop, Applies the brush falloff in a loop pattern.

  * ``LOOP_INVERT``
Loop and Invert, Applies the falloff radius in a loop pattern, inverting the displacement direction in each pattern repetition.

  """

  boundary_offset: float = ...

  """

  Offset of the boundary origin in relation to the brush radius

  """

  brush_capabilities: BrushCapabilities = ...

  """

  Brush's capabilities

  """

  clone_alpha: float = ...

  """

  Opacity of clone image display

  """

  clone_image: Image = ...

  """

  Image for clone tool

  """

  clone_offset: typing.Tuple[float, float] = ...

  cloth_constraint_softbody_strength: float = ...

  """

  How much the cloth preserves the original shape, acting as a soft body

  """

  cloth_damping: float = ...

  """

  How much the applied forces are propagated through the cloth

  """

  cloth_deform_type: str = ...

  """

  Deformation type that is used in the brush

  """

  cloth_force_falloff_type: str = ...

  """

  Shape used in the brush to apply force to the cloth

  """

  cloth_mass: float = ...

  """

  Mass of each simulation particle

  """

  cloth_sim_falloff: float = ...

  """

  Area to apply deformation falloff to the effects of the simulation

  """

  cloth_sim_limit: float = ...

  """

  Factor added relative to the size of the radius to limit the cloth simulation effects

  """

  cloth_simulation_area_type: str = ...

  """

  Part of the mesh that is going to be simulated when the stroke is active

  * ``LOCAL``
Local, Simulates only a specific area around the brush limited by a fixed radius.

  * ``GLOBAL``
Global, Simulates the entire mesh.

  * ``DYNAMIC``
Dynamic, The active simulation area moves with the brush.

  """

  color: typing.Tuple[float, float, float] = ...

  color_type: str = ...

  """

  Use single color or gradient when painting

  * ``COLOR``
Color, Paint with a single color.

  * ``GRADIENT``
Gradient, Paint with a gradient.

  """

  crease_pinch_factor: float = ...

  """

  How much the crease brush pinches

  """

  cursor_color_add: typing.Tuple[float, float, float, float] = ...

  """

  Color of cursor when adding

  """

  cursor_color_subtract: typing.Tuple[float, float, float, float] = ...

  """

  Color of cursor when subtracting

  """

  cursor_overlay_alpha: int = ...

  curve: CurveMapping = ...

  """

  Editable falloff curve

  """

  curve_preset: str = ...

  dash_ratio: float = ...

  """

  Ratio of samples in a cycle that the brush is enabled

  """

  dash_samples: int = ...

  """

  Length of a dash cycle measured in stroke samples

  """

  deform_target: str = ...

  """

  How the deformation of the brush will affect the object

  * ``GEOMETRY``
Geometry, Brush deformation displaces the vertices of the mesh.

  * ``CLOTH_SIM``
Cloth Simulation, Brush deforms the mesh by deforming the constraints of a cloth simulation.

  """

  density: float = ...

  """

  Amount of random elements that are going to be affected by the brush

  """

  direction: str = ...

  """

  * ``ADD``
Add, Add effect of brush.

  * ``SUBTRACT``
Subtract, Subtract effect of brush.

  """

  disconnected_distance_max: float = ...

  """

  Maximum distance to search for disconnected loose parts in the mesh

  """

  elastic_deform_type: str = ...

  """

  Deformation type that is used in the brush

  """

  elastic_deform_volume_preservation: float = ...

  """

  Poisson ratio for elastic deformation. Higher values preserve volume more, but also lead to more bulging

  """

  falloff_angle: float = ...

  """

  Paint most on faces pointing towards the view according to this angle

  """

  falloff_shape: str = ...

  """

  Use projected or spherical falloff

  * ``SPHERE``
Sphere, Apply brush influence in a Sphere, outwards from the center.

  * ``PROJECTED``
Projected, Apply brush influence in a 2D circle, projected from the view.

  """

  fill_threshold: float = ...

  """

  Threshold above which filling is not propagated

  """

  flow: float = ...

  """

  Amount of paint that is applied per stroke sample

  """

  gpencil_sculpt_tool: str = ...

  """

  * ``SMOOTH``
Smooth, Smooth stroke points.

  * ``THICKNESS``
Thickness, Adjust thickness of strokes.

  * ``STRENGTH``
Strength, Adjust color strength of strokes.

  * ``RANDOMIZE``
Randomize, Introduce jitter/randomness into strokes.

  * ``GRAB``
Grab, Translate the set of points initially within the brush circle.

  * ``PUSH``
Push, Move points out of the way, as if combing them.

  * ``TWIST``
Twist, Rotate points around the midpoint of the brush.

  * ``PINCH``
Pinch, Pull points towards the midpoint of the brush.

  * ``CLONE``
Clone, Paste copies of the strokes stored on the clipboard.

  """

  gpencil_settings: BrushGpencilSettings = ...

  gpencil_tool: str = ...

  """

  * ``DRAW``
Draw, The brush is of type used for drawing strokes.

  * ``FILL``
Fill, The brush is of type used for filling areas.

  * ``ERASE``
Erase, The brush is used for erasing strokes.

  * ``TINT``
Tint, The brush is of type used for tinting strokes.

  """

  gpencil_vertex_tool: str = ...

  gpencil_weight_tool: str = ...

  """

  * ``WEIGHT``
Weight, Weight Paint for Vertex Groups.

  """

  grad_spacing: int = ...

  """

  Spacing before brush gradient goes full circle

  """

  gradient: ColorRamp = ...

  gradient_fill_mode: str = ...

  gradient_stroke_mode: str = ...

  hardness: float = ...

  """

  How close the brush falloff starts from the edge of the brush

  """

  height: float = ...

  """

  Affectable height of brush (layer height for layer tool, i.e.)

  """

  icon_filepath: str = ...

  """

  File path to brush icon

  """

  image_paint_capabilities: BrushCapabilitiesImagePaint = ...

  image_tool: str = ...

  invert_density_pressure: bool = ...

  """

  Invert the modulation of pressure in density

  """

  invert_flow_pressure: bool = ...

  """

  Invert the modulation of pressure in flow

  """

  invert_hardness_pressure: bool = ...

  """

  Invert the modulation of pressure in hardness

  """

  invert_to_scrape_fill: bool = ...

  """

  Use Scrape or Fill tool when inverting this brush instead of inverting its displacement direction

  """

  invert_wet_mix_pressure: bool = ...

  """

  Invert the modulation of pressure in wet mix

  """

  invert_wet_persistence_pressure: bool = ...

  """

  Invert the modulation of pressure in wet persistence

  """

  jitter: float = ...

  """

  Jitter the position of the brush while painting

  """

  jitter_absolute: int = ...

  """

  Jitter the position of the brush in pixels while painting

  """

  jitter_unit: str = ...

  """

  Jitter in screen space or relative to brush size

  * ``VIEW``
View, Jittering happens in screen space, in pixels.

  * ``BRUSH``
Brush, Jittering happens relative to the brush size.

  """

  mask_overlay_alpha: int = ...

  mask_stencil_dimension: typing.Tuple[float, float] = ...

  """

  Dimensions of mask stencil in viewport

  """

  mask_stencil_pos: typing.Tuple[float, float] = ...

  """

  Position of mask stencil in viewport

  """

  mask_texture: Texture = ...

  mask_texture_slot: BrushTextureSlot = ...

  mask_tool: str = ...

  multiplane_scrape_angle: float = ...

  """

  Angle between the planes of the crease

  """

  normal_radius_factor: float = ...

  """

  Ratio between the brush radius and the radius that is going to be used to sample the normal

  """

  normal_weight: float = ...

  """

  How much grab will pull vertexes out of surface during a grab

  """

  paint_curve: PaintCurve = ...

  """

  Active Paint Curve

  """

  plane_offset: float = ...

  """

  Adjust plane on which the brush acts towards or away from the object surface

  """

  plane_trim: float = ...

  """

  If a vertex is further away from offset plane than this, then it is not affected

  """

  pose_deform_type: str = ...

  """

  Deformation type that is used in the brush

  """

  pose_ik_segments: int = ...

  """

  Number of segments of the inverse kinematics chain that will deform the mesh

  """

  pose_offset: float = ...

  """

  Offset of the pose origin in relation to the brush radius

  """

  pose_origin_type: str = ...

  """

  Method to set the rotation origins for the segments of the brush

  * ``TOPOLOGY``
Topology, Sets the rotation origin automatically using the topology and shape of the mesh as a guide.

  * ``FACE_SETS``
Face Sets, Creates a pose segment per face sets, starting from the active face set.

  * ``FACE_SETS_FK``
Face Sets FK, Simulates an FK deformation using the Face Set under the cursor as control.

  """

  pose_smooth_iterations: int = ...

  """

  Smooth iterations applied after calculating the pose factor of each vertex

  """

  rake_factor: float = ...

  """

  How much grab will follow cursor rotation

  """

  rate: float = ...

  """

  Interval between paints for Airbrush

  """

  sculpt_capabilities: BrushCapabilitiesSculpt = ...

  sculpt_plane: str = ...

  sculpt_tool: str = ...

  secondary_color: typing.Tuple[float, float, float] = ...

  sharp_threshold: float = ...

  """

  Threshold below which, no sharpening is done

  """

  show_multiplane_scrape_planes_preview: bool = ...

  """

  Preview the scrape planes in the cursor during the stroke

  """

  size: int = ...

  """

  Radius of the brush in pixels

  """

  slide_deform_type: str = ...

  """

  Deformation type that is used in the brush

  """

  smear_deform_type: str = ...

  """

  Deformation type that is used in the brush

  """

  smooth_deform_type: str = ...

  """

  Deformation type that is used in the brush

  * ``LAPLACIAN``
Laplacian, Smooths the surface and the volume.

  * ``SURFACE``
Surface, Smooths the surface of the mesh, preserving the volume.

  """

  smooth_stroke_factor: float = ...

  """

  Higher values give a smoother stroke

  """

  smooth_stroke_radius: int = ...

  """

  Minimum distance from last point before stroke continues

  """

  spacing: int = ...

  """

  Spacing between brush daubs as a percentage of brush diameter

  """

  stencil_dimension: typing.Tuple[float, float] = ...

  """

  Dimensions of stencil in viewport

  """

  stencil_pos: typing.Tuple[float, float] = ...

  """

  Position of stencil in viewport

  """

  strength: float = ...

  """

  How powerful the effect of the brush is when applied

  """

  stroke_method: str = ...

  """

  * ``DOTS``
Dots, Apply paint on each mouse move step.

  * ``DRAG_DOT``
Drag Dot, Allows a single dot to be carefully positioned.

  * ``SPACE``
Space, Limit brush application to the distance specified by spacing.

  * ``AIRBRUSH``
Airbrush, Keep applying paint effect while holding mouse (spray).

  * ``ANCHORED``
Anchored, Keep the brush anchored to the initial location.

  * ``LINE``
Line, Draw a line with dabs separated according to spacing.

  * ``CURVE``
Curve, Define the stroke curve with a bezier curve (dabs are separated according to spacing).

  """

  surface_smooth_current_vertex: float = ...

  """

  How much the position of each individual vertex influences the final result

  """

  surface_smooth_iterations: int = ...

  """

  Number of smoothing iterations per brush step

  """

  surface_smooth_shape_preservation: float = ...

  """

  How much of the original shape is preserved when smoothing

  """

  texture: Texture = ...

  texture_overlay_alpha: int = ...

  texture_sample_bias: float = ...

  """

  Value added to texture samples

  """

  texture_slot: BrushTextureSlot = ...

  tilt_strength_factor: float = ...

  """

  How much the tilt of the pen will affect the brush

  """

  tip_roundness: float = ...

  """

  Roundness of the brush tip

  """

  tip_scale_x: float = ...

  """

  Scale of the brush tip in the X axis

  """

  topology_rake_factor: float = ...

  """

  Automatically align edges to the brush direction to generate cleaner topology and define sharp features. Best used on low-poly meshes as it has a performance impact

  """

  unprojected_radius: float = ...

  """

  Radius of brush in Blender units

  """

  use_accumulate: bool = ...

  """

  Accumulate stroke daubs on top of each other

  """

  use_adaptive_space: bool = ...

  """

  Space daubs according to surface orientation instead of screen space

  """

  use_airbrush: bool = ...

  """

  Keep applying paint effect while holding mouse (spray)

  """

  use_alpha: bool = ...

  """

  When this is disabled, lock alpha while painting

  """

  use_anchor: bool = ...

  """

  Keep the brush anchored to the initial location

  """

  use_automasking_boundary_edges: bool = ...

  """

  Do not affect non manifold boundary edges

  """

  use_automasking_boundary_face_sets: bool = ...

  """

  Do not affect vertices that belong to a Face Set boundary

  """

  use_automasking_face_sets: bool = ...

  """

  Affect only vertices that share Face Sets with the active vertex

  """

  use_automasking_topology: bool = ...

  """

  Affect only vertices connected to the active vertex under the brush

  """

  use_cloth_collision: bool = ...

  """

  Collide with objects during the simulation

  """

  use_cloth_pin_simulation_boundary: bool = ...

  """

  Lock the position of the vertices in the simulation falloff area to avoid artifacts and create a softer transition with unaffected areas

  """

  use_connected_only: bool = ...

  """

  Affect only topologically connected elements

  """

  use_cursor_overlay: bool = ...

  """

  Show cursor in viewport

  """

  use_cursor_overlay_override: bool = ...

  """

  Don't show overlay during a stroke

  """

  use_curve: bool = ...

  """

  Define the stroke curve with a bezier curve. Dabs are separated according to spacing

  """

  use_custom_icon: bool = ...

  """

  Set the brush icon from an image file

  """

  use_density_pressure: bool = ...

  """

  Use pressure to modulate density

  """

  use_edge_to_edge: bool = ...

  """

  Drag anchor brush from edge-to-edge

  """

  use_flow_pressure: bool = ...

  """

  Use pressure to modulate flow

  """

  use_frontface: bool = ...

  """

  Brush only affects vertexes that face the viewer

  """

  use_frontface_falloff: bool = ...

  """

  Blend brush influence by how much they face the front

  """

  use_grab_active_vertex: bool = ...

  """

  Apply the maximum grab strength to the active vertex instead of the cursor location

  """

  use_hardness_pressure: bool = ...

  """

  Use pressure to modulate hardness

  """

  use_inverse_smooth_pressure: bool = ...

  """

  Lighter pressure causes more smoothing to be applied

  """

  use_line: bool = ...

  """

  Draw a line with dabs separated according to spacing

  """

  use_locked_size: str = ...

  """

  Measure brush size relative to the view or the scene

  * ``VIEW``
View, Measure brush size relative to the view.

  * ``SCENE``
Scene, Measure brush size relative to the scene.

  """

  use_multiplane_scrape_dynamic: bool = ...

  """

  The angle between the planes changes during the stroke to fit the surface under the cursor

  """

  use_offset_pressure: bool = ...

  """

  Enable tablet pressure sensitivity for offset

  """

  use_original_normal: bool = ...

  """

  When locked keep using normal of surface where stroke was initiated

  """

  use_original_plane: bool = ...

  """

  When locked keep using the plane origin of surface where stroke was initiated

  """

  use_paint_antialiasing: bool = ...

  """

  Smooths the edges of the strokes

  """

  use_paint_grease_pencil: bool = ...

  """

  Use this brush in grease pencil drawing mode

  """

  use_paint_image: bool = ...

  """

  Use this brush in texture paint mode

  """

  use_paint_sculpt: bool = ...

  """

  Use this brush in sculpt mode

  """

  use_paint_uv_sculpt: bool = ...

  """

  Use this brush in UV sculpt mode

  """

  use_paint_vertex: bool = ...

  """

  Use this brush in vertex paint mode

  """

  use_paint_weight: bool = ...

  """

  Use this brush in weight paint mode

  """

  use_persistent: bool = ...

  """

  Sculpt on a persistent layer of the mesh

  """

  use_plane_trim: bool = ...

  """

  Enable Plane Trim

  """

  use_pose_ik_anchored: bool = ...

  """

  Keep the position of the last segment in the IK chain fixed

  """

  use_pose_lock_rotation: bool = ...

  """

  Do not rotate the segment when using the scale deform mode

  """

  use_pressure_area_radius: bool = ...

  """

  Enable tablet pressure sensitivity for area radius

  """

  use_pressure_jitter: bool = ...

  """

  Enable tablet pressure sensitivity for jitter

  """

  use_pressure_masking: str = ...

  """

  Pen pressure makes texture influence smaller

  """

  use_pressure_size: bool = ...

  """

  Enable tablet pressure sensitivity for size

  """

  use_pressure_spacing: bool = ...

  """

  Enable tablet pressure sensitivity for spacing

  """

  use_pressure_strength: bool = ...

  """

  Enable tablet pressure sensitivity for strength

  """

  use_primary_overlay: bool = ...

  """

  Show texture in viewport

  """

  use_primary_overlay_override: bool = ...

  """

  Don't show overlay during a stroke

  """

  use_restore_mesh: bool = ...

  """

  Allow a single dot to be carefully positioned

  """

  use_scene_spacing: str = ...

  """

  Calculate the brush spacing using view or scene distance

  * ``VIEW``
View, Calculate brush spacing relative to the view.

  * ``SCENE``
Scene, Calculate brush spacing relative to the scene using the stroke location.

  """

  use_secondary_overlay: bool = ...

  """

  Show texture in viewport

  """

  use_secondary_overlay_override: bool = ...

  """

  Don't show overlay during a stroke

  """

  use_smooth_stroke: bool = ...

  """

  Brush lags behind mouse and follows a smoother path

  """

  use_space: bool = ...

  """

  Limit brush application to the distance specified by spacing

  """

  use_space_attenuation: bool = ...

  """

  Automatically adjust strength to give consistent results for different spacings

  """

  use_vertex_grease_pencil: bool = ...

  """

  Use this brush in grease pencil vertex color mode

  """

  use_wet_mix_pressure: bool = ...

  """

  Use pressure to modulate wet mix

  """

  use_wet_persistence_pressure: bool = ...

  """

  Use pressure to modulate wet persistence

  """

  uv_sculpt_tool: str = ...

  """

  * ``GRAB``
Grab, Grab UVs.

  * ``RELAX``
Relax, Relax UVs.

  * ``PINCH``
Pinch, Pinch UVs.

  """

  vertex_paint_capabilities: BrushCapabilitiesVertexPaint = ...

  vertex_tool: str = ...

  weight: float = ...

  """

  Vertex weight when brush is applied

  """

  weight_paint_capabilities: BrushCapabilitiesWeightPaint = ...

  weight_tool: str = ...

  wet_mix: float = ...

  """

  Amount of paint that is picked from the surface into the brush color

  """

  wet_persistence: float = ...

  """

  Amount of wet paint that stays in the brush after applying paint to the surface

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CacheFile(bpy_struct, ID):

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  filepath: str = ...

  """

  Path to external displacements file

  """

  forward_axis: str = ...

  frame: float = ...

  """

  The time to use for looking up the data in the cache file, or to determine which file to use in a file sequence

  """

  frame_offset: float = ...

  """

  Subtracted from the current frame to use for looking up the data in the cache file, or to determine which file to use in a file sequence

  """

  is_sequence: bool = ...

  """

  Whether the cache is separated in a series of files

  """

  object_paths: typing.Union[AlembicObjectPaths, typing.Sequence[AlembicObjectPath], typing.Mapping[str, AlembicObjectPath], bpy_prop_collection] = ...

  """

  Paths of the objects inside the Alembic archive

  """

  override_frame: bool = ...

  """

  Whether to use a custom frame for looking up data in the cache file, instead of using the current scene frame

  """

  scale: float = ...

  """

  Value by which to enlarge or shrink the object with respect to the world's origin (only applicable through a Transform Cache constraint)

  """

  up_axis: str = ...

  velocity_name: str = ...

  """

  Name of the Alembic attribute used for generating motion blur data

  """

  velocity_unit: str = ...

  """

  Define how the velocity vectors are interpreted with regard to time, 'frame' means the delta time is 1 frame, 'second' means the delta time is 1 / FPS

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Camera(bpy_struct, ID):

  """

  Camera data-block for storing camera settings

  """

  angle: float = ...

  """

  Camera lens field of view

  """

  angle_x: float = ...

  """

  Camera lens horizontal field of view

  """

  angle_y: float = ...

  """

  Camera lens vertical field of view

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  background_images: typing.Union[CameraBackgroundImages, typing.Sequence[CameraBackgroundImage], typing.Mapping[str, CameraBackgroundImage], bpy_prop_collection] = ...

  """

  List of background images

  """

  clip_end: float = ...

  """

  Camera far clipping distance

  """

  clip_start: float = ...

  """

  Camera near clipping distance

  """

  cycles: CyclesCameraSettings = ...

  """

  Cycles camera settings

  """

  display_size: float = ...

  """

  Apparent size of the Camera object in the 3D View

  """

  dof: CameraDOFSettings = ...

  lens: float = ...

  """

  Perspective Camera lens value in millimeters

  """

  lens_unit: str = ...

  """

  Unit to edit lens in for the user interface

  * ``MILLIMETERS``
Millimeters, Specify the lens in millimeters.

  * ``FOV``
Field of View, Specify the lens as the field of view's angle.

  """

  ortho_scale: float = ...

  """

  Orthographic Camera scale (similar to zoom)

  """

  passepartout_alpha: float = ...

  """

  Opacity (alpha) of the darkened overlay in Camera view

  """

  sensor_fit: str = ...

  """

  Method to fit image and field of view angle inside the sensor

  * ``AUTO``
Auto, Fit to the sensor width or height depending on image resolution.

  * ``HORIZONTAL``
Horizontal, Fit to the sensor width.

  * ``VERTICAL``
Vertical, Fit to the sensor height.

  """

  sensor_height: float = ...

  """

  Vertical size of the image sensor area in millimeters

  """

  sensor_width: float = ...

  """

  Horizontal size of the image sensor area in millimeters

  """

  shift_x: float = ...

  """

  Camera horizontal shift

  """

  shift_y: float = ...

  """

  Camera vertical shift

  """

  show_background_images: bool = ...

  """

  Display reference images behind objects in the 3D View

  """

  show_composition_center: bool = ...

  """

  Display center composition guide inside the camera view

  """

  show_composition_center_diagonal: bool = ...

  """

  Display diagonal center composition guide inside the camera view

  """

  show_composition_golden: bool = ...

  """

  Display golden ratio composition guide inside the camera view

  """

  show_composition_golden_tria_a: bool = ...

  """

  Display golden triangle A composition guide inside the camera view

  """

  show_composition_golden_tria_b: bool = ...

  """

  Display golden triangle B composition guide inside the camera view

  """

  show_composition_harmony_tri_a: bool = ...

  """

  Display harmony A composition guide inside the camera view

  """

  show_composition_harmony_tri_b: bool = ...

  """

  Display harmony B composition guide inside the camera view

  """

  show_composition_thirds: bool = ...

  """

  Display rule of thirds composition guide inside the camera view

  """

  show_limits: bool = ...

  """

  Display the clipping range and focus point on the camera

  """

  show_mist: bool = ...

  """

  Display a line from the Camera to indicate the mist area

  """

  show_name: bool = ...

  """

  Show the active Camera's name in Camera view

  """

  show_passepartout: bool = ...

  """

  Show a darkened overlay outside the image area in Camera view

  """

  show_safe_areas: bool = ...

  """

  Show TV title safe and action safe areas in Camera view

  """

  show_safe_center: bool = ...

  """

  Show safe areas to fit content in a different aspect ratio

  """

  show_sensor: bool = ...

  """

  Show sensor size (film gate) in Camera view

  """

  stereo: CameraStereoData = ...

  type: str = ...

  """

  Camera types

  """

  def view_frame(self, scene: Scene = None) -> None:

    """

    Return 4 points for the cameras frame (before object transformation)

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Collection(bpy_struct, ID):

  """

  Collection of Object data-blocks

  """

  all_objects: typing.Union[typing.Sequence[Object], typing.Mapping[str, Object], bpy_prop_collection] = ...

  """

  Objects that are in this collection and its child collections

  """

  children: typing.Union[CollectionChildren, typing.Sequence[Collection], typing.Mapping[str, Collection], bpy_prop_collection] = ...

  """

  Collections that are immediate children of this collection

  """

  color_tag: str = ...

  """

  Color tag for a collection

  * ``NONE``
None, Assign no color tag to the collection.

  * ``COLOR_01``
Color 01.

  * ``COLOR_02``
Color 02.

  * ``COLOR_03``
Color 03.

  * ``COLOR_04``
Color 04.

  * ``COLOR_05``
Color 05.

  * ``COLOR_06``
Color 06.

  * ``COLOR_07``
Color 07.

  * ``COLOR_08``
Color 08.

  """

  hide_render: bool = ...

  """

  Globally disable in renders

  """

  hide_select: bool = ...

  """

  Disable selection in viewport

  """

  hide_viewport: bool = ...

  """

  Globally disable in viewports

  """

  instance_offset: typing.Tuple[float, float, float] = ...

  """

  Offset from the origin to use when instancing

  """

  objects: typing.Union[CollectionObjects, typing.Sequence[Object], typing.Mapping[str, Object], bpy_prop_collection] = ...

  """

  Objects that are directly in this collection

  """

  users_dupli_group: typing.Any = ...

  """

  The collection instance objects this collection is used in

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Curve(ID):

  """

  Curve data-block storing curves, splines and NURBS

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  bevel_depth: float = ...

  """

  Radius of the bevel geometry, not including extrusion

  """

  bevel_factor_end: float = ...

  """

  Define where along the spline the curve geometry ends (0 for the beginning, 1 for the end)

  """

  bevel_factor_mapping_end: str = ...

  """

  Determine how the geometry end factor is mapped to a spline

  * ``RESOLUTION``
Resolution, Map the geometry factor to the number of subdivisions of a spline (U resolution).

  * ``SEGMENTS``
Segments, Map the geometry factor to the length of a segment and to the number of subdivisions of a segment.

  * ``SPLINE``
Spline, Map the geometry factor to the length of a spline.

  """

  bevel_factor_mapping_start: str = ...

  """

  Determine how the geometry start factor is mapped to a spline

  * ``RESOLUTION``
Resolution, Map the geometry factor to the number of subdivisions of a spline (U resolution).

  * ``SEGMENTS``
Segments, Map the geometry factor to the length of a segment and to the number of subdivisions of a segment.

  * ``SPLINE``
Spline, Map the geometry factor to the length of a spline.

  """

  bevel_factor_start: float = ...

  """

  Define where along the spline the curve geometry starts (0 for the beginning, 1 for the end)

  """

  bevel_mode: str = ...

  """

  Determine how to build the curve's bevel geometry

  * ``ROUND``
Round, Use circle for the section of the curve's bevel geometry.

  * ``OBJECT``
Object, Use an object for the section of the curve's bevel geometry segment.

  * ``PROFILE``
Profile, Use a custom profile for each quarter of curve's bevel geometry.

  """

  bevel_object: Object = ...

  """

  The name of the Curve object that defines the bevel shape

  """

  bevel_profile: CurveProfile = ...

  """

  The path for the curve's custom profile

  """

  bevel_resolution: int = ...

  """

  The number of segments in each quarter-circle of the bevel

  """

  cycles: CyclesMeshSettings = ...

  """

  Cycles mesh settings

  """

  dimensions: str = ...

  """

  Select 2D or 3D curve type

  * ``2D``
2D, Clamp the Z axis of the curve.

  * ``3D``
3D, Allow editing on the Z axis of this curve, also allows tilt and curve radius to be used.

  """

  eval_time: float = ...

  """

  Parametric position along the length of the curve that Objects 'following' it should be at (position is evaluated by dividing by the 'Path Length' value)

  """

  extrude: float = ...

  """

  Length of the depth added in the local Z direction along the curve, perpendicular to its normals

  """

  fill_mode: str = ...

  """

  Mode of filling curve

  """

  is_editmode: bool = ...

  """

  True when used in editmode

  """

  materials: typing.Union[IDMaterials, typing.Sequence[Material], typing.Mapping[str, Material], bpy_prop_collection] = ...

  offset: float = ...

  """

  Distance to move the curve parallel to its normals

  """

  path_duration: int = ...

  """

  The number of frames that are needed to traverse the path, defining the maximum value for the 'Evaluation Time' setting

  """

  render_resolution_u: int = ...

  """

  Surface resolution in U direction used while rendering (zero uses preview resolution)

  """

  render_resolution_v: int = ...

  """

  Surface resolution in V direction used while rendering (zero uses preview resolution)

  """

  resolution_u: int = ...

  """

  Number of computed points in the U direction between every pair of control points

  """

  resolution_v: int = ...

  """

  The number of computed points in the V direction between every pair of control points

  """

  shape_keys: Key = ...

  splines: typing.Union[CurveSplines, typing.Sequence[Spline], typing.Mapping[str, Spline], bpy_prop_collection] = ...

  """

  Collection of splines in this curve data object

  """

  taper_object: Object = ...

  """

  Curve object name that defines the taper (width)

  """

  texspace_location: typing.Tuple[float, float, float] = ...

  """

  Texture space location

  """

  texspace_size: typing.Tuple[float, float, float] = ...

  """

  Texture space size

  """

  twist_mode: str = ...

  """

  The type of tilt calculation for 3D Curves

  * ``Z_UP``
Z-Up, Use Z-Up axis to calculate the curve twist at each point.

  * ``MINIMUM``
Minimum, Use the least twist over the entire curve.

  * ``TANGENT``
Tangent, Use the tangent to calculate twist.

  """

  twist_smooth: float = ...

  """

  Smoothing iteration for tangents

  """

  use_auto_texspace: bool = ...

  """

  Adjust active object's texture space automatically when transforming object

  """

  use_deform_bounds: bool = ...

  """

  Option for curve-deform: Use the mesh bounds to clamp the deformation

  """

  use_fill_caps: bool = ...

  """

  Fill caps for beveled curves

  """

  use_fill_deform: bool = ...

  """

  Fill curve after applying shape keys and all modifiers

  """

  use_map_taper: bool = ...

  """

  Map effect of the taper object to the beveled part of the curve

  """

  use_path: bool = ...

  """

  Enable the curve to become a translation path

  """

  use_path_follow: bool = ...

  """

  Make curve path children to rotate along the path

  """

  use_radius: bool = ...

  """

  Option for paths and curve-deform: apply the curve radius with path following it and deforming

  """

  use_stretch: bool = ...

  """

  Option for curve-deform: make deformed child to stretch along entire path

  """

  def transform(self, matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]], shape_keys: bool = False) -> None:

    """

    Transform curve by a matrix

    """

    ...

  def validate_material_indices(self) -> bool:

    """

    Validate material indices of splines or letters, return True when the curve has had invalid indices corrected (to default 0)

    """

    ...

  def update_gpu_tag(self) -> None:

    """

    update_gpu_tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FreestyleLineStyle(bpy_struct, ID):

  """

  Freestyle line style, reusable by multiple line sets

  """

  active_texture: Texture = ...

  """

  Active texture slot being displayed

  """

  active_texture_index: int = ...

  """

  Index of active texture slot

  """

  alpha: float = ...

  """

  Base alpha transparency, possibly modified by alpha transparency modifiers

  """

  alpha_modifiers: typing.Union[LineStyleAlphaModifiers, typing.Sequence[LineStyleAlphaModifier], typing.Mapping[str, LineStyleAlphaModifier], bpy_prop_collection] = ...

  """

  List of alpha transparency modifiers

  """

  angle_max: float = ...

  """

  Maximum 2D angle for splitting chains

  """

  angle_min: float = ...

  """

  Minimum 2D angle for splitting chains

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  caps: str = ...

  """

  Select the shape of both ends of strokes

  * ``BUTT``
Butt, Butt cap (flat).

  * ``ROUND``
Round, Round cap (half-circle).

  * ``SQUARE``
Square, Square cap (flat and extended).

  """

  chain_count: int = ...

  """

  Chain count for the selection of first N chains

  """

  chaining: str = ...

  """

  Select the way how feature edges are jointed to form chains

  * ``PLAIN``
Plain, Plain chaining.

  * ``SKETCHY``
Sketchy, Sketchy chaining with a multiple touch.

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Base line color, possibly modified by line color modifiers

  """

  color_modifiers: typing.Union[LineStyleColorModifiers, typing.Sequence[LineStyleColorModifier], typing.Mapping[str, LineStyleColorModifier], bpy_prop_collection] = ...

  """

  List of line color modifiers

  """

  dash1: int = ...

  """

  Length of the 1st dash for dashed lines

  """

  dash2: int = ...

  """

  Length of the 2nd dash for dashed lines

  """

  dash3: int = ...

  """

  Length of the 3rd dash for dashed lines

  """

  gap1: int = ...

  """

  Length of the 1st gap for dashed lines

  """

  gap2: int = ...

  """

  Length of the 2nd gap for dashed lines

  """

  gap3: int = ...

  """

  Length of the 3rd gap for dashed lines

  """

  geometry_modifiers: typing.Union[LineStyleGeometryModifiers, typing.Sequence[LineStyleGeometryModifier], typing.Mapping[str, LineStyleGeometryModifier], bpy_prop_collection] = ...

  """

  List of stroke geometry modifiers

  """

  integration_type: str = ...

  """

  Select the way how the sort key is computed for each chain

  * ``MEAN``
Mean, The value computed for the chain is the mean of the values obtained for chain vertices.

  * ``MIN``
Min, The value computed for the chain is the minimum of the values obtained for chain vertices.

  * ``MAX``
Max, The value computed for the chain is the maximum of the values obtained for chain vertices.

  * ``FIRST``
First, The value computed for the chain is the value obtained for the first chain vertex.

  * ``LAST``
Last, The value computed for the chain is the value obtained for the last chain vertex.

  """

  length_max: float = ...

  """

  Maximum curvilinear 2D length for the selection of chains

  """

  length_min: float = ...

  """

  Minimum curvilinear 2D length for the selection of chains

  """

  material_boundary: bool = ...

  """

  If true, chains of feature edges are split at material boundaries

  """

  node_tree: NodeTree = ...

  """

  Node tree for node-based shaders

  """

  panel: str = ...

  """

  Select the property panel to be shown

  * ``STROKES``
Strokes, Show the panel for stroke construction.

  * ``COLOR``
Color, Show the panel for line color options.

  * ``ALPHA``
Alpha, Show the panel for alpha transparency options.

  * ``THICKNESS``
Thickness, Show the panel for line thickness options.

  * ``GEOMETRY``
Geometry, Show the panel for stroke geometry options.

  * ``TEXTURE``
Texture, Show the panel for stroke texture options.

  """

  rounds: int = ...

  """

  Number of rounds in a sketchy multiple touch

  """

  sort_key: str = ...

  """

  Select the sort key to determine the stacking order of chains

  * ``DISTANCE_FROM_CAMERA``
Distance from Camera, Sort by distance from camera (closer lines lie on top of further lines).

  * ``2D_LENGTH``
2D Length, Sort by curvilinear 2D length (longer lines lie on top of shorter lines).

  * ``PROJECTED_X``
Projected X, Sort by the projected X value in the image coordinate system.

  * ``PROJECTED_Y``
Projected Y, Sort by the projected Y value in the image coordinate system.

  """

  sort_order: str = ...

  """

  Select the sort order

  * ``DEFAULT``
Default, Default order of the sort key.

  * ``REVERSE``
Reverse, Reverse order.

  """

  split_dash1: int = ...

  """

  Length of the 1st dash for splitting

  """

  split_dash2: int = ...

  """

  Length of the 2nd dash for splitting

  """

  split_dash3: int = ...

  """

  Length of the 3rd dash for splitting

  """

  split_gap1: int = ...

  """

  Length of the 1st gap for splitting

  """

  split_gap2: int = ...

  """

  Length of the 2nd gap for splitting

  """

  split_gap3: int = ...

  """

  Length of the 3rd gap for splitting

  """

  split_length: float = ...

  """

  Curvilinear 2D length for chain splitting

  """

  texture_slots: typing.Union[LineStyleTextureSlots, typing.Sequence[LineStyleTextureSlot], typing.Mapping[str, LineStyleTextureSlot], bpy_prop_collection] = ...

  """

  Texture slots defining the mapping and influence of textures

  """

  texture_spacing: float = ...

  """

  Spacing for textures along stroke length

  """

  thickness: float = ...

  """

  Base line thickness, possibly modified by line thickness modifiers

  """

  thickness_modifiers: typing.Union[LineStyleThicknessModifiers, typing.Sequence[LineStyleThicknessModifier], typing.Mapping[str, LineStyleThicknessModifier], bpy_prop_collection] = ...

  """

  List of line thickness modifiers

  """

  thickness_position: str = ...

  """

  Thickness position of silhouettes and border edges (applicable when plain chaining is used with the Same Object option)

  * ``CENTER``
Center, Silhouettes and border edges are centered along stroke geometry.

  * ``INSIDE``
Inside, Silhouettes and border edges are drawn inside of stroke geometry.

  * ``OUTSIDE``
Outside, Silhouettes and border edges are drawn outside of stroke geometry.

  * ``RELATIVE``
Relative, Silhouettes and border edges are shifted by a user-defined ratio.

  """

  thickness_ratio: float = ...

  """

  A number between 0 (inside) and 1 (outside) specifying the relative position of stroke thickness

  """

  use_angle_max: bool = ...

  """

  Split chains at points with angles larger than the maximum 2D angle

  """

  use_angle_min: bool = ...

  """

  Split chains at points with angles smaller than the minimum 2D angle

  """

  use_chain_count: bool = ...

  """

  Enable the selection of first N chains

  """

  use_chaining: bool = ...

  """

  Enable chaining of feature edges

  """

  use_dashed_line: bool = ...

  """

  Enable or disable dashed line

  """

  use_length_max: bool = ...

  """

  Enable the selection of chains by a maximum 2D length

  """

  use_length_min: bool = ...

  """

  Enable the selection of chains by a minimum 2D length

  """

  use_nodes: bool = ...

  """

  Use shader nodes for the line style

  """

  use_same_object: bool = ...

  """

  If true, only feature edges of the same object are joined

  """

  use_sorting: bool = ...

  """

  Arrange the stacking order of strokes

  """

  use_split_length: bool = ...

  """

  Enable chain splitting by curvilinear 2D length

  """

  use_split_pattern: bool = ...

  """

  Enable chain splitting by dashed line patterns

  """

  use_texture: bool = ...

  """

  Enable or disable textured strokes

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GreasePencil(bpy_struct, ID):

  """

  Freehand annotation sketchbook

  """

  after_color: typing.Tuple[float, float, float] = ...

  """

  Base color for ghosts after the active frame

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  before_color: typing.Tuple[float, float, float] = ...

  """

  Base color for ghosts before the active frame

  """

  edit_line_color: typing.Tuple[float, float, float, float] = ...

  """

  Color for editing line

  """

  ghost_after_range: int = ...

  """

  Maximum number of frames to show after current frame (0 = don't show any frames after current)

  """

  ghost_before_range: int = ...

  """

  Maximum number of frames to show before current frame (0 = don't show any frames before current)

  """

  grid: GreasePencilGrid = ...

  """

  Settings for grid and canvas in the 3D viewport

  """

  is_annotation: bool = ...

  """

  Current datablock is an annotation

  """

  is_stroke_paint_mode: bool = ...

  """

  Draw Grease Pencil strokes on click/drag

  """

  is_stroke_sculpt_mode: bool = ...

  """

  Sculpt Grease Pencil strokes instead of viewport data

  """

  is_stroke_vertex_mode: bool = ...

  """

  Grease Pencil vertex paint

  """

  is_stroke_weight_mode: bool = ...

  """

  Grease Pencil weight paint

  """

  layers: typing.Union[GreasePencilLayers, typing.Sequence[GPencilLayer], typing.Mapping[str, GPencilLayer], bpy_prop_collection] = ...

  materials: typing.Union[IDMaterials, typing.Sequence[Material], typing.Mapping[str, Material], bpy_prop_collection] = ...

  onion_factor: float = ...

  """

  Change fade opacity of displayed onion frames

  """

  onion_keyframe_type: str = ...

  """

  Type of keyframe (for filtering)

  * ``ALL``
All, Include all Keyframe types.

  * ``KEYFRAME``
Keyframe, Normal keyframe - e.g. for key poses.

  * ``BREAKDOWN``
Breakdown, A breakdown pose - e.g. for transitions between key poses.

  * ``MOVING_HOLD``
Moving Hold, A keyframe that is part of a moving hold.

  * ``EXTREME``
Extreme, An 'extreme' pose, or some other purpose as needed.

  * ``JITTER``
Jitter, A filler or baked keyframe for keying on ones, or some other purpose as needed.

  """

  onion_mode: str = ...

  """

  Mode to display frames

  * ``ABSOLUTE``
Frames, Frames in absolute range of the scene frame.

  * ``RELATIVE``
Keyframes, Frames in relative range of the Grease Pencil keyframes.

  * ``SELECTED``
Selected, Only selected keyframes.

  """

  pixel_factor: float = ...

  """

  Scale conversion factor for pixel size (use larger values for thicker lines)

  """

  stroke_depth_order: str = ...

  """

  Defines how the strokes are ordered in 3D space (for objects not displayed 'In Front')

  * ``2D``
2D Layers, Display strokes using grease pencil layers to define order.

  * ``3D``
3D Location, Display strokes using real 3D position in 3D space.

  """

  stroke_thickness_space: str = ...

  """

  Set stroke thickness in screen space or world space

  * ``WORLDSPACE``
World Space, Set stroke thickness relative to the world space.

  * ``SCREENSPACE``
Screen Space, Set stroke thickness relative to the screen space.

  """

  use_autolock_layers: bool = ...

  """

  Lock automatically all layers except active one to avoid accidental changes

  """

  use_ghost_custom_colors: bool = ...

  """

  Use custom colors for ghost frames

  """

  use_ghosts_always: bool = ...

  """

  Ghosts are shown in renders and animation playback. Useful for special effects (e.g. motion blur)

  """

  use_multiedit: bool = ...

  """

  Edit strokes from multiple grease pencil keyframes at the same time (keyframes must be selected to be included)

  """

  use_onion_fade: bool = ...

  """

  Display onion keyframes with a fade in color transparency

  """

  use_onion_loop: bool = ...

  """

  Display onion keyframes for looping animations

  """

  use_onion_skinning: bool = ...

  """

  Show ghosts of the keyframes before and after the current frame

  """

  use_stroke_edit_mode: bool = ...

  """

  Edit Grease Pencil strokes instead of viewport data

  """

  zdepth_offset: float = ...

  """

  Offset amount when drawing in surface mode

  """

  def clear(self) -> None:

    """

    Remove all the Grease Pencil data

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Image(bpy_struct, ID):

  """

  Image data-block referencing an external or packed image

  """

  alpha_mode: str = ...

  """

  Representation of alpha in the image file, to convert to and from when saving and loading the image

  * ``STRAIGHT``
Straight, Store RGB and alpha channels separately with alpha acting as a mask, also known as unassociated alpha. Commonly used by image editing applications and file formats like PNG.

  * ``PREMUL``
Premultiplied, Store RGB channels with alpha multiplied in, also known as associated alpha. The natural format for renders and used by file formats like OpenEXR.

  * ``CHANNEL_PACKED``
Channel Packed, Different images are packed in the RGB and alpha channels, and they should not affect each other. Channel packing is commonly used by game engines to save memory.

  * ``NONE``
None, Ignore alpha channel from the file and make image fully opaque.

  """

  bindcode: int = ...

  """

  OpenGL bindcode

  """

  channels: int = ...

  """

  Number of channels in pixels buffer

  """

  colorspace_settings: ColorManagedInputColorspaceSettings = ...

  """

  Input color space settings

  """

  depth: int = ...

  """

  Image bit depth

  """

  display_aspect: typing.Tuple[float, float] = ...

  """

  Display Aspect for this image, does not affect rendering

  """

  file_format: str = ...

  """

  Format used for re-saving this file

  * ``BMP``
BMP, Output image in bitmap format.

  * ``IRIS``
Iris, Output image in (old!) SGI IRIS format.

  * ``PNG``
PNG, Output image in PNG format.

  * ``JPEG``
JPEG, Output image in JPEG format.

  * ``JPEG2000``
JPEG 2000, Output image in JPEG 2000 format.

  * ``TARGA``
Targa, Output image in Targa format.

  * ``TARGA_RAW``
Targa Raw, Output image in uncompressed Targa format.

  * ``CINEON``
Cineon, Output image in Cineon format.

  * ``DPX``
DPX, Output image in DPX format.

  * ``OPEN_EXR_MULTILAYER``
OpenEXR MultiLayer, Output image in multilayer OpenEXR format.

  * ``OPEN_EXR``
OpenEXR, Output image in OpenEXR format.

  * ``HDR``
Radiance HDR, Output image in Radiance HDR format.

  * ``TIFF``
TIFF, Output image in TIFF format.

  * ``AVI_JPEG``
AVI JPEG, Output video in AVI JPEG format.

  * ``AVI_RAW``
AVI Raw, Output video in AVI Raw format.

  * ``FFMPEG``
FFmpeg video, The most versatile way to output video files.

  """

  filepath: str = ...

  """

  Image/Movie file name

  """

  filepath_raw: str = ...

  """

  Image/Movie file name (without data refreshing)

  """

  frame_duration: int = ...

  """

  Duration (in frames) of the image (1 when not a video/sequence)

  """

  generated_color: typing.Tuple[float, float, float, float] = ...

  """

  Fill color for the generated image

  """

  generated_height: int = ...

  """

  Generated image height

  """

  generated_type: str = ...

  """

  Generated image type

  * ``BLANK``
Blank, Generate a blank image.

  * ``UV_GRID``
UV Grid, Generated grid to test UV mappings.

  * ``COLOR_GRID``
Color Grid, Generated improved UV grid to test UV mappings.

  """

  generated_width: int = ...

  """

  Generated image width

  """

  has_data: bool = ...

  """

  True if the image data is loaded into memory

  """

  is_dirty: bool = ...

  """

  Image has changed and is not saved

  """

  is_float: bool = ...

  """

  True if this image is stored in float buffer

  """

  is_multiview: bool = ...

  """

  Image has more than one view

  """

  is_stereo_3d: bool = ...

  """

  Image has left and right views

  """

  packed_file: PackedFile = ...

  """

  First packed file of the image

  """

  packed_files: typing.Union[typing.Sequence[ImagePackedFile], typing.Mapping[str, ImagePackedFile], bpy_prop_collection] = ...

  """

  Collection of packed images

  """

  pixels: float = ...

  """

  Image pixels in floating point values

  """

  render_slots: typing.Union[RenderSlots, typing.Sequence[RenderSlot], typing.Mapping[str, RenderSlot], bpy_prop_collection] = ...

  """

  Render slots of the image

  """

  resolution: typing.Tuple[float, float] = ...

  """

  X/Y pixels per meter

  """

  size: typing.Tuple[int, int] = ...

  """

  Width and height in pixels, zero when image data cant be loaded

  """

  source: str = ...

  """

  Where the image comes from

  * ``FILE``
Single Image, Single image file.

  * ``SEQUENCE``
Image Sequence, Multiple image files, as a sequence.

  * ``MOVIE``
Movie, Movie file.

  * ``GENERATED``
Generated, Generated image.

  * ``VIEWER``
Viewer, Compositing node viewer.

  * ``TILED``
UDIM Tiles, Tiled UDIM image texture.

  """

  stereo_3d_format: Stereo3dFormat = ...

  """

  Settings for stereo 3d

  """

  tiles: typing.Union[UDIMTiles, typing.Sequence[UDIMTile], typing.Mapping[str, UDIMTile], bpy_prop_collection] = ...

  """

  Tiles of the image

  """

  type: str = ...

  """

  How to generate the image

  """

  use_deinterlace: bool = ...

  """

  Deinterlace movie file on load

  """

  use_generated_float: bool = ...

  """

  Generate floating point buffer

  """

  use_half_precision: bool = ...

  """

  Use 16bits per channel to lower the memory usage during rendering

  """

  use_multiview: bool = ...

  """

  Use Multiple Views (when available)

  """

  use_view_as_render: bool = ...

  """

  Apply render part of display transformation when displaying this image on the screen

  """

  views_format: str = ...

  """

  Mode to load image views

  * ``INDIVIDUAL``
Individual, Individual files for each view with the prefix as defined by the scene views.

  * ``STEREO_3D``
Stereo 3D, Single file with an encoded stereo pair.

  """

  def save_render(self, filepath: str, scene: Scene = None) -> None:

    """

    Save image to a specific path using a scenes render settings

    """

    ...

  def save(self) -> None:

    """

    Save image to its source path

    """

    ...

  def pack(self, data: str = '', data_len: int = 0) -> None:

    """

    Pack an image as embedded data into the .blend file

    """

    ...

  def unpack(self, method: str = 'USE_LOCAL') -> None:

    """

    Save an image packed in the .blend file to disk

    """

    ...

  def reload(self) -> None:

    """

    Reload the image from its source path

    """

    ...

  def update(self) -> None:

    """

    Update the display image from the floating point buffer

    """

    ...

  def scale(self, width: int, height: int) -> None:

    """

    Scale the image in pixels

    """

    ...

  def gl_touch(self, frame: int = 0) -> int:

    """

    Delay the image from being cleaned from the cache due inactivity

    """

    ...

  def gl_load(self, frame: int = 0) -> int:

    """

    Load the image into an OpenGL texture. On success, image.bindcode will contain the OpenGL texture bindcode. Colors read from the texture will be in scene linear color space and have premultiplied or straight alpha matching the image alpha mode

    """

    ...

  def gl_free(self) -> None:

    """

    Free the image from OpenGL graphics memory

    """

    ...

  def filepath_from_user(self, image_user: ImageUser = None) -> str:

    """

    Return the absolute path to the filepath of an image frame specified by the image user

    """

    ...

  def buffers_free(self) -> None:

    """

    Free the image buffers from memory

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Key(bpy_struct, ID):

  """

  Shape keys data-block containing different shapes of geometric data-blocks

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  eval_time: float = ...

  """

  Evaluation time for absolute shape keys

  """

  key_blocks: typing.Union[typing.Sequence[ShapeKey], typing.Mapping[str, ShapeKey], bpy_prop_collection] = ...

  """

  Shape keys

  """

  reference_key: ShapeKey = ...

  use_relative: bool = ...

  """

  Make shape keys relative, otherwise play through shapes as a sequence using the evaluation time

  """

  user: ID = ...

  """

  Data-block using these shape keys

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Lattice(bpy_struct, ID):

  """

  Lattice data-block defining a grid for deforming other objects

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  interpolation_type_u: str = ...

  interpolation_type_v: str = ...

  interpolation_type_w: str = ...

  is_editmode: bool = ...

  """

  True when used in editmode

  """

  points: typing.Union[typing.Sequence[LatticePoint], typing.Mapping[str, LatticePoint], bpy_prop_collection] = ...

  """

  Points of the lattice

  """

  points_u: int = ...

  """

  Point in U direction (can't be changed when there are shape keys)

  """

  points_v: int = ...

  """

  Point in V direction (can't be changed when there are shape keys)

  """

  points_w: int = ...

  """

  Point in W direction (can't be changed when there are shape keys)

  """

  shape_keys: Key = ...

  use_outside: bool = ...

  """

  Only draw, and take into account, the outer vertices

  """

  vertex_group: str = ...

  """

  Vertex group to apply the influence of the lattice

  """

  def transform(self, matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]], shape_keys: bool = False) -> None:

    """

    Transform lattice by a matrix

    """

    ...

  def update_gpu_tag(self) -> None:

    """

    update_gpu_tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Library(bpy_struct, ID):

  """

  External .blend file from which data is linked

  """

  filepath: str = ...

  """

  Path to the library .blend file

  """

  packed_file: PackedFile = ...

  parent: Library = ...

  version: typing.Tuple[int, int, int] = ...

  """

  Version of Blender the library .blend was saved with

  """

  users_id: typing.Any = ...

  """

  ID data blocks which use this library

  (readonly)

  """

  def reload(self) -> None:

    """

    Reload this library and all its linked data-blocks

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Light(ID):

  """

  Light data-block for lighting a scene

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Light color

  """

  cutoff_distance: float = ...

  """

  Distance at which the light influence will be set to 0

  """

  cycles: CyclesLightSettings = ...

  """

  Cycles light settings

  """

  distance: float = ...

  """

  Falloff distance - the light is at half the original intensity at this point

  """

  node_tree: NodeTree = ...

  """

  Node tree for node based lights

  """

  specular_factor: float = ...

  """

  Specular reflection multiplier

  """

  type: str = ...

  """

  Type of Light

  * ``POINT``
Point, Omnidirectional point light source.

  * ``SUN``
Sun, Constant direction parallel ray light source.

  * ``SPOT``
Spot, Directional cone light source.

  * ``AREA``
Area, Directional area light source.

  """

  use_custom_distance: bool = ...

  """

  Use custom attenuation distance instead of global light threshold

  """

  use_nodes: bool = ...

  """

  Use shader nodes to render the light

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LightProbe(bpy_struct, ID):

  """

  Light Probe data-block for lighting capture objects

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  clip_end: float = ...

  """

  Probe clip end, beyond which objects will not appear in reflections

  """

  clip_start: float = ...

  """

  Probe clip start, below which objects will not appear in reflections

  """

  falloff: float = ...

  """

  Control how fast the probe influence decreases

  """

  grid_resolution_x: int = ...

  """

  Number of sample along the x axis of the volume

  """

  grid_resolution_y: int = ...

  """

  Number of sample along the y axis of the volume

  """

  grid_resolution_z: int = ...

  """

  Number of sample along the z axis of the volume

  """

  influence_distance: float = ...

  """

  Influence distance of the probe

  """

  influence_type: str = ...

  """

  Type of influence volume

  """

  intensity: float = ...

  """

  Modify the intensity of the lighting captured by this probe

  """

  invert_visibility_collection: bool = ...

  """

  Invert visibility collection

  """

  parallax_distance: float = ...

  """

  Lowest corner of the parallax bounding box

  """

  parallax_type: str = ...

  """

  Type of parallax volume

  """

  show_clip: bool = ...

  """

  Show the clipping distances in the 3D view

  """

  show_data: bool = ...

  """

  Show captured lighting data into the 3D view for debugging purpose

  """

  show_influence: bool = ...

  """

  Show the influence volume in the 3D view

  """

  show_parallax: bool = ...

  """

  Show the parallax correction volume in the 3D view

  """

  type: str = ...

  """

  Type of light probe

  * ``CUBEMAP``
Reflection Cubemap, Capture reflections.

  * ``PLANAR``
Reflection Plane.

  * ``GRID``
Irradiance Volume, Volume used for precomputing indirect lighting.

  """

  use_custom_parallax: bool = ...

  """

  Enable custom settings for the parallax correction volume

  """

  visibility_bleed_bias: float = ...

  """

  Bias for reducing light-bleed on variance shadow maps

  """

  visibility_blur: float = ...

  """

  Filter size of the visibility blur

  """

  visibility_buffer_bias: float = ...

  """

  Bias for reducing self shadowing

  """

  visibility_collection: Collection = ...

  """

  Restrict objects visible for this probe

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Mask(bpy_struct, ID):

  """

  Mask data-block defining mask for compositing

  """

  active_layer_index: int = ...

  """

  Index of active layer in list of all mask's layers

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  frame_end: int = ...

  """

  Final frame of the mask (used for sequencer)

  """

  frame_start: int = ...

  """

  First frame of the mask (used for sequencer)

  """

  layers: typing.Union[MaskLayers, typing.Sequence[MaskLayer], typing.Mapping[str, MaskLayer], bpy_prop_collection] = ...

  """

  Collection of layers which defines this mask

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Material(bpy_struct, ID):

  """

  Material data-block to define the appearance of geometric objects for rendering

  """

  alpha_threshold: float = ...

  """

  A pixel is rendered only if its alpha value is above this threshold

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  blend_method: str = ...

  """

  Blend Mode for Transparent Faces

  * ``OPAQUE``
Opaque, Render surface without transparency.

  * ``CLIP``
Alpha Clip, Use the alpha threshold to clip the visibility (binary visibility).

  * ``HASHED``
Alpha Hashed, Use noise to dither the binary visibility (works well with multi-samples).

  * ``BLEND``
Alpha Blend, Render polygon transparent, depending on alpha channel of the texture.

  """

  cycles: CyclesMaterialSettings = ...

  """

  Cycles material settings

  """

  diffuse_color: typing.Tuple[float, float, float, float] = ...

  """

  Diffuse color of the material

  """

  grease_pencil: MaterialGPencilStyle = ...

  """

  Grease pencil color settings for material

  """

  is_grease_pencil: bool = ...

  """

  True if this material has grease pencil data

  """

  line_color: typing.Tuple[float, float, float, float] = ...

  """

  Line color used for Freestyle line rendering

  """

  line_priority: int = ...

  """

  The line color of a higher priority is used at material boundaries

  """

  metallic: float = ...

  """

  Amount of mirror reflection for raytrace

  """

  node_tree: NodeTree = ...

  """

  Node tree for node based materials

  """

  paint_active_slot: int = ...

  """

  Index of active texture paint slot

  """

  paint_clone_slot: int = ...

  """

  Index of clone texture paint slot

  """

  pass_index: int = ...

  """

  Index number for the "Material Index" render pass

  """

  preview_render_type: str = ...

  """

  Type of preview render

  * ``FLAT``
Flat, Flat XY plane.

  * ``SPHERE``
Sphere, Sphere.

  * ``CUBE``
Cube, Cube.

  * ``HAIR``
Hair, Hair strands.

  * ``SHADERBALL``
Shader Ball, Shader Ball.

  * ``CLOTH``
Cloth, Cloth.

  * ``FLUID``
Fluid, Fluid.

  """

  refraction_depth: float = ...

  """

  Approximate the thickness of the object to compute two refraction event (0 is disabled)

  """

  roughness: float = ...

  """

  Roughness of the material

  """

  shadow_method: str = ...

  """

  Shadow mapping method

  * ``NONE``
None, Material will cast no shadow.

  * ``OPAQUE``
Opaque, Material will cast shadows without transparency.

  * ``CLIP``
Alpha Clip, Use the alpha threshold to clip the visibility (binary visibility).

  * ``HASHED``
Alpha Hashed, Use noise to dither the binary visibility and use filtering to reduce the noise.

  """

  show_transparent_back: bool = ...

  """

  Limit transparency to a single layer (avoids transparency sorting problems)

  """

  specular_color: typing.Tuple[float, float, float] = ...

  """

  Specular color of the material

  """

  specular_intensity: float = ...

  """

  How intense (bright) the specular reflection is

  """

  texture_paint_images: typing.Union[typing.Sequence[Image], typing.Mapping[str, Image], bpy_prop_collection] = ...

  """

  Texture images used for texture painting

  """

  texture_paint_slots: typing.Union[typing.Sequence[TexPaintSlot], typing.Mapping[str, TexPaintSlot], bpy_prop_collection] = ...

  """

  Texture slots defining the mapping and influence of textures

  """

  use_backface_culling: bool = ...

  """

  Use back face culling to hide the back side of faces

  """

  use_nodes: bool = ...

  """

  Use shader nodes to render the material

  """

  use_preview_world: bool = ...

  """

  Use the current world background to light the preview render

  """

  use_screen_refraction: bool = ...

  """

  Use raytraced screen space refractions

  """

  use_sss_translucency: bool = ...

  """

  Add translucency effect to subsurface

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Mesh(bpy_struct, ID):

  """

  Mesh data-block defining geometric surfaces

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  attributes: typing.Union[AttributeGroup, typing.Sequence[Attribute], typing.Mapping[str, Attribute], bpy_prop_collection] = ...

  """

  Geometry attributes

  """

  auto_smooth_angle: float = ...

  """

  Maximum angle between face normals that will be considered as smooth (unused if custom split normals data are available)

  """

  auto_texspace: bool = ...

  """

  Adjust active object's texture space automatically when transforming object

  """

  cycles: CyclesMeshSettings = ...

  """

  Cycles mesh settings

  """

  edges: typing.Union[MeshEdges, typing.Sequence[MeshEdge], typing.Mapping[str, MeshEdge], bpy_prop_collection] = ...

  """

  Edges of the mesh

  """

  face_maps: typing.Union[MeshFaceMapLayers, typing.Sequence[MeshFaceMapLayer], typing.Mapping[str, MeshFaceMapLayer], bpy_prop_collection] = ...

  has_custom_normals: bool = ...

  """

  True if there are custom split normals data in this mesh

  """

  is_editmode: bool = ...

  """

  True when used in editmode

  """

  loop_triangles: typing.Union[MeshLoopTriangles, typing.Sequence[MeshLoopTriangle], typing.Mapping[str, MeshLoopTriangle], bpy_prop_collection] = ...

  """

  Tessellation of mesh polygons into triangles

  """

  loops: typing.Union[MeshLoops, typing.Sequence[MeshLoop], typing.Mapping[str, MeshLoop], bpy_prop_collection] = ...

  """

  Loops of the mesh (polygon corners)

  """

  materials: typing.Union[IDMaterials, typing.Sequence[Material], typing.Mapping[str, Material], bpy_prop_collection] = ...

  polygon_layers_float: typing.Union[PolygonFloatProperties, typing.Sequence[MeshPolygonFloatPropertyLayer], typing.Mapping[str, MeshPolygonFloatPropertyLayer], bpy_prop_collection] = ...

  polygon_layers_int: typing.Union[PolygonIntProperties, typing.Sequence[MeshPolygonIntPropertyLayer], typing.Mapping[str, MeshPolygonIntPropertyLayer], bpy_prop_collection] = ...

  polygon_layers_string: typing.Union[PolygonStringProperties, typing.Sequence[MeshPolygonStringPropertyLayer], typing.Mapping[str, MeshPolygonStringPropertyLayer], bpy_prop_collection] = ...

  polygons: typing.Union[MeshPolygons, typing.Sequence[MeshPolygon], typing.Mapping[str, MeshPolygon], bpy_prop_collection] = ...

  """

  Polygons of the mesh

  """

  remesh_mode: str = ...

  """

  * ``VOXEL``
Voxel, Use the voxel remesher.

  * ``QUAD``
Quad, Use the quad remesher.

  """

  remesh_voxel_adaptivity: float = ...

  """

  Reduces the final face count by simplifying geometry where detail is not needed, generating triangles. A value greater than 0 disables Fix Poles

  """

  remesh_voxel_size: float = ...

  """

  Size of the voxel in object space used for volume evaluation. Lower values preserve finer details

  """

  sculpt_vertex_colors: typing.Union[VertColors, typing.Sequence[MeshVertColorLayer], typing.Mapping[str, MeshVertColorLayer], bpy_prop_collection] = ...

  """

  All vertex colors

  """

  shape_keys: Key = ...

  skin_vertices: typing.Union[typing.Sequence[MeshSkinVertexLayer], typing.Mapping[str, MeshSkinVertexLayer], bpy_prop_collection] = ...

  """

  All skin vertices

  """

  texco_mesh: Mesh = ...

  """

  Derive texture coordinates from another mesh

  """

  texspace_location: typing.Tuple[float, float, float] = ...

  """

  Texture space location

  """

  texspace_size: typing.Tuple[float, float, float] = ...

  """

  Texture space size

  """

  texture_mesh: Mesh = ...

  """

  Use another mesh for texture indices (vertex indices must be aligned)

  """

  total_edge_sel: int = ...

  """

  Selected edge count in editmode

  """

  total_face_sel: int = ...

  """

  Selected face count in editmode

  """

  total_vert_sel: int = ...

  """

  Selected vertex count in editmode

  """

  use_auto_smooth: bool = ...

  """

  Auto smooth (based on smooth/sharp faces/edges and angle between faces), or use custom split normals data if available

  """

  use_auto_texspace: bool = ...

  """

  Adjust active object's texture space automatically when transforming object

  """

  use_customdata_edge_bevel: bool = ...

  use_customdata_edge_crease: bool = ...

  use_customdata_vertex_bevel: bool = ...

  use_mirror_topology: bool = ...

  """

  Use topology based mirroring (for when both sides of mesh have matching, unique topology)

  """

  use_mirror_vertex_group_x: bool = ...

  """

  Mirror the left/right vertex groups when painting

  """

  use_mirror_x: bool = ...

  """

  Enable symmetry in the X axis

  """

  use_mirror_y: bool = ...

  """

  Enable symmetry in the Y axis

  """

  use_mirror_z: bool = ...

  """

  Enable symmetry in the Z axis

  """

  use_paint_mask: bool = ...

  """

  Face selection masking for painting

  """

  use_paint_mask_vertex: bool = ...

  """

  Vertex selection masking for painting

  """

  use_remesh_fix_poles: bool = ...

  """

  Produces less poles and a better topology flow

  """

  use_remesh_preserve_paint_mask: bool = ...

  """

  Keep the current mask on the new mesh

  """

  use_remesh_preserve_sculpt_face_sets: bool = ...

  """

  Keep the current Face Sets on the new mesh

  """

  use_remesh_preserve_vertex_colors: bool = ...

  """

  Keep the current vertex colors on the new mesh

  """

  use_remesh_preserve_volume: bool = ...

  """

  Projects the mesh to preserve the volume and details of the original mesh

  """

  use_remesh_smooth_normals: bool = ...

  """

  Smooth the normals of the remesher result

  """

  uv_layer_clone: MeshUVLoopLayer = ...

  """

  UV loop layer to be used as cloning source

  """

  uv_layer_clone_index: int = ...

  """

  Clone UV loop layer index

  """

  uv_layer_stencil: MeshUVLoopLayer = ...

  """

  UV loop layer to mask the painted area

  """

  uv_layer_stencil_index: int = ...

  """

  Mask UV loop layer index

  """

  uv_layers: typing.Union[UVLoopLayers, typing.Sequence[MeshUVLoopLayer], typing.Mapping[str, MeshUVLoopLayer], bpy_prop_collection] = ...

  """

  All UV loop layers

  """

  vertex_colors: typing.Union[LoopColors, typing.Sequence[MeshLoopColorLayer], typing.Mapping[str, MeshLoopColorLayer], bpy_prop_collection] = ...

  """

  All vertex colors

  """

  vertex_layers_float: typing.Union[VertexFloatProperties, typing.Sequence[MeshVertexFloatPropertyLayer], typing.Mapping[str, MeshVertexFloatPropertyLayer], bpy_prop_collection] = ...

  vertex_layers_int: typing.Union[VertexIntProperties, typing.Sequence[MeshVertexIntPropertyLayer], typing.Mapping[str, MeshVertexIntPropertyLayer], bpy_prop_collection] = ...

  vertex_layers_string: typing.Union[VertexStringProperties, typing.Sequence[MeshVertexStringPropertyLayer], typing.Mapping[str, MeshVertexStringPropertyLayer], bpy_prop_collection] = ...

  vertex_paint_masks: typing.Union[typing.Sequence[MeshPaintMaskLayer], typing.Mapping[str, MeshPaintMaskLayer], bpy_prop_collection] = ...

  """

  Vertex paint mask

  """

  vertices: typing.Union[MeshVertices, typing.Sequence[MeshVertex], typing.Mapping[str, MeshVertex], bpy_prop_collection] = ...

  """

  Vertices of the mesh

  """

  edge_keys: typing.Any = ...

  """

  (readonly)

  """

  def transform(self, matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]], shape_keys: bool = False) -> None:

    """

    Transform mesh vertices by a matrix (Warning: inverts normals if matrix is negative)

    """

    ...

  def flip_normals(self) -> None:

    """

    Invert winding of all polygons (clears tessellation, does not handle custom normals)

    """

    ...

  def calc_normals(self) -> None:

    """

    Calculate vertex normals

    """

    ...

  def create_normals_split(self) -> None:

    """

    Empty split vertex normals

    """

    ...

  def calc_normals_split(self) -> None:

    """

    Calculate split vertex normals, which preserve sharp edges

    """

    ...

  def free_normals_split(self) -> None:

    """

    Free split vertex normals

    """

    ...

  def split_faces(self, free_loop_normals: bool = True) -> None:

    """

    Split faces based on the edge angle

    """

    ...

  def calc_tangents(self, uvmap: str = '') -> None:

    """

    Compute tangents and bitangent signs, to be used together with the split normals to get a complete tangent space for normal mapping (split normals are also computed if not yet present)

    """

    ...

  def free_tangents(self) -> None:

    """

    Free tangents

    """

    ...

  def calc_loop_triangles(self) -> None:

    """

    Calculate loop triangle tessellation (supports editmode too)

    """

    ...

  def calc_smooth_groups(self, use_bitflags: bool = False) -> None:

    """

    Calculate smooth groups from sharp edges

    """

    ...

  def normals_split_custom_set(self, normals: typing.Tuple[typing.Tuple[float, float, float]]) -> None:

    """

    Define custom split normals of this mesh (use zero-vectors to keep auto ones)

    """

    ...

  def normals_split_custom_set_from_vertices(self, normals: typing.Tuple[typing.Tuple[float, float, float]]) -> None:

    """

    Define custom split normals of this mesh, from vertices' normals (use zero-vectors to keep auto ones)

    """

    ...

  def update(self, calc_edges: bool = False, calc_edges_loose: bool = False) -> None:

    """

    update

    """

    ...

  def update_gpu_tag(self) -> None:

    """

    update_gpu_tag

    """

    ...

  def unit_test_compare(self, mesh: Mesh = None, threshold: float = 7.1526e-06) -> str:

    """

    unit_test_compare

    """

    ...

  def clear_geometry(self) -> None:

    """

    Remove all geometry from the mesh. Note that this does not free shape keys or materials

    """

    ...

  def validate(self, verbose: bool = False, clean_customdata: bool = True) -> bool:

    """

    Validate geometry, return True when the mesh has had invalid geometry corrected/removed

    """

    ...

  def validate_material_indices(self) -> bool:

    """

    Validate material indices of polygons, return True when the mesh has had invalid indices corrected (to default 0)

    """

    ...

  def count_selected_items(self) -> typing.Tuple[int, int, int]:

    """

    Return the number of selected items (vert, edge, face)

    """

    ...

  def from_pydata(self, vertices: typing.Any, edges: typing.Any, faces: typing.Any) -> None:

    """

    Make a mesh from a list of vertices/edges/faces
Until we have a nicer way to make geometry, use this.

    Warning: Invalid mesh data
*(out of range indices, edges with matching indices,
2 sided faces... etc)* are **not** prevented.
If the data used for mesh creation isn't known to be valid,
run :class:`Mesh.validate` after this function.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MetaBall(bpy_struct, ID):

  """

  Metaball data-block to defined blobby surfaces

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  cycles: CyclesMeshSettings = ...

  """

  Cycles mesh settings

  """

  elements: typing.Union[MetaBallElements, typing.Sequence[MetaElement], typing.Mapping[str, MetaElement], bpy_prop_collection] = ...

  """

  Meta elements

  """

  is_editmode: bool = ...

  """

  True when used in editmode

  """

  materials: typing.Union[IDMaterials, typing.Sequence[Material], typing.Mapping[str, Material], bpy_prop_collection] = ...

  render_resolution: float = ...

  """

  Polygonization resolution in rendering

  """

  resolution: float = ...

  """

  Polygonization resolution in the 3D viewport

  """

  texspace_location: typing.Tuple[float, float, float] = ...

  """

  Texture space location

  """

  texspace_size: typing.Tuple[float, float, float] = ...

  """

  Texture space size

  """

  threshold: float = ...

  """

  Influence of meta elements

  """

  update_method: str = ...

  """

  Metaball edit update behavior

  * ``UPDATE_ALWAYS``
Always, While editing, update metaball always.

  * ``HALFRES``
Half, While editing, update metaball in half resolution.

  * ``FAST``
Fast, While editing, update metaball without polygonization.

  * ``NEVER``
Never, While editing, don't update metaball at all.

  """

  use_auto_texspace: bool = ...

  """

  Adjust active object's texture space automatically when transforming object

  """

  def transform(self, matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]]) -> None:

    """

    Transform meta elements by a matrix

    """

    ...

  def update_gpu_tag(self) -> None:

    """

    update_gpu_tag

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieClip(bpy_struct, ID):

  """

  MovieClip data-block referencing an external movie file

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  colorspace_settings: ColorManagedInputColorspaceSettings = ...

  """

  Input color space settings

  """

  display_aspect: typing.Tuple[float, float] = ...

  """

  Display Aspect for this clip, does not affect rendering

  """

  filepath: str = ...

  """

  Filename of the movie or sequence file

  """

  fps: float = ...

  """

  Detected frame rate of the movie clip in frames per second

  """

  frame_duration: int = ...

  """

  Detected duration of movie clip in frames

  """

  frame_offset: int = ...

  """

  Offset of footage first frame relative to its file name (affects only how footage is loading, does not change data associated with a clip)

  """

  frame_start: int = ...

  """

  Global scene frame number at which this movie starts playing (affects all data associated with a clip)

  """

  grease_pencil: GreasePencil = ...

  """

  Grease pencil data for this movie clip

  """

  proxy: MovieClipProxy = ...

  size: typing.Tuple[int, int] = ...

  """

  Width and height in pixels, zero when image data cant be loaded

  """

  source: str = ...

  """

  Where the clip comes from

  * ``SEQUENCE``
Image Sequence, Multiple image files, as a sequence.

  * ``MOVIE``
Movie File, Movie file.

  """

  tracking: MovieTracking = ...

  use_proxy: bool = ...

  """

  Use a preview proxy and/or timecode index for this clip

  """

  use_proxy_custom_directory: bool = ...

  """

  Create proxy images in a custom directory (default is movie location)

  """

  def metadata(self) -> IDPropertyWrapPtr:

    """

    Retrieve metadata of the movie file

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeTree(ID):

  """

  Node tree consisting of linked nodes used for shading, textures and compositing

  """

  active_input: int = ...

  """

  Index of the active input

  """

  active_output: int = ...

  """

  Index of the active output

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  bl_description: str = ...

  bl_icon: str = ...

  """

  The node tree icon

  """

  bl_idname: str = ...

  bl_label: str = ...

  """

  The node tree label

  """

  grease_pencil: GreasePencil = ...

  """

  Grease Pencil data-block

  """

  inputs: typing.Union[NodeTreeInputs, typing.Sequence[NodeSocketInterface], typing.Mapping[str, NodeSocketInterface], bpy_prop_collection] = ...

  """

  Node tree inputs

  """

  links: typing.Union[NodeLinks, typing.Sequence[NodeLink], typing.Mapping[str, NodeLink], bpy_prop_collection] = ...

  nodes: typing.Union[Nodes, typing.Sequence[Node], typing.Mapping[str, Node], bpy_prop_collection] = ...

  outputs: typing.Union[NodeTreeOutputs, typing.Sequence[NodeSocketInterface], typing.Mapping[str, NodeSocketInterface], bpy_prop_collection] = ...

  """

  Node tree outputs

  """

  type: str = ...

  """

  Node Tree type (deprecated, bl_idname is the actual node tree type identifier)

  * ``SHADER``
Shader, Shader nodes.

  * ``TEXTURE``
Texture, Texture nodes.

  * ``COMPOSITING``
Compositing, Compositing nodes.

  * ``SIMULATION``
Simulation, Simulation nodes.

  """

  view_center: typing.Tuple[float, float] = ...

  def interface_update(self, context: Context) -> None:

    """

    Updated node group interface

    """

    ...

  @classmethod

  def poll(cls, context: Context) -> bool:

    """

    Check visibility in the editor

    """

    ...

  def update(self) -> None:

    """

    Update on editor changes

    """

    ...

  @classmethod

  def get_from_context(cls, context: Context) -> None:

    """

    Get a node tree from the context

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Object(bpy_struct, ID):

  """

  Object data-block defining an object in a scene

  """

  active_material: Material = ...

  """

  Active material being displayed

  """

  active_material_index: int = ...

  """

  Index of active material slot

  """

  active_shape_key: ShapeKey = ...

  """

  Current shape key

  """

  active_shape_key_index: int = ...

  """

  Current shape key index

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  animation_visualization: AnimViz = ...

  """

  Animation data for this data-block

  """

  bound_box: typing.Tuple[typing.Tuple[float, float, float], ...] = ...

  """

  Object's bounding box in object-space coordinates, all values are -1.0 when not available

  """

  collision: CollisionSettings = ...

  """

  Settings for using the object as a collider in physics simulation

  """

  color: typing.Tuple[float, float, float, float] = ...

  """

  Object color and alpha, used when faces have the ObColor mode enabled

  """

  constraints: typing.Union[ObjectConstraints, typing.Sequence[Constraint], typing.Mapping[str, Constraint], bpy_prop_collection] = ...

  """

  Constraints affecting the transformation of the object

  """

  cycles: CyclesObjectSettings = ...

  """

  Cycles object settings

  """

  cycles_visibility: CyclesVisibilitySettings = ...

  """

  Cycles visibility settings

  """

  data: ID = ...

  """

  Object data

  """

  delta_location: typing.Tuple[float, float, float] = ...

  """

  Extra translation added to the location of the object

  """

  delta_rotation_euler: typing.Tuple[float, float, float] = ...

  """

  Extra rotation added to the rotation of the object (when using Euler rotations)

  """

  delta_rotation_quaternion: typing.Tuple[float, float, float, float] = ...

  """

  Extra rotation added to the rotation of the object (when using Quaternion rotations)

  """

  delta_scale: typing.Tuple[float, float, float] = ...

  """

  Extra scaling added to the scale of the object

  """

  dimensions: typing.Tuple[float, float, float] = ...

  """

  Absolute bounding box dimensions of the object (WARNING: assigning to it or its members multiple consecutive times will not work correctly, as this needs up-to-date evaluated data)

  """

  display: ObjectDisplay = ...

  """

  Object display settings for 3d viewport

  """

  display_bounds_type: str = ...

  """

  Object boundary display type

  * ``BOX``
Box, Display bounds as box.

  * ``SPHERE``
Sphere, Display bounds as sphere.

  * ``CYLINDER``
Cylinder, Display bounds as cylinder.

  * ``CONE``
Cone, Display bounds as cone.

  * ``CAPSULE``
Capsule, Display bounds as capsule.

  """

  display_type: str = ...

  """

  How to display object in viewport

  * ``BOUNDS``
Bounds, Display the bounds of the object.

  * ``WIRE``
Wire, Display the object as a wireframe.

  * ``SOLID``
Solid, Display the object as a solid (if solid drawing is enabled in the viewport).

  * ``TEXTURED``
Textured, Display the object with textures (if textures are enabled in the viewport).

  """

  empty_display_size: float = ...

  """

  Size of display for empties in the viewport

  """

  empty_display_type: str = ...

  """

  Viewport display style for empties

  """

  empty_image_depth: str = ...

  """

  Determine which other objects will occlude the image

  """

  empty_image_offset: typing.Tuple[float, float] = ...

  """

  Origin offset distance

  """

  empty_image_side: str = ...

  """

  Show front/back side

  """

  face_maps: typing.Union[FaceMaps, typing.Sequence[FaceMap], typing.Mapping[str, FaceMap], bpy_prop_collection] = ...

  """

  Maps of faces of the object

  """

  field: FieldSettings = ...

  """

  Settings for using the object as a field in physics simulation

  """

  grease_pencil_modifiers: typing.Union[ObjectGpencilModifiers, typing.Sequence[GpencilModifier], typing.Mapping[str, GpencilModifier], bpy_prop_collection] = ...

  """

  Modifiers affecting the data of the grease pencil object

  """

  hide_render: bool = ...

  """

  Globally disable in renders

  """

  hide_select: bool = ...

  """

  Disable selection in viewport

  """

  hide_viewport: bool = ...

  """

  Globally disable in viewports

  """

  image_user: ImageUser = ...

  """

  Parameters defining which layer, pass and frame of the image is displayed

  """

  instance_collection: Collection = ...

  """

  Instance an existing collection

  """

  instance_faces_scale: float = ...

  """

  Scale the face instance objects

  """

  instance_type: str = ...

  """

  If not None, object instancing method to use

  * ``NONE``
None.

  * ``VERTS``
Vertices, Instantiate child objects on all vertices.

  * ``FACES``
Faces, Instantiate child objects on all faces.

  * ``COLLECTION``
Collection, Enable collection instancing.

  """

  is_from_instancer: bool = ...

  """

  Object comes from a instancer

  """

  is_from_set: bool = ...

  """

  Object comes from a background set

  """

  is_instancer: bool = ...

  location: typing.Tuple[float, float, float] = ...

  """

  Location of the object

  """

  lock_location: typing.Tuple[bool, bool, bool] = ...

  """

  Lock editing of location when transforming

  """

  lock_rotation: typing.Tuple[bool, bool, bool] = ...

  """

  Lock editing of rotation when transforming

  """

  lock_rotation_w: bool = ...

  """

  Lock editing of 'angle' component of four-component rotations when transforming

  """

  lock_rotations_4d: bool = ...

  """

  Lock editing of four component rotations by components (instead of as Eulers)

  """

  lock_scale: typing.Tuple[bool, bool, bool] = ...

  """

  Lock editing of scale when transforming

  """

  material_slots: typing.Union[typing.Sequence[MaterialSlot], typing.Mapping[str, MaterialSlot], bpy_prop_collection] = ...

  """

  Material slots in the object

  """

  matrix_basis: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Matrix access to location, rotation and scale (including deltas), before constraints and parenting are applied

  """

  matrix_local: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Parent relative transformation matrix - WARNING: Only takes into account 'Object' parenting, so e.g. in case of bone parenting you get a matrix relative to the Armature object, not to the actual parent bone

  """

  matrix_parent_inverse: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Inverse of object's parent matrix at time of parenting

  """

  matrix_world: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Worldspace transformation matrix

  """

  mode: str = ...

  """

  Object interaction mode

  * ``OBJECT``
Object Mode.

  * ``EDIT``
Edit Mode.

  * ``POSE``
Pose Mode.

  * ``SCULPT``
Sculpt Mode.

  * ``VERTEX_PAINT``
Vertex Paint.

  * ``WEIGHT_PAINT``
Weight Paint.

  * ``TEXTURE_PAINT``
Texture Paint.

  * ``PARTICLE_EDIT``
Particle Edit.

  * ``EDIT_GPENCIL``
Edit Mode, Edit Grease Pencil Strokes.

  * ``SCULPT_GPENCIL``
Sculpt Mode, Sculpt Grease Pencil Strokes.

  * ``PAINT_GPENCIL``
Draw, Paint Grease Pencil Strokes.

  * ``VERTEX_GPENCIL``
Vertex Paint, Grease Pencil Vertex Paint Strokes.

  * ``WEIGHT_GPENCIL``
Weight Paint, Grease Pencil Weight Paint Strokes.

  """

  modifiers: typing.Union[ObjectModifiers, typing.Sequence[Modifier], typing.Mapping[str, Modifier], bpy_prop_collection] = ...

  """

  Modifiers affecting the geometric data of the object

  """

  motion_path: MotionPath = ...

  """

  Motion Path for this element

  """

  parent: Object = ...

  """

  Parent Object

  """

  parent_bone: str = ...

  """

  Name of parent bone in case of a bone parenting relation

  """

  parent_type: str = ...

  """

  Type of parent relation

  * ``OBJECT``
Object, The object is parented to an object.

  * ``ARMATURE``
Armature.

  * ``LATTICE``
Lattice, The object is parented to a lattice.

  * ``VERTEX``
Vertex, The object is parented to a vertex.

  * ``VERTEX_3``
3 Vertices.

  * ``BONE``
Bone, The object is parented to a bone.

  """

  parent_vertices: typing.Tuple[int, int, int] = ...

  """

  Indices of vertices in case of a vertex parenting relation

  """

  particle_systems: typing.Union[ParticleSystems, typing.Sequence[ParticleSystem], typing.Mapping[str, ParticleSystem], bpy_prop_collection] = ...

  """

  Particle systems emitted from the object

  """

  pass_index: int = ...

  """

  Index number for the "Object Index" render pass

  """

  pose: Pose = ...

  """

  Current pose for armatures

  """

  pose_library: Action = ...

  """

  Action used as a pose library for armatures

  """

  proxy: Object = ...

  """

  Library object this proxy object controls

  """

  proxy_collection: Object = ...

  """

  Library collection duplicator object this proxy object controls

  """

  rigid_body: RigidBodyObject = ...

  """

  Settings for rigid body simulation

  """

  rigid_body_constraint: RigidBodyConstraint = ...

  """

  Constraint constraining rigid bodies

  """

  rotation_axis_angle: typing.Tuple[float, float, float, float] = ...

  """

  Angle of Rotation for Axis-Angle rotation representation

  """

  rotation_euler: typing.Tuple[float, float, float] = ...

  """

  Rotation in Eulers

  """

  rotation_mode: str = ...

  """

  * ``QUATERNION``
Quaternion (WXYZ), No Gimbal Lock.

  * ``XYZ``
XYZ Euler, XYZ Rotation Order - prone to Gimbal Lock (default).

  * ``XZY``
XZY Euler, XZY Rotation Order - prone to Gimbal Lock.

  * ``YXZ``
YXZ Euler, YXZ Rotation Order - prone to Gimbal Lock.

  * ``YZX``
YZX Euler, YZX Rotation Order - prone to Gimbal Lock.

  * ``ZXY``
ZXY Euler, ZXY Rotation Order - prone to Gimbal Lock.

  * ``ZYX``
ZYX Euler, ZYX Rotation Order - prone to Gimbal Lock.

  * ``AXIS_ANGLE``
Axis Angle, Axis Angle (W+XYZ), defines a rotation around some axis defined by 3D-Vector.

  """

  rotation_quaternion: typing.Tuple[float, float, float, float] = ...

  """

  Rotation in Quaternions

  """

  scale: typing.Tuple[float, float, float] = ...

  """

  Scaling of the object

  """

  shader_effects: typing.Union[ObjectShaderFx, typing.Sequence[ShaderFx], typing.Mapping[str, ShaderFx], bpy_prop_collection] = ...

  """

  Effects affecting display of object

  """

  show_all_edges: bool = ...

  """

  Display all edges for mesh objects

  """

  show_axis: bool = ...

  """

  Display the object's origin and axes

  """

  show_bounds: bool = ...

  """

  Display the object's bounds

  """

  show_empty_image_only_axis_aligned: bool = ...

  """

  Only display the image when it is aligned with the view axis

  """

  show_empty_image_orthographic: bool = ...

  """

  Display image in orthographic mode

  """

  show_empty_image_perspective: bool = ...

  """

  Display image in perspective mode

  """

  show_in_front: bool = ...

  """

  Make the object draw in front of others

  """

  show_instancer_for_render: bool = ...

  """

  Make instancer visible when rendering

  """

  show_instancer_for_viewport: bool = ...

  """

  Make instancer visible in the viewport

  """

  show_name: bool = ...

  """

  Display the object's name

  """

  show_only_shape_key: bool = ...

  """

  Always show the current Shape for this Object

  """

  show_texture_space: bool = ...

  """

  Display the object's texture space

  """

  show_transparent: bool = ...

  """

  Display material transparency in the object

  """

  show_wire: bool = ...

  """

  Add the object's wireframe over solid drawing

  """

  soft_body: SoftBodySettings = ...

  """

  Settings for soft body simulation

  """

  track_axis: str = ...

  """

  Axis that points in 'forward' direction (applies to InstanceFrame when parent 'Follow' is enabled)

  """

  type: str = ...

  """

  Type of Object

  """

  up_axis: str = ...

  """

  Axis that points in the upward direction (applies to InstanceFrame when parent 'Follow' is enabled)

  """

  use_dynamic_topology_sculpting: bool = ...

  use_empty_image_alpha: bool = ...

  """

  Use alpha blending instead of alpha test (can produce sorting artifacts)

  """

  use_grease_pencil_lights: bool = ...

  """

  Lights affect grease pencil object

  """

  use_instance_faces_scale: bool = ...

  """

  Scale instance based on face size

  """

  use_instance_vertices_rotation: bool = ...

  """

  Rotate instance according to vertex normal

  """

  use_shape_key_edit_mode: bool = ...

  """

  Apply shape keys in edit mode (for Meshes only)

  """

  vertex_groups: typing.Union[VertexGroups, typing.Sequence[VertexGroup], typing.Mapping[str, VertexGroup], bpy_prop_collection] = ...

  """

  Vertex groups of the object

  """

  children: typing.Any = ...

  """

  All the children of this object.

    Note: Takes ``O(len(bpy.data.objects))`` time.

  (readonly)

  """

  users_collection: typing.Any = ...

  """

  The collections this object is in.

  Note: Takes ``O(len(bpy.data.collections) + len(bpy.data.scenes))`` time.

  (readonly)

  """

  users_scene: typing.Any = ...

  """

  The scenes this object is in.

    Note: Takes ``O(len(bpy.data.scenes) * len(bpy.data.objects))`` time.

  (readonly)

  """

  def select_get(self, view_layer: ViewLayer = None) -> bool:

    """

    Test if the object is selected. The selection state is per view layer

    """

    ...

  def select_set(self, state: bool, view_layer: ViewLayer = None) -> None:

    """

    Select or deselect the object. The selection state is per view layer

    """

    ...

  def hide_get(self, view_layer: ViewLayer = None) -> bool:

    """

    Test if the object is hidden for viewport editing. This hiding state is per view layer

    """

    ...

  def hide_set(self, state: bool, view_layer: ViewLayer = None) -> None:

    """

    Hide the object for viewport editing. This hiding state is per view layer

    """

    ...

  def visible_get(self, view_layer: ViewLayer = None, viewport: SpaceView3D = None) -> bool:

    """

    Test if the object is visible in the 3D viewport, taking into account all visibility settings

    """

    ...

  def holdout_get(self, view_layer: ViewLayer = None) -> bool:

    """

    Test if object is masked in the view layer

    """

    ...

  def indirect_only_get(self, view_layer: ViewLayer = None) -> bool:

    """

    Test if object is set to contribute only indirectly (through shadows and reflections) in the view layer

    """

    ...

  def local_view_get(self, viewport: SpaceView3D) -> bool:

    """

    Get the local view state for this object

    """

    ...

  def local_view_set(self, viewport: SpaceView3D, state: bool) -> None:

    """

    Set the local view state for this object

    """

    ...

  def visible_in_viewport_get(self, viewport: SpaceView3D) -> bool:

    """

    Check for local view and local collections for this viewport and object

    """

    ...

  def convert_space(self, pose_bone: PoseBone = None, matrix: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0)), from_space: str = 'WORLD', to_space: str = 'WORLD') -> typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]]:

    """

    Convert (transform) the given matrix from one space to another

    """

    ...

  def calc_matrix_camera(self, depsgraph: Depsgraph, x: int = 1, y: int = 1, scale_x: float = 1.0, scale_y: float = 1.0) -> typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]]:

    """

    Generate the camera projection matrix of this object (mostly useful for Camera and Light types)

    """

    ...

  def camera_fit_coords(self, depsgraph: Depsgraph, coordinates: typing.Tuple[float]) -> None:

    """

    Compute the coordinate (and scale for ortho cameras) given object should be to 'see' all given coordinates

    """

    ...

  def to_mesh(self, preserve_all_data_layers: bool = False, depsgraph: Depsgraph = None) -> Mesh:

    """

    Create a Mesh data-block from the current state of the object. The object owns the data-block. To force free it use to_mesh_clear(). The result is temporary and can not be used by objects from the main database

    """

    ...

  def to_mesh_clear(self) -> None:

    """

    Clears mesh data-block created by to_mesh()

    """

    ...

  def find_armature(self) -> Object:

    """

    Find armature influencing this object as a parent or via a modifier

    """

    ...

  def shape_key_add(self, name: str = 'Key', from_mix: bool = True) -> ShapeKey:

    """

    Add shape key to this object

    """

    ...

  def shape_key_remove(self, key: ShapeKey) -> None:

    """

    Remove a Shape Key from this object

    """

    ...

  def shape_key_clear(self) -> None:

    """

    Remove all Shape Keys from this object

    """

    ...

  def ray_cast(self, origin: typing.Tuple[float, float, float], direction: typing.Tuple[float, float, float], distance: float = 1.70141e+38, depsgraph: Depsgraph = None) -> None:

    """

    Cast a ray onto evaluated geometry, in object space (using context's or provided depsgraph to get evaluated mesh if needed)

    """

    ...

  def closest_point_on_mesh(self, origin: typing.Tuple[float, float, float], distance: float = 1.84467e+19, depsgraph: Depsgraph = None) -> None:

    """

    Find the nearest point on evaluated geometry, in object space (using context's or provided depsgraph to get evaluated mesh if needed)

    """

    ...

  def is_modified(self, scene: Scene, settings: str) -> bool:

    """

    Determine if this object is modified from the base mesh data

    """

    ...

  def is_deform_modified(self, scene: Scene, settings: str) -> bool:

    """

    Determine if this object is modified by a deformation from the base mesh data

    """

    ...

  def update_from_editmode(self) -> bool:

    """

    Load the objects edit-mode data into the object data

    """

    ...

  def cache_release(self) -> None:

    """

    Release memory used by caches associated with this object. Intended to be used by render engines only

    """

    ...

  def generate_gpencil_strokes(self, grease_pencil_object: Object, use_collections: bool = True, scale_thickness: float = 1.0, sample: float = 0.0) -> bool:

    """

    Convert a curve object to grease pencil strokes.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PaintCurve(bpy_struct, ID):

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Palette(bpy_struct, ID):

  colors: typing.Union[PaletteColors, typing.Sequence[PaletteColor], typing.Mapping[str, PaletteColor], bpy_prop_collection] = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleSettings(bpy_struct, ID):

  """

  Particle settings, reusable by multiple particle systems

  """

  active_instanceweight: ParticleDupliWeight = ...

  active_instanceweight_index: int = ...

  active_texture: Texture = ...

  """

  Active texture slot being displayed

  """

  active_texture_index: int = ...

  """

  Index of active texture slot

  """

  adaptive_angle: int = ...

  """

  How many degrees path has to curve to make another render segment

  """

  adaptive_pixel: int = ...

  """

  How many pixels path has to cover to make another render segment

  """

  angular_velocity_factor: float = ...

  """

  Angular velocity amount (in radians per second)

  """

  angular_velocity_mode: str = ...

  """

  What axis is used to change particle rotation with time

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  apply_effector_to_children: bool = ...

  """

  Apply effectors to children

  """

  apply_guide_to_children: bool = ...

  bending_random: float = ...

  """

  Random stiffness of hairs

  """

  boids: BoidSettings = ...

  branch_threshold: float = ...

  """

  Threshold of branching

  """

  brownian_factor: float = ...

  """

  Amount of random, erratic particle movement

  """

  child_length: float = ...

  """

  Length of child paths

  """

  child_length_threshold: float = ...

  """

  Amount of particles left untouched by child path length

  """

  child_nbr: int = ...

  """

  Number of children/parent

  """

  child_parting_factor: float = ...

  """

  Create parting in the children based on parent strands

  """

  child_parting_max: float = ...

  """

  Maximum root to tip angle (tip distance/root distance for long hair)

  """

  child_parting_min: float = ...

  """

  Minimum root to tip angle (tip distance/root distance for long hair)

  """

  child_radius: float = ...

  """

  Radius of children around parent

  """

  child_roundness: float = ...

  """

  Roundness of children around parent

  """

  child_size: float = ...

  """

  A multiplier for the child particle size

  """

  child_size_random: float = ...

  """

  Random variation to the size of the child particles

  """

  child_type: str = ...

  """

  Create child particles

  """

  clump_curve: CurveMapping = ...

  """

  Curve defining clump tapering

  """

  clump_factor: float = ...

  """

  Amount of clumping

  """

  clump_noise_size: float = ...

  """

  Size of clump noise

  """

  clump_shape: float = ...

  """

  Shape of clumping

  """

  collision_collection: Collection = ...

  """

  Limit colliders to this collection

  """

  color_maximum: float = ...

  """

  Maximum length of the particle color vector

  """

  count: int = ...

  """

  Total number of particles

  """

  courant_target: float = ...

  """

  The relative distance a particle can move before requiring more subframes (target Courant number); 0.01-0.3 is the recommended range

  """

  create_long_hair_children: bool = ...

  """

  Calculate children that suit long hair well

  """

  damping: float = ...

  """

  Amount of damping

  """

  display_color: str = ...

  """

  Draw additional particle data as a color

  """

  display_method: str = ...

  """

  How particles are drawn in viewport

  """

  display_percentage: int = ...

  """

  Percentage of particles to display in 3D view

  """

  display_size: float = ...

  """

  Size of particles on viewport in BU

  """

  display_step: int = ...

  """

  How many steps paths are drawn with (power of 2)

  """

  distribution: str = ...

  """

  How to distribute particles on selected element

  """

  drag_factor: float = ...

  """

  Amount of air-drag

  """

  effect_hair: float = ...

  """

  Hair stiffness for effectors

  """

  effector_amount: int = ...

  """

  How many particles are effectors (0 is all particles)

  """

  effector_weights: EffectorWeights = ...

  emit_from: str = ...

  """

  Where to emit particles from

  """

  factor_random: float = ...

  """

  Give the starting velocity a random variation

  """

  fluid: SPHFluidSettings = ...

  force_field_1: FieldSettings = ...

  force_field_2: FieldSettings = ...

  frame_end: float = ...

  """

  Frame number to stop emitting particles

  """

  frame_start: float = ...

  """

  Frame number to start emitting particles

  """

  grid_random: float = ...

  """

  Add random offset to the grid locations

  """

  grid_resolution: int = ...

  """

  The resolution of the particle grid

  """

  hair_length: float = ...

  """

  Length of the hair

  """

  hair_step: int = ...

  """

  Number of hair segments

  """

  hexagonal_grid: bool = ...

  """

  Create the grid in a hexagonal pattern

  """

  instance_collection: Collection = ...

  """

  Show Objects in this collection in place of particles

  """

  instance_object: Object = ...

  """

  Show this Object in place of particles

  """

  instance_weights: typing.Union[typing.Sequence[ParticleDupliWeight], typing.Mapping[str, ParticleDupliWeight], bpy_prop_collection] = ...

  """

  Weights for all of the objects in the dupli collection

  """

  integrator: str = ...

  """

  Algorithm used to calculate physics, from the fastest to the most stable/accurate: Midpoint, Euler, Verlet, RK4 (Old)

  """

  invert_grid: bool = ...

  """

  Invert what is considered object and what is not

  """

  is_fluid: bool = ...

  """

  Particles were created by a fluid simulation

  """

  jitter_factor: float = ...

  """

  Amount of jitter applied to the sampling

  """

  keyed_loops: int = ...

  """

  Number of times the keys are looped

  """

  keys_step: int = ...

  kink: str = ...

  """

  Type of periodic offset on the path

  """

  kink_amplitude: float = ...

  """

  The amplitude of the offset

  """

  kink_amplitude_clump: float = ...

  """

  How much clump affects kink amplitude

  """

  kink_amplitude_random: float = ...

  """

  Random variation of the amplitude

  """

  kink_axis: str = ...

  """

  Which axis to use for offset

  """

  kink_axis_random: float = ...

  """

  Random variation of the orientation

  """

  kink_extra_steps: int = ...

  """

  Extra steps for resolution of special kink features

  """

  kink_flat: float = ...

  """

  How flat the hairs are

  """

  kink_frequency: float = ...

  """

  The frequency of the offset (1/total length)

  """

  kink_shape: float = ...

  """

  Adjust the offset to the beginning/end

  """

  length_random: float = ...

  """

  Give path length a random variation

  """

  lifetime: float = ...

  """

  Life span of the particles

  """

  lifetime_random: float = ...

  """

  Give the particle life a random variation

  """

  line_length_head: float = ...

  """

  Length of the line's head

  """

  line_length_tail: float = ...

  """

  Length of the line's tail

  """

  lock_boids_to_surface: bool = ...

  """

  Constrain boids to a surface

  """

  mass: float = ...

  """

  Mass of the particles

  """

  material: int = ...

  """

  Index of material slot used for rendering particles

  """

  material_slot: str = ...

  """

  Material slot used for rendering particles

  """

  normal_factor: float = ...

  """

  Let the surface normal give the particle a starting velocity

  """

  object_align_factor: typing.Tuple[float, float, float] = ...

  """

  Let the emitter object orientation give the particle a starting velocity

  """

  object_factor: float = ...

  """

  Let the object give the particle a starting velocity

  """

  particle_factor: float = ...

  """

  Let the target particle give the particle a starting velocity

  """

  particle_size: float = ...

  """

  The size of the particles

  """

  path_end: float = ...

  """

  End time of drawn path

  """

  path_start: float = ...

  """

  Starting time of drawn path

  """

  phase_factor: float = ...

  """

  Rotation around the chosen orientation axis

  """

  phase_factor_random: float = ...

  """

  Randomize rotation around the chosen orientation axis

  """

  physics_type: str = ...

  """

  Particle physics type

  """

  radius_scale: float = ...

  """

  Multiplier of diameter properties

  """

  react_event: str = ...

  """

  The event of target particles to react on

  """

  reactor_factor: float = ...

  """

  Let the vector away from the target particle's location give the particle a starting velocity

  """

  render_step: int = ...

  """

  How many steps paths are rendered with (power of 2)

  """

  render_type: str = ...

  """

  How particles are rendered

  """

  rendered_child_count: int = ...

  """

  Number of children/parent for rendering

  """

  root_radius: float = ...

  """

  Strand diameter width at the root

  """

  rotation_factor_random: float = ...

  """

  Randomize particle orientation

  """

  rotation_mode: str = ...

  """

  Particle orientation axis (does not affect Explode modifier's results)

  """

  roughness_1: float = ...

  """

  Amount of location dependent rough

  """

  roughness_1_size: float = ...

  """

  Size of location dependent rough

  """

  roughness_2: float = ...

  """

  Amount of random rough

  """

  roughness_2_size: float = ...

  """

  Size of random rough

  """

  roughness_2_threshold: float = ...

  """

  Amount of particles left untouched by random rough

  """

  roughness_curve: CurveMapping = ...

  """

  Curve defining roughness

  """

  roughness_end_shape: float = ...

  """

  Shape of end point rough

  """

  roughness_endpoint: float = ...

  """

  Amount of end point rough

  """

  shape: float = ...

  """

  Strand shape parameter

  """

  show_guide_hairs: bool = ...

  """

  Show guide hairs

  """

  show_hair_grid: bool = ...

  """

  Show hair simulation grid

  """

  show_health: bool = ...

  """

  Draw boid health

  """

  show_number: bool = ...

  """

  Show particle number

  """

  show_size: bool = ...

  """

  Show particle size

  """

  show_unborn: bool = ...

  """

  Show particles before they are emitted

  """

  show_velocity: bool = ...

  """

  Show particle velocity

  """

  size_random: float = ...

  """

  Give the particle size a random variation

  """

  subframes: int = ...

  """

  Subframes to simulate for improved stability and finer granularity simulations (dt = timestep / (subframes + 1))

  """

  tangent_factor: float = ...

  """

  Let the surface tangent give the particle a starting velocity

  """

  tangent_phase: float = ...

  """

  Rotate the surface tangent

  """

  texture_slots: typing.Union[ParticleSettingsTextureSlots, typing.Sequence[ParticleSettingsTextureSlot], typing.Mapping[str, ParticleSettingsTextureSlot], bpy_prop_collection] = ...

  """

  Texture slots defining the mapping and influence of textures

  """

  time_tweak: float = ...

  """

  A multiplier for physics timestep (1.0 means one frame = 1/25 seconds)

  """

  timestep: float = ...

  """

  The simulation timestep per frame (seconds per frame)

  """

  tip_radius: float = ...

  """

  Strand diameter width at the tip

  """

  trail_count: int = ...

  """

  Number of trail particles

  """

  twist: float = ...

  """

  Number of turns around parent along the strand

  """

  twist_curve: CurveMapping = ...

  """

  Curve defining twist

  """

  type: str = ...

  """

  Particle Type

  """

  use_absolute_path_time: bool = ...

  """

  Path timing is in absolute frames

  """

  use_adaptive_subframes: bool = ...

  """

  Automatically set the number of subframes

  """

  use_advanced_hair: bool = ...

  """

  Use full physics calculations for growing hair

  """

  use_close_tip: bool = ...

  """

  Set tip radius to zero

  """

  use_clump_curve: bool = ...

  """

  Use a curve to define clump tapering

  """

  use_clump_noise: bool = ...

  """

  Create random clumps around the parent

  """

  use_collection_count: bool = ...

  """

  Use object multiple times in the same collection

  """

  use_collection_pick_random: bool = ...

  """

  Pick objects from collection randomly

  """

  use_dead: bool = ...

  """

  Show particles after they have died

  """

  use_die_on_collision: bool = ...

  """

  Particles die when they collide with a deflector object

  """

  use_dynamic_rotation: bool = ...

  """

  Particle rotations are affected by collisions and effectors

  """

  use_emit_random: bool = ...

  """

  Emit in random order of elements

  """

  use_even_distribution: bool = ...

  """

  Use even distribution from faces based on face areas or edge lengths

  """

  use_global_instance: bool = ...

  """

  Use object's global coordinates for duplication

  """

  use_hair_bspline: bool = ...

  """

  Interpolate hair using B-Splines

  """

  use_modifier_stack: bool = ...

  """

  Emit particles from mesh with modifiers applied (must use same subdivision surface level for viewport and render for correct results)

  """

  use_multiply_size_mass: bool = ...

  """

  Multiply mass by particle size

  """

  use_parent_particles: bool = ...

  """

  Render parent particles

  """

  use_react_multiple: bool = ...

  """

  React multiple times

  """

  use_react_start_end: bool = ...

  """

  Give birth to unreacted particles eventually

  """

  use_regrow_hair: bool = ...

  """

  Regrow hair for each frame

  """

  use_render_adaptive: bool = ...

  """

  Draw steps of the particle path

  """

  use_rotation_instance: bool = ...

  """

  Use object's rotation for duplication (global x-axis is aligned particle rotation axis)

  """

  use_rotations: bool = ...

  """

  Calculate particle rotations

  """

  use_roughness_curve: bool = ...

  """

  Use a curve to define roughness

  """

  use_scale_instance: bool = ...

  """

  Use object's scale for duplication

  """

  use_self_effect: bool = ...

  """

  Particle effectors affect themselves

  """

  use_size_deflect: bool = ...

  """

  Use particle's size in deflection

  """

  use_strand_primitive: bool = ...

  """

  Use the strand primitive for rendering

  """

  use_twist_curve: bool = ...

  """

  Use a curve to define twist

  """

  use_velocity_length: bool = ...

  """

  Multiply line length by particle speed

  """

  use_whole_collection: bool = ...

  """

  Use whole collection at once

  """

  userjit: int = ...

  """

  Emission locations per face (0 = automatic)

  """

  virtual_parents: float = ...

  """

  Relative amount of virtual parents

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Scene(bpy_struct, ID):

  """

  Scene data-block, consisting in objects and defining time and render related settings

  """

  active_clip: MovieClip = ...

  """

  Active movie clip used for constraints and viewport drawing

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  audio_distance_model: str = ...

  """

  Distance model for distance attenuation calculation

  * ``NONE``
None, No distance attenuation.

  * ``INVERSE``
Inverse, Inverse distance model.

  * ``INVERSE_CLAMPED``
Inverse Clamped, Inverse distance model with clamping.

  * ``LINEAR``
Linear, Linear distance model.

  * ``LINEAR_CLAMPED``
Linear Clamped, Linear distance model with clamping.

  * ``EXPONENT``
Exponent, Exponent distance model.

  * ``EXPONENT_CLAMPED``
Exponent Clamped, Exponent distance model with clamping.

  """

  audio_doppler_factor: float = ...

  """

  Pitch factor for Doppler effect calculation

  """

  audio_doppler_speed: float = ...

  """

  Speed of sound for Doppler effect calculation

  """

  audio_volume: float = ...

  """

  Audio volume

  """

  background_set: Scene = ...

  """

  Background set scene

  """

  camera: Object = ...

  """

  Active camera, used for rendering the scene

  """

  collection: Collection = ...

  """

  Scene master collection that objects and other collections in the scene

  """

  cursor: View3DCursor = ...

  cycles: CyclesRenderSettings = ...

  """

  Cycles render settings

  """

  cycles_curves: CyclesCurveRenderSettings = ...

  """

  Cycles hair rendering settings

  """

  display: SceneDisplay = ...

  """

  Scene display settings for 3d viewport

  """

  display_settings: ColorManagedDisplaySettings = ...

  """

  Settings of device saved image would be displayed on

  """

  eevee: SceneEEVEE = ...

  """

  EEVEE settings for the scene

  """

  frame_current: int = ...

  """

  Current Frame, to update animation data from python frame_set() instead

  """

  frame_current_final: float = ...

  """

  Current frame with subframe and time remapping applied

  """

  frame_end: int = ...

  """

  Final frame of the playback/rendering range

  """

  frame_float: float = ...

  frame_preview_end: int = ...

  """

  Alternative end frame for UI playback

  """

  frame_preview_start: int = ...

  """

  Alternative start frame for UI playback

  """

  frame_start: int = ...

  """

  First frame of the playback/rendering range

  """

  frame_step: int = ...

  """

  Number of frames to skip forward while rendering/playing back each frame

  """

  frame_subframe: float = ...

  gravity: typing.Tuple[float, float, float] = ...

  """

  Constant acceleration in a given direction

  """

  grease_pencil: GreasePencil = ...

  """

  Grease Pencil data-block used for annotations in the 3D view

  """

  grease_pencil_settings: SceneGpencil = ...

  """

  Grease Pencil settings for the scene

  """

  is_nla_tweakmode: bool = ...

  """

  Whether there is any action referenced by NLA being edited (strictly read-only)

  """

  keying_sets: typing.Union[KeyingSets, typing.Sequence[KeyingSet], typing.Mapping[str, KeyingSet], bpy_prop_collection] = ...

  """

  Absolute Keying Sets for this Scene

  """

  keying_sets_all: typing.Union[KeyingSetsAll, typing.Sequence[KeyingSet], typing.Mapping[str, KeyingSet], bpy_prop_collection] = ...

  """

  All Keying Sets available for use (Builtins and Absolute Keying Sets for this Scene)

  """

  lock_frame_selection_to_range: bool = ...

  """

  Don't allow frame to be selected with mouse outside of frame range

  """

  node_tree: NodeTree = ...

  """

  Compositing node tree

  """

  objects: typing.Union[SceneObjects, typing.Sequence[Object], typing.Mapping[str, Object], bpy_prop_collection] = ...

  render: RenderSettings = ...

  rigidbody_world: RigidBodyWorld = ...

  safe_areas: DisplaySafeAreas = ...

  sequence_editor: SequenceEditor = ...

  sequencer_colorspace_settings: ColorManagedSequencerColorspaceSettings = ...

  """

  Settings of color space sequencer is working in

  """

  show_keys_from_selected_only: bool = ...

  """

  Consider keyframes for active Object and/or its selected bones only (in timeline and when jumping between keyframes)

  """

  show_subframe: bool = ...

  """

  Show current scene subframe and allow set it using interface tools

  """

  sync_mode: str = ...

  """

  How to sync playback

  * ``NONE``
No Sync, Do not sync, play every frame.

  * ``FRAME_DROP``
Frame Dropping, Drop frames if playback is too slow.

  * ``AUDIO_SYNC``
AV-sync, Sync to audio playback, dropping frames.

  """

  timeline_markers: typing.Union[TimelineMarkers, typing.Sequence[TimelineMarker], typing.Mapping[str, TimelineMarker], bpy_prop_collection] = ...

  """

  Markers used in all timelines for the current scene

  """

  tool_settings: ToolSettings = ...

  transform_orientation_slots: typing.Union[typing.Sequence[TransformOrientationSlot], typing.Mapping[str, TransformOrientationSlot], bpy_prop_collection] = ...

  unit_settings: UnitSettings = ...

  """

  Unit editing settings

  """

  use_audio: bool = ...

  """

  Play back of audio from Sequence Editor will be muted

  """

  use_audio_scrub: bool = ...

  """

  Play audio from Sequence Editor while scrubbing

  """

  use_gravity: bool = ...

  """

  Use global gravity for all dynamics

  """

  use_nodes: bool = ...

  """

  Enable the compositing node tree

  """

  use_preview_range: bool = ...

  """

  Use an alternative start/end frame range for animation playback and view renders

  """

  use_stamp_note: str = ...

  """

  User defined note for the render stamping

  """

  view_layers: typing.Union[ViewLayers, typing.Sequence[ViewLayer], typing.Mapping[str, ViewLayer], bpy_prop_collection] = ...

  view_settings: ColorManagedViewSettings = ...

  """

  Color management settings applied on image before saving

  """

  world: World = ...

  """

  World used for rendering the scene

  """

  def statistics(self, view_layer: ViewLayer) -> str:

    """

    statistics

    """

    ...

  def frame_set(self, frame: int, subframe: float = 0.0) -> None:

    """

    Set scene frame updating all objects immediately

    """

    ...

  def uvedit_aspect(self, object: Object) -> typing.Tuple[float, float]:

    """

    Get uv aspect for current object

    """

    ...

  def ray_cast(self, depsgraph: Depsgraph, origin: typing.Tuple[float, float, float], direction: typing.Tuple[float, float, float], distance: float = 1.70141e+38) -> None:

    """

    Cast a ray onto in object space

    """

    ...

  def sequence_editor_create(self) -> SequenceEditor:

    """

    Ensure sequence editor is valid in this scene

    """

    ...

  def sequence_editor_clear(self) -> None:

    """

    Clear sequence editor in this scene

    """

    ...

  def alembic_export(self, filepath: str, frame_start: int = 1, frame_end: int = 1, xform_samples: int = 1, geom_samples: int = 1, shutter_open: float = 0.0, shutter_close: float = 1.0, selected_only: bool = False, uvs: bool = True, normals: bool = True, vcolors: bool = False, apply_subdiv: bool = True, flatten: bool = False, visible_objects_only: bool = False, renderable_only: bool = False, face_sets: bool = False, subdiv_schema: bool = False, export_hair: bool = True, export_particles: bool = True, packuv: bool = False, scale: float = 1.0, triangulate: bool = False, quad_method: str = 'BEAUTY', ngon_method: str = 'BEAUTY') -> None:

    """

    Export to Alembic file (deprecated, use the Alembic export operator)

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Screen(bpy_struct, ID):

  """

  Screen data-block, defining the layout of areas in a window

  """

  areas: typing.Union[typing.Sequence[Area], typing.Mapping[str, Area], bpy_prop_collection] = ...

  """

  Areas the screen is subdivided into

  """

  is_animation_playing: bool = ...

  """

  Animation playback is active

  """

  is_scrubbing: bool = ...

  """

  True when the user is scrubbing through time

  """

  is_temporary: bool = ...

  show_fullscreen: bool = ...

  """

  An area is maximized, filling this screen

  """

  show_statusbar: bool = ...

  """

  Show Status Bar

  """

  use_follow: bool = ...

  """

  Follow current frame in editors

  """

  use_play_3d_editors: bool = ...

  use_play_animation_editors: bool = ...

  use_play_clip_editors: bool = ...

  use_play_image_editors: bool = ...

  use_play_node_editors: bool = ...

  use_play_properties_editors: bool = ...

  use_play_sequence_editors: bool = ...

  use_play_top_left_3d_editor: bool = ...

  def statusbar_info(self) -> str:

    """

    statusbar_info

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Sound(bpy_struct, ID):

  """

  Sound data-block referencing an external or packed sound file

  """

  filepath: str = ...

  """

  Sound sample file used by this Sound data-block

  """

  packed_file: PackedFile = ...

  use_memory_cache: bool = ...

  """

  The sound file is decoded and loaded into RAM

  """

  use_mono: bool = ...

  """

  If the file contains multiple audio channels they are rendered to a single one

  """

  factory: typing.Any = ...

  """

  The aud.Factory object of the sound.

  (readonly)

  """

  def pack(self) -> None:

    """

    Pack the sound into the current blend file

    """

    ...

  def unpack(self, method: str = 'USE_LOCAL') -> None:

    """

    Unpack the sound to the samples filename

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Speaker(bpy_struct, ID):

  """

  Speaker data-block for 3D audio speaker objects

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  attenuation: float = ...

  """

  How strong the distance affects volume, depending on distance model

  """

  cone_angle_inner: float = ...

  """

  Angle of the inner cone, in degrees, inside the cone the volume is 100 %

  """

  cone_angle_outer: float = ...

  """

  Angle of the outer cone, in degrees, outside this cone the volume is the outer cone volume, between inner and outer cone the volume is interpolated

  """

  cone_volume_outer: float = ...

  """

  Volume outside the outer cone

  """

  distance_max: float = ...

  """

  Maximum distance for volume calculation, no matter how far away the object is

  """

  distance_reference: float = ...

  """

  Reference distance at which volume is 100 %

  """

  muted: bool = ...

  """

  Mute the speaker

  """

  pitch: float = ...

  """

  Playback pitch of the sound

  """

  sound: Sound = ...

  """

  Sound data-block used by this speaker

  """

  volume: float = ...

  """

  How loud the sound is

  """

  volume_max: float = ...

  """

  Maximum volume, no matter how near the object is

  """

  volume_min: float = ...

  """

  Minimum volume, no matter how far away the object is

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Text(bpy_struct, ID):

  """

  Text data-block referencing an external or packed text file

  """

  current_character: int = ...

  """

  Index of current character in current line, and also start index of character in selection if one exists

  """

  current_line: TextLine = ...

  """

  Current line, and start line of selection if one exists

  """

  current_line_index: int = ...

  """

  Index of current TextLine in TextLine collection

  """

  filepath: str = ...

  """

  Filename of the text file

  """

  indentation: str = ...

  """

  Use tabs or spaces for indentation

  * ``TABS``
Tabs, Indent using tabs.

  * ``SPACES``
Spaces, Indent using spaces.

  """

  is_dirty: bool = ...

  """

  Text file has been edited since last save

  """

  is_in_memory: bool = ...

  """

  Text file is in memory, without a corresponding file on disk

  """

  is_modified: bool = ...

  """

  Text file on disk is different than the one in memory

  """

  lines: typing.Union[typing.Sequence[TextLine], typing.Mapping[str, TextLine], bpy_prop_collection] = ...

  """

  Lines of text

  """

  select_end_character: int = ...

  """

  Index of character after end of selection in the selection end line

  """

  select_end_line: TextLine = ...

  """

  End line of selection

  """

  select_end_line_index: int = ...

  """

  Index of last TextLine in selection

  """

  use_module: bool = ...

  """

  Run this text as a script on loading, Text name must end with ".py"

  """

  def clear(self) -> None:

    """

    clear the text block

    """

    ...

  def write(self, text: str) -> None:

    """

    write text at the cursor location and advance to the end of the text block

    """

    ...

  def is_syntax_highlight_supported(self) -> bool:

    """

    Returns True if the editor supports syntax highlighting for the current text datablock

    """

    ...

  def select_set(self, line_start: int, char_start: int, line_end: int, char_end: int) -> None:

    """

    Set selection range by line and character index

    """

    ...

  def cursor_set(self, line: int, character: int = 0, select: bool = False) -> None:

    """

    Set cursor by line and (optionally) character index

    """

    ...

  def as_module(self) -> None:

    ...

  def as_string(self) -> None:

    """

    Return the text as a string.

    """

    ...

  def from_string(self, string: typing.Any) -> None:

    """

    Replace text with this string.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Texture(ID):

  """

  Texture data-block used by materials, lights, worlds and brushes

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  color_ramp: ColorRamp = ...

  contrast: float = ...

  """

  Adjust the contrast of the texture

  """

  factor_blue: float = ...

  factor_green: float = ...

  factor_red: float = ...

  intensity: float = ...

  """

  Adjust the brightness of the texture

  """

  node_tree: NodeTree = ...

  """

  Node tree for node-based textures

  """

  saturation: float = ...

  """

  Adjust the saturation of colors in the texture

  """

  type: str = ...

  """

  * ``NONE``
None.

  * ``BLEND``
Blend, Procedural - create a ramp texture.

  * ``CLOUDS``
Clouds, Procedural - create a cloud-like fractal noise texture.

  * ``DISTORTED_NOISE``
Distorted Noise, Procedural - noise texture distorted by two noise algorithms.

  * ``IMAGE``
Image or Movie, Allow for images or movies to be used as textures.

  * ``MAGIC``
Magic, Procedural - color texture based on trigonometric functions.

  * ``MARBLE``
Marble, Procedural - marble-like noise texture with wave generated bands.

  * ``MUSGRAVE``
Musgrave, Procedural - highly flexible fractal noise texture.

  * ``NOISE``
Noise, Procedural - random noise, gives a different result every time, for every frame, for every pixel.

  * ``STUCCI``
Stucci, Procedural - create a fractal noise texture.

  * ``VORONOI``
Voronoi, Procedural - create cell-like patterns based on Worley noise.

  * ``WOOD``
Wood, Procedural - wave generated bands or rings, with optional noise.

  """

  use_clamp: bool = ...

  """

  Set negative texture RGB and intensity values to zero, for some uses like displacement this option can be disabled to get the full range

  """

  use_color_ramp: bool = ...

  """

  Map the texture intensity to the color ramp. Note that the alpha value is used for image textures, enable "Calculate Alpha" for images without an alpha channel

  """

  use_nodes: bool = ...

  """

  Make this a node-based texture

  """

  use_preview_alpha: bool = ...

  """

  Show Alpha in Preview Render

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  def evaluate(self, value: typing.Tuple[float, float, float]) -> typing.Tuple[float, float, float, float]:

    """

    Evaluate the texture at the coordinates given

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VectorFont(bpy_struct, ID):

  """

  Vector font for Text objects

  """

  filepath: str = ...

  packed_file: PackedFile = ...

  def pack(self) -> None:

    """

    Pack the font into the current blend file

    """

    ...

  def unpack(self, method: str = 'USE_LOCAL') -> None:

    """

    Unpack the font to the samples filename

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Volume(bpy_struct, ID):

  """

  Volume data-block for 3D volume grids

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  display: VolumeDisplay = ...

  """

  Volume display settings for 3d viewport

  """

  filepath: str = ...

  """

  Volume file used by this Volume data-block

  """

  frame_duration: int = ...

  """

  Number of frames of the sequence to use

  """

  frame_offset: int = ...

  """

  Offset the number of the frame to use in the animation

  """

  frame_start: int = ...

  """

  Global starting frame of the sequence, assuming first has a #1

  """

  grids: typing.Union[VolumeGrids, typing.Sequence[VolumeGrid], typing.Mapping[str, VolumeGrid], bpy_prop_collection] = ...

  """

  3D volume grids

  """

  is_sequence: bool = ...

  """

  Whether the cache is separated in a series of files

  """

  materials: typing.Union[IDMaterials, typing.Sequence[Material], typing.Mapping[str, Material], bpy_prop_collection] = ...

  packed_file: PackedFile = ...

  render: VolumeRender = ...

  """

  Volume render settings for 3d viewport

  """

  sequence_mode: str = ...

  """

  Sequence playback mode

  * ``CLIP``
Clip, Hide frames outside the specified frame range.

  * ``EXTEND``
Extend, Repeat the start frame before, and the end frame after the frame range.

  * ``REPEAT``
Repeat, Cycle the frames in the sequence.

  * ``PING_PONG``
Ping-Pong, Repeat the frames, reversing the playback direction every other cycle.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WindowManager(bpy_struct, ID):

  """

  Window manager data-block defining open windows and other user interface data

  """

  addon_filter: str = ...

  """

  Filter add-ons by category

  """

  addon_search: str = ...

  """

  Search within the selected filter

  """

  addon_support: typing.Set[str] = ...

  """

  Display support level

  * ``OFFICIAL``
Official, Officially supported.

  * ``COMMUNITY``
Community, Maintained by community developers.

  * ``TESTING``
Testing, Newly contributed scripts (excluded from release builds).

  """

  is_interface_locked: bool = ...

  """

  If true, the interface is currently locked by a running job and data shouldn't be modified from application timers. Otherwise, the running job might conflict with the handler causing unexpected results or even crashes

  """

  keyconfigs: typing.Union[KeyConfigurations, typing.Sequence[KeyConfig], typing.Mapping[str, KeyConfig], bpy_prop_collection] = ...

  """

  Registered key configurations

  """

  operators: typing.Union[typing.Sequence[Operator], typing.Mapping[str, Operator], bpy_prop_collection] = ...

  """

  Operator registry

  """

  preset_name: str = ...

  """

  Name for new preset

  """

  windows: typing.Union[typing.Sequence[Window], typing.Mapping[str, Window], bpy_prop_collection] = ...

  """

  Open windows

  """

  xr_session_settings: XrSessionSettings = ...

  xr_session_state: XrSessionState = ...

  """

  Runtime state information about the VR session

  """

  @classmethod

  def fileselect_add(cls, operator: Operator) -> None:

    """

    Opens a file selector with an operator. The string properties 'filepath', 'filename', 'directory' and a 'files' collection are assigned when present in the operator

    """

    ...

  @classmethod

  def modal_handler_add(cls, operator: Operator) -> bool:

    """

    Add a modal handler to the window manager, for the given modal operator (called by invoke() with self, just before returning {'RUNNING_MODAL'})

    """

    ...

  def event_timer_add(self, time_step: float, window: Window = None) -> Timer:

    """

    Add a timer to the given window, to generate periodic 'TIMER' events

    """

    ...

  def event_timer_remove(self, timer: Timer) -> None:

    """

    event_timer_remove

    """

    ...

  @classmethod

  def gizmo_group_type_ensure(cls, identifier: str) -> None:

    """

    Activate an existing widget group (when the persistent option isn't set)

    """

    ...

  @classmethod

  def gizmo_group_type_unlink_delayed(cls, identifier: str) -> None:

    """

    Unlink a widget group (when the persistent option is set)

    """

    ...

  def progress_begin(self, min: float, max: float) -> None:

    """

    Start progress report

    """

    ...

  def progress_update(self, value: float) -> None:

    """

    Update the progress feedback

    """

    ...

  def progress_end(self) -> None:

    """

    Terminate progress report

    """

    ...

  @classmethod

  def invoke_props_popup(cls, operator: Operator, event: Event) -> typing.Set[str]:

    """

    Operator popup invoke (show operator properties and execute it automatically on changes)

    """

    ...

  @classmethod

  def invoke_props_dialog(cls, operator: Operator, width: int = 300) -> typing.Set[str]:

    """

    Operator dialog (non-autoexec popup) invoke (show operator properties and only execute it on click on OK button)

    """

    ...

  @classmethod

  def invoke_search_popup(cls, operator: Operator) -> None:

    """

    Operator search popup invoke which searches values of the operator's :class:`bpy.types.Operator.bl_property` (which must be an EnumProperty), executing it on confirmation

    """

    ...

  @classmethod

  def invoke_popup(cls, operator: Operator, width: int = 300) -> typing.Set[str]:

    """

    Operator popup invoke (only shows operator's properties, without executing it)

    """

    ...

  @classmethod

  def invoke_confirm(cls, operator: Operator, event: Event) -> typing.Set[str]:

    """

    Operator confirmation popup (only to let user confirm the execution, no operator properties shown)

    """

    ...

  @classmethod

  def popmenu_begin__internal(cls, title: str, icon: str = 'NONE') -> UIPopupMenu:

    """

    popmenu_begin__internal

    """

    ...

  @classmethod

  def popmenu_end__internal(cls, menu: UIPopupMenu) -> None:

    """

    popmenu_end__internal

    """

    ...

  @classmethod

  def popover_begin__internal(cls, ui_units_x: int = 0, from_active_button: bool = False) -> UIPopover:

    """

    popover_begin__internal

    """

    ...

  @classmethod

  def popover_end__internal(cls, menu: UIPopover, keymap: KeyMap = None) -> None:

    """

    popover_end__internal

    """

    ...

  @classmethod

  def piemenu_begin__internal(cls, title: str, icon: str = 'NONE', event: Event = None) -> UIPieMenu:

    """

    piemenu_begin__internal

    """

    ...

  @classmethod

  def piemenu_end__internal(cls, menu: UIPieMenu) -> None:

    """

    piemenu_end__internal

    """

    ...

  @classmethod

  def operator_properties_last(cls, operator: str) -> OperatorProperties:

    """

    operator_properties_last

    """

    ...

  def print_undo_steps(self) -> None:

    """

    print_undo_steps

    """

    ...

  @classmethod

  def tag_script_reload(cls) -> None:

    """

    Tag for refreshing the interface after scripts have been reloaded

    """

    ...

  def popover(self, draw_func: typing.Any) -> None:

    ...

  def popup_menu(self, draw_func: typing.Any, title: typing.Any = '', icon: typing.Any = 'NONE') -> None:

    """

    Popup menus can be useful for creating menus without having to register menu classes.

    Note that they will not block the scripts execution, so the caller can't wait for user input.

    .. code::


      import bpy


      def draw(self, context):
          self.layout.label(text="Hello World")


      bpy.context.window_manager.popup_menu(draw, title="Greeting", icon='INFO')

    """

    ...

  def popup_menu_pie(self, event: typing.Any, draw_func: typing.Any, title: typing.Any = '', icon: typing.Any = 'NONE') -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_cursor_add(self) -> None:

    """

    Undocumented, consider `contributing <https://developer.blender.org/T51061>`_.

    """

    ...

  def draw_cursor_remove(self) -> None:

    """

    Undocumented, consider `contributing <https://developer.blender.org/T51061>`_.

    """

    ...

class WorkSpace(bpy_struct, ID):

  """

  Workspace data-block, defining the working environment for the user

  """

  object_mode: str = ...

  """

  Switch to this object mode when activating the workspace

  * ``OBJECT``
Object Mode.

  * ``EDIT``
Edit Mode.

  * ``POSE``
Pose Mode.

  * ``SCULPT``
Sculpt Mode.

  * ``VERTEX_PAINT``
Vertex Paint.

  * ``WEIGHT_PAINT``
Weight Paint.

  * ``TEXTURE_PAINT``
Texture Paint.

  * ``PARTICLE_EDIT``
Particle Edit.

  * ``EDIT_GPENCIL``
Grease Pencil Edit Mode, Edit Grease Pencil Strokes.

  * ``SCULPT_GPENCIL``
Grease Pencil Sculpt Mode, Sculpt Grease Pencil Strokes.

  * ``PAINT_GPENCIL``
Grease Pencil Draw, Paint Grease Pencil Strokes.

  * ``VERTEX_GPENCIL``
Grease Pencil Vertex Paint, Grease Pencil Vertex Paint Strokes.

  * ``WEIGHT_GPENCIL``
Grease Pencil Weight Paint, Grease Pencil Weight Paint Strokes.

  """

  owner_ids: typing.Union[wmOwnerIDs, typing.Sequence[wmOwnerID], typing.Mapping[str, wmOwnerID], bpy_prop_collection] = ...

  screens: typing.Union[typing.Sequence[Screen], typing.Mapping[str, Screen], bpy_prop_collection] = ...

  """

  Screen layouts of a workspace

  """

  tools: typing.Union[wmTools, typing.Sequence[WorkSpaceTool], typing.Mapping[str, WorkSpaceTool], bpy_prop_collection] = ...

  use_filter_by_owner: bool = ...

  """

  Filter the UI by tags

  """

  @classmethod

  def status_text_set_internal(cls, text: str) -> None:

    """

    Set the status bar text, typically key shortcuts for modal operators

    """

    ...

  def status_text_set(self, text: typing.Any) -> None:

    """

    Set the status text or None to clear,
When text is a function, this will be called with the (header, context) arguments.

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class World(bpy_struct, ID):

  """

  World data-block describing the environment and ambient lighting of a scene

  """

  animation_data: AnimData = ...

  """

  Animation data for this data-block

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Color of the background

  """

  cycles: CyclesWorldSettings = ...

  """

  Cycles world settings

  """

  cycles_visibility: CyclesVisibilitySettings = ...

  """

  Cycles visibility settings

  """

  light_settings: WorldLighting = ...

  """

  World lighting settings

  """

  mist_settings: WorldMistSettings = ...

  """

  World mist settings

  """

  node_tree: NodeTree = ...

  """

  Node tree for node based worlds

  """

  use_nodes: bool = ...

  """

  Use shader nodes to render the world

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Itasc(bpy_struct, IKParam):

  """

  Parameters for the iTaSC IK solver

  """

  damping_epsilon: float = ...

  """

  Singular value under which damping is progressively applied (higher values=more stability, less reactivity - default=0.1)

  """

  damping_max: float = ...

  """

  Maximum damping coefficient when singular value is nearly 0 (higher values=more stability, less reactivity - default=0.5)

  """

  feedback: float = ...

  """

  Feedback coefficient for error correction, average response time is 1/feedback (default=20)

  """

  iterations: int = ...

  """

  Maximum number of iterations for convergence in case of reiteration

  """

  mode: str = ...

  """

  * ``ANIMATION``
Animation, Stateless solver computing pose starting from current action and non-IK constraints.

  * ``SIMULATION``
Simulation, State-full solver running in real-time context and ignoring actions and non-IK constraints.

  """

  precision: float = ...

  """

  Precision of convergence in case of reiteration

  """

  reiteration_method: str = ...

  """

  Defines if the solver is allowed to reiterate (converge until precision is met) on none, first or all frames

  * ``NEVER``
Never, The solver does not reiterate, not even on first frame (starts from rest pose).

  * ``INITIAL``
Initial, The solver reiterates (converges) on the first frame but not on subsequent frame.

  * ``ALWAYS``
Always, The solver reiterates (converges) on all frames.

  """

  solver: str = ...

  """

  Solving method selection: automatic damping or manual damping

  * ``SDLS``
SDLS, Selective Damped Least Square.

  * ``DLS``
DLS, Damped Least Square with Numerical Filtering.

  """

  step_count: int = ...

  """

  Divide the frame interval into this many steps

  """

  step_max: float = ...

  """

  Higher bound for timestep in second in case of automatic substeps

  """

  step_min: float = ...

  """

  Lower bound for timestep in second in case of automatic substeps

  """

  use_auto_step: bool = ...

  """

  Automatically determine the optimal number of steps for best performance/accuracy trade off

  """

  velocity_max: float = ...

  """

  Maximum joint velocity in rad/s (default=50)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleAlphaModifier(LineStyleModifier):

  """

  Base type to define alpha transparency modifiers

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleColorModifier(LineStyleModifier):

  """

  Base type to define line color modifiers

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier(LineStyleModifier):

  """

  Base type to define stroke geometry modifiers

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifier(LineStyleModifier):

  """

  Base type to define line thickness modifiers

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ArmatureModifier(bpy_struct, Modifier):

  """

  Armature deformation modifier

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  object: Object = ...

  """

  Armature object to deform with

  """

  use_bone_envelopes: bool = ...

  """

  Bind Bone envelopes to armature modifier

  """

  use_deform_preserve_volume: bool = ...

  """

  Deform rotation interpolation with quaternions

  """

  use_multi_modifier: bool = ...

  """

  Use same input as previous modifier, and mix results using overall vgroup

  """

  use_vertex_groups: bool = ...

  """

  Bind vertex groups to armature modifier

  """

  vertex_group: str = ...

  """

  Name of Vertex Group which determines influence of modifier per point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ArrayModifier(bpy_struct, Modifier):

  """

  Array duplication modifier

  """

  constant_offset_displace: typing.Tuple[float, float, float] = ...

  """

  Value for the distance between arrayed items

  """

  count: int = ...

  """

  Number of duplicates to make

  """

  curve: Object = ...

  """

  Curve object to fit array length to

  """

  end_cap: Object = ...

  """

  Mesh object to use as an end cap

  """

  fit_length: float = ...

  """

  Length to fit array within

  """

  fit_type: str = ...

  """

  Array length calculation method

  * ``FIXED_COUNT``
Fixed Count, Duplicate the object a certain number of times.

  * ``FIT_LENGTH``
Fit Length, Duplicate the object as many times as fits in a certain length.

  * ``FIT_CURVE``
Fit Curve, Fit the duplicated objects to a curve.

  """

  merge_threshold: float = ...

  """

  Limit below which to merge vertices

  """

  offset_object: Object = ...

  """

  Use the location and rotation of another object to determine the distance and rotational change between arrayed items

  """

  offset_u: float = ...

  """

  Amount to offset array UVs on the U axis

  """

  offset_v: float = ...

  """

  Amount to offset array UVs on the V axis

  """

  relative_offset_displace: typing.Tuple[float, float, float] = ...

  """

  The size of the geometry will determine the distance between arrayed items

  """

  start_cap: Object = ...

  """

  Mesh object to use as a start cap

  """

  use_constant_offset: bool = ...

  """

  Add a constant offset

  """

  use_merge_vertices: bool = ...

  """

  Merge vertices in adjacent duplicates

  """

  use_merge_vertices_cap: bool = ...

  """

  Merge vertices in first and last duplicates

  """

  use_object_offset: bool = ...

  """

  Add another object's transformation to the total offset

  """

  use_relative_offset: bool = ...

  """

  Add an offset relative to the object's bounding box

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BevelModifier(bpy_struct, Modifier):

  """

  Bevel modifier to make edges and vertices more rounded

  """

  affect: str = ...

  """

  Affect edges or vertices

  * ``VERTICES``
Vertices, Affect only vertices.

  * ``EDGES``
Edges, Affect only edges.

  """

  angle_limit: float = ...

  """

  Angle above which to bevel edges

  """

  custom_profile: CurveProfile = ...

  """

  The path for the custom profile

  """

  face_strength_mode: str = ...

  """

  Whether to set face strength, and which faces to set it on

  * ``FSTR_NONE``
None, Do not set face strength.

  * ``FSTR_NEW``
New, Set face strength on new faces only.

  * ``FSTR_AFFECTED``
Affected, Set face strength on new and affected faces only.

  * ``FSTR_ALL``
All, Set face strength on all faces.

  """

  harden_normals: bool = ...

  """

  Match normals of new faces to adjacent faces

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  limit_method: str = ...

  """

  * ``NONE``
None, Bevel the entire mesh by a constant amount.

  * ``ANGLE``
Angle, Only bevel edges with sharp enough angles between faces.

  * ``WEIGHT``
Weight, Use bevel weights to determine how much bevel is applied in edge mode.

  * ``VGROUP``
Vertex Group, Use vertex group weights to select whether vertex or edge is beveled.

  """

  loop_slide: bool = ...

  """

  Prefer sliding along edges to having even widths

  """

  mark_seam: bool = ...

  """

  Mark Seams along beveled edges

  """

  mark_sharp: bool = ...

  """

  Mark beveled edges as sharp

  """

  material: int = ...

  """

  Material index of generated faces, -1 for automatic

  """

  miter_inner: str = ...

  """

  Pattern to use for inside of miters

  * ``MITER_SHARP``
Sharp, Inside of miter is sharp.

  * ``MITER_ARC``
Arc, Inside of miter is arc.

  """

  miter_outer: str = ...

  """

  Pattern to use for outside of miters

  * ``MITER_SHARP``
Sharp, Outside of miter is sharp.

  * ``MITER_PATCH``
Patch, Outside of miter is squared-off patch.

  * ``MITER_ARC``
Arc, Outside of miter is arc.

  """

  offset_type: str = ...

  """

  What distance Width measures

  * ``OFFSET``
Offset, Amount is offset of new edges from original.

  * ``WIDTH``
Width, Amount is width of new face.

  * ``DEPTH``
Depth, Amount is perpendicular distance from original edge to bevel face.

  * ``PERCENT``
Percent, Amount is percent of adjacent edge length.

  * ``ABSOLUTE``
Absolute, Amount is absolute distance along adjacent edge.

  """

  profile: float = ...

  """

  The profile shape (0.5 = round)

  """

  profile_type: str = ...

  """

  The type of shape used to rebuild a beveled section

  * ``SUPERELLIPSE``
Superellipse, The profile can be a concave or convex curve.

  * ``CUSTOM``
Custom, The profile can be any arbitrary path between its endpoints.

  """

  segments: int = ...

  """

  Number of segments for round edges/verts

  """

  spread: float = ...

  """

  Spread distance for inner miter arcs

  """

  use_clamp_overlap: bool = ...

  """

  Clamp the width to avoid overlap

  """

  vertex_group: str = ...

  """

  Vertex group name

  """

  vmesh_method: str = ...

  """

  The method to use to create the mesh at intersections

  * ``ADJ``
Grid Fill, Default patterned fill.

  * ``CUTOFF``
Cutoff, A cut-off at the end of each profile before the intersection.

  """

  width: float = ...

  """

  Bevel amount

  """

  width_pct: float = ...

  """

  Bevel amount for percentage method

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BooleanModifier(bpy_struct, Modifier):

  """

  Boolean operations modifier

  """

  collection: Collection = ...

  """

  Use mesh objects in this collection for Boolean operation

  """

  debug_options: typing.Set[str] = ...

  """

  Debugging options, only when started with '-d'

  """

  double_threshold: float = ...

  """

  Threshold for checking overlapping geometry

  """

  object: Object = ...

  """

  Mesh object to use for Boolean operation

  """

  operand_type: str = ...

  """

  * ``OBJECT``
Object, Use a mesh object as the operand for the Boolean operation.

  * ``COLLECTION``
Collection, Use a collection of mesh objects as the operand for the Boolean operation.

  """

  operation: str = ...

  """

  * ``INTERSECT``
Intersect, Keep the part of the mesh that is common between all operands.

  * ``UNION``
Union, Combine meshes in an additive way.

  * ``DIFFERENCE``
Difference, Combine meshes in a subtractive way.

  """

  solver: str = ...

  """

  Method for calculating booleans

  * ``FAST``
Fast, Simple solver for the best performance, without support for overlapping geometry.

  * ``EXACT``
Exact, Advanced solver for the best result.

  """

  use_self: bool = ...

  """

  Allow self-intersection in operands

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BuildModifier(bpy_struct, Modifier):

  """

  Build effect modifier

  """

  frame_duration: float = ...

  """

  Total time the build effect requires

  """

  frame_start: float = ...

  """

  Start frame of the effect

  """

  seed: int = ...

  """

  Seed for random if used

  """

  use_random_order: bool = ...

  """

  Randomize the faces or edges during build

  """

  use_reverse: bool = ...

  """

  Deconstruct the mesh instead of building it

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CastModifier(bpy_struct, Modifier):

  """

  Modifier to cast to other shapes

  """

  cast_type: str = ...

  """

  Target object shape

  """

  factor: float = ...

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  object: Object = ...

  """

  Control object: if available, its location determines the center of the effect

  """

  radius: float = ...

  """

  Only deform vertices within this distance from the center of the effect (leave as 0 for infinite.)

  """

  size: float = ...

  """

  Size of projection shape (leave as 0 for auto)

  """

  use_radius_as_size: bool = ...

  """

  Use radius as size of projection shape (0 = auto)

  """

  use_transform: bool = ...

  """

  Use object transform to control projection shape

  """

  use_x: bool = ...

  use_y: bool = ...

  use_z: bool = ...

  vertex_group: str = ...

  """

  Vertex group name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ClothModifier(bpy_struct, Modifier):

  """

  Cloth simulation modifier

  """

  collision_settings: ClothCollisionSettings = ...

  hair_grid_max: typing.Tuple[float, float, float] = ...

  hair_grid_min: typing.Tuple[float, float, float] = ...

  hair_grid_resolution: typing.Tuple[int, int, int] = ...

  point_cache: PointCache = ...

  settings: ClothSettings = ...

  solver_result: ClothSolverResult = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CollisionModifier(bpy_struct, Modifier):

  """

  Collision modifier defining modifier stack position used for collision

  """

  settings: CollisionSettings = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CorrectiveSmoothModifier(bpy_struct, Modifier):

  """

  Correct distortion caused by deformation

  """

  factor: float = ...

  """

  Smooth factor effect

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  is_bind: bool = ...

  iterations: int = ...

  rest_source: str = ...

  """

  Select the source of rest positions

  * ``ORCO``
Original Coords, Use base mesh vertex coords as the rest position.

  * ``BIND``
Bind Coords, Use bind vertex coords for rest position.

  """

  scale: float = ...

  """

  Compensate for scale applied by other modifiers

  """

  smooth_type: str = ...

  """

  Method used for smoothing

  * ``SIMPLE``
Simple, Use the average of adjacent edge-vertices.

  * ``LENGTH_WEIGHTED``
Length Weight, Use the average of adjacent edge-vertices weighted by their length.

  """

  use_only_smooth: bool = ...

  """

  Apply smoothing without reconstructing the surface

  """

  use_pin_boundary: bool = ...

  """

  Excludes boundary vertices from being smoothed

  """

  vertex_group: str = ...

  """

  Name of Vertex Group which determines influence of modifier per point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurveModifier(bpy_struct, Modifier):

  """

  Curve deformation modifier

  """

  deform_axis: str = ...

  """

  The axis that the curve deforms along

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  object: Object = ...

  """

  Curve object to deform with

  """

  vertex_group: str = ...

  """

  Name of Vertex Group which determines influence of modifier per point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DataTransferModifier(bpy_struct, Modifier):

  """

  Modifier transferring some data from a source mesh

  """

  data_types_edges: typing.Set[str] = ...

  """

  Which edge data layers to transfer

  * ``SHARP_EDGE``
Sharp, Transfer sharp mark.

  * ``SEAM``
UV Seam, Transfer UV seam mark.

  * ``CREASE``
Crease, Transfer subdivision crease values.

  * ``BEVEL_WEIGHT_EDGE``
Bevel Weight, Transfer bevel weights.

  * ``FREESTYLE_EDGE``
Freestyle, Transfer Freestyle edge mark.

  """

  data_types_loops: typing.Set[str] = ...

  """

  Which face corner data layers to transfer

  * ``CUSTOM_NORMAL``
Custom Normals, Transfer custom normals.

  * ``VCOL``
Vertex Colors, Vertex (face corners) colors.

  * ``UV``
UVs, Transfer UV layers.

  """

  data_types_polys: typing.Set[str] = ...

  """

  Which poly data layers to transfer

  * ``SMOOTH``
Smooth, Transfer flat/smooth mark.

  * ``FREESTYLE_FACE``
Freestyle Mark, Transfer Freestyle face mark.

  """

  data_types_verts: typing.Set[str] = ...

  """

  Which vertex data layers to transfer

  * ``VGROUP_WEIGHTS``
Vertex Groups, Transfer active or all vertex groups.

  * ``BEVEL_WEIGHT_VERT``
Bevel Weight, Transfer bevel weights.

  """

  edge_mapping: str = ...

  """

  Method used to map source edges to destination ones

  * ``TOPOLOGY``
Topology, Copy from identical topology meshes.

  * ``VERT_NEAREST``
Nearest Vertices, Copy from most similar edge (edge which vertices are the closest of destination edge's ones).

  * ``NEAREST``
Nearest Edge, Copy from closest edge (using midpoints).

  * ``POLY_NEAREST``
Nearest Face Edge, Copy from closest edge of closest face (using midpoints).

  * ``EDGEINTERP_VNORPROJ``
Projected Edge Interpolated, Interpolate all source edges hit by the projection of destination one along its own normal (from vertices).

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  islands_precision: float = ...

  """

  Factor controlling precision of islands handling (typically, 0.1 should be enough, higher values can make things really slow)

  """

  layers_uv_select_dst: str = ...

  """

  How to match source and destination layers

  * ``ACTIVE``
Active Layer, Affect active data layer of all targets.

  * ``NAME``
By Name, Match target data layers to affect by name.

  * ``INDEX``
By Order, Match target data layers to affect by order (indices).

  """

  layers_uv_select_src: str = ...

  """

  Which layers to transfer, in case of multi-layers types

  * ``ACTIVE``
Active Layer, Only transfer active data layer.

  * ``ALL``
All Layers, Transfer all data layers.

  * ``BONE_SELECT``
Selected Pose Bones, Transfer all vertex groups used by selected pose bones.

  * ``BONE_DEFORM``
Deform Pose Bones, Transfer all vertex groups used by deform bones.

  """

  layers_vcol_select_dst: str = ...

  """

  How to match source and destination layers

  * ``ACTIVE``
Active Layer, Affect active data layer of all targets.

  * ``NAME``
By Name, Match target data layers to affect by name.

  * ``INDEX``
By Order, Match target data layers to affect by order (indices).

  """

  layers_vcol_select_src: str = ...

  """

  Which layers to transfer, in case of multi-layers types

  * ``ACTIVE``
Active Layer, Only transfer active data layer.

  * ``ALL``
All Layers, Transfer all data layers.

  * ``BONE_SELECT``
Selected Pose Bones, Transfer all vertex groups used by selected pose bones.

  * ``BONE_DEFORM``
Deform Pose Bones, Transfer all vertex groups used by deform bones.

  """

  layers_vgroup_select_dst: str = ...

  """

  How to match source and destination layers

  * ``ACTIVE``
Active Layer, Affect active data layer of all targets.

  * ``NAME``
By Name, Match target data layers to affect by name.

  * ``INDEX``
By Order, Match target data layers to affect by order (indices).

  """

  layers_vgroup_select_src: str = ...

  """

  Which layers to transfer, in case of multi-layers types

  * ``ACTIVE``
Active Layer, Only transfer active data layer.

  * ``ALL``
All Layers, Transfer all data layers.

  * ``BONE_SELECT``
Selected Pose Bones, Transfer all vertex groups used by selected pose bones.

  * ``BONE_DEFORM``
Deform Pose Bones, Transfer all vertex groups used by deform bones.

  """

  loop_mapping: str = ...

  """

  Method used to map source faces' corners to destination ones

  * ``TOPOLOGY``
Topology, Copy from identical topology meshes.

  * ``NEAREST_NORMAL``
Nearest Corner And Best Matching Normal, Copy from nearest corner which has the best matching normal.

  * ``NEAREST_POLYNOR``
Nearest Corner And Best Matching Face Normal, Copy from nearest corner which has the face with the best matching normal to destination corner's face one.

  * ``NEAREST_POLY``
Nearest Corner Of Nearest Face, Copy from nearest corner of nearest polygon.

  * ``POLYINTERP_NEAREST``
Nearest Face Interpolated, Copy from interpolated corners of the nearest source polygon.

  * ``POLYINTERP_LNORPROJ``
Projected Face Interpolated, Copy from interpolated corners of the source polygon hit by corner normal projection.

  """

  max_distance: float = ...

  """

  Maximum allowed distance between source and destination element, for non-topology mappings

  """

  mix_factor: float = ...

  """

  Factor to use when applying data to destination (exact behavior depends on mix mode, multiplied with weights from vertex group when defined)

  """

  mix_mode: str = ...

  """

  How to affect destination elements with source values

  * ``REPLACE``
Replace, Overwrite all elements' data.

  * ``ABOVE_THRESHOLD``
Above Threshold, Only replace destination elements where data is above given threshold (exact behavior depends on data type).

  * ``BELOW_THRESHOLD``
Below Threshold, Only replace destination elements where data is below given threshold (exact behavior depends on data type).

  * ``MIX``
Mix, Mix source value into destination one, using given threshold as factor.

  * ``ADD``
Add, Add source value to destination one, using given threshold as factor.

  * ``SUB``
Subtract, Subtract source value to destination one, using given threshold as factor.

  * ``MUL``
Multiply, Multiply source value to destination one, using given threshold as factor.

  """

  object: Object = ...

  """

  Object to transfer data from

  """

  poly_mapping: str = ...

  """

  Method used to map source faces to destination ones

  * ``TOPOLOGY``
Topology, Copy from identical topology meshes.

  * ``NEAREST``
Nearest Face, Copy from nearest polygon (using center points).

  * ``NORMAL``
Best Normal-Matching, Copy from source polygon which normal is the closest to destination one.

  * ``POLYINTERP_PNORPROJ``
Projected Face Interpolated, Interpolate all source polygons intersected by the projection of destination one along its own normal.

  """

  ray_radius: float = ...

  """

  'Width' of rays (especially useful when raycasting against vertices or edges)

  """

  use_edge_data: bool = ...

  """

  Enable edge data transfer

  """

  use_loop_data: bool = ...

  """

  Enable face corner data transfer

  """

  use_max_distance: bool = ...

  """

  Source elements must be closer than given distance from destination one

  """

  use_object_transform: bool = ...

  """

  Evaluate source and destination meshes in global space

  """

  use_poly_data: bool = ...

  """

  Enable face data transfer

  """

  use_vert_data: bool = ...

  """

  Enable vertex data transfer

  """

  vert_mapping: str = ...

  """

  Method used to map source vertices to destination ones

  * ``TOPOLOGY``
Topology, Copy from identical topology meshes.

  * ``NEAREST``
Nearest Vertex, Copy from closest vertex.

  * ``EDGE_NEAREST``
Nearest Edge Vertex, Copy from closest vertex of closest edge.

  * ``EDGEINTERP_NEAREST``
Nearest Edge Interpolated, Copy from interpolated values of vertices from closest point on closest edge.

  * ``POLY_NEAREST``
Nearest Face Vertex, Copy from closest vertex of closest face.

  * ``POLYINTERP_NEAREST``
Nearest Face Interpolated, Copy from interpolated values of vertices from closest point on closest face.

  * ``POLYINTERP_VNORPROJ``
Projected Face Interpolated, Copy from interpolated values of vertices from point on closest face hit by normal-projection.

  """

  vertex_group: str = ...

  """

  Vertex group name for selecting the affected areas

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DecimateModifier(bpy_struct, Modifier):

  """

  Decimation modifier

  """

  angle_limit: float = ...

  """

  Only dissolve angles below this (planar only)

  """

  decimate_type: str = ...

  """

  * ``COLLAPSE``
Collapse, Use edge collapsing.

  * ``UNSUBDIV``
Un-Subdivide, Use un-subdivide face reduction.

  * ``DISSOLVE``
Planar, Dissolve geometry to form planar polygons.

  """

  delimit: typing.Set[str] = ...

  """

  Limit merging geometry

  * ``NORMAL``
Normal, Delimit by face directions.

  * ``MATERIAL``
Material, Delimit by face material.

  * ``SEAM``
Seam, Delimit by edge seams.

  * ``SHARP``
Sharp, Delimit by sharp edges.

  * ``UV``
UVs, Delimit by UV coordinates.

  """

  face_count: int = ...

  """

  The current number of faces in the decimated mesh

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence (collapse only)

  """

  iterations: int = ...

  """

  Number of times reduce the geometry (unsubdivide only)

  """

  ratio: float = ...

  """

  Ratio of triangles to reduce to (collapse only)

  """

  symmetry_axis: str = ...

  """

  Axis of symmetry

  """

  use_collapse_triangulate: bool = ...

  """

  Keep triangulated faces resulting from decimation (collapse only)

  """

  use_dissolve_boundaries: bool = ...

  """

  Dissolve all vertices in between face boundaries (planar only)

  """

  use_symmetry: bool = ...

  """

  Maintain symmetry on an axis

  """

  vertex_group: str = ...

  """

  Vertex group name (collapse only)

  """

  vertex_group_factor: float = ...

  """

  Vertex group strength

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DisplaceModifier(bpy_struct, Modifier):

  """

  Displacement modifier

  """

  direction: str = ...

  """

  * ``X``
X, Use the texture's intensity value to displace in the X direction.

  * ``Y``
Y, Use the texture's intensity value to displace in the Y direction.

  * ``Z``
Z, Use the texture's intensity value to displace in the Z direction.

  * ``NORMAL``
Normal, Use the texture's intensity value to displace along the vertex normal.

  * ``CUSTOM_NORMAL``
Custom Normal, Use the texture's intensity value to displace along the (averaged) custom normal (falls back to vertex).

  * ``RGB_TO_XYZ``
RGB to XYZ, Use the texture's RGB values to displace the mesh in the XYZ direction.

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  mid_level: float = ...

  """

  Material value that gives no displacement

  """

  space: str = ...

  """

  * ``LOCAL``
Local, Direction is defined in local coordinates.

  * ``GLOBAL``
Global, Direction is defined in global coordinates.

  """

  strength: float = ...

  """

  Amount to displace geometry

  """

  texture: Texture = ...

  texture_coords: str = ...

  """

  * ``LOCAL``
Local, Use the local coordinate system for the texture coordinates.

  * ``GLOBAL``
Global, Use the global coordinate system for the texture coordinates.

  * ``OBJECT``
Object, Use the linked object's local coordinate system for the texture coordinates.

  * ``UV``
UV, Use UV coordinates for the texture coordinates.

  """

  texture_coords_bone: str = ...

  """

  Bone to set the texture coordinates

  """

  texture_coords_object: Object = ...

  """

  Object to set the texture coordinates

  """

  uv_layer: str = ...

  """

  UV map name

  """

  vertex_group: str = ...

  """

  Name of Vertex Group which determines influence of modifier per point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DynamicPaintModifier(bpy_struct, Modifier):

  """

  Dynamic Paint modifier

  """

  brush_settings: DynamicPaintBrushSettings = ...

  canvas_settings: DynamicPaintCanvasSettings = ...

  ui_type: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class EdgeSplitModifier(bpy_struct, Modifier):

  """

  Edge splitting modifier to create sharp edges

  """

  split_angle: float = ...

  """

  Angle above which to split edges

  """

  use_edge_angle: bool = ...

  """

  Split edges with high angle between faces

  """

  use_edge_sharp: bool = ...

  """

  Split edges that are marked as sharp

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ExplodeModifier(bpy_struct, Modifier):

  """

  Explosion effect modifier based on a particle system

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  particle_uv: str = ...

  """

  UV map to change with particle age

  """

  protect: float = ...

  """

  Clean vertex group edges

  """

  show_alive: bool = ...

  """

  Show mesh when particles are alive

  """

  show_dead: bool = ...

  """

  Show mesh when particles are dead

  """

  show_unborn: bool = ...

  """

  Show mesh when particles are unborn

  """

  use_edge_cut: bool = ...

  """

  Cut face edges for nicer shrapnel

  """

  use_size: bool = ...

  """

  Use particle size for the shrapnel

  """

  vertex_group: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FluidModifier(bpy_struct, Modifier):

  """

  Fluid simulation modifier

  """

  domain_settings: FluidDomainSettings = ...

  effector_settings: FluidEffectorSettings = ...

  flow_settings: FluidFlowSettings = ...

  fluid_type: str = ...

  """

  * ``NONE``
None.

  * ``DOMAIN``
Domain.

  * ``FLOW``
Flow, Inflow/Outflow.

  * ``EFFECTOR``
Effector.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class HookModifier(bpy_struct, Modifier):

  """

  Hook modifier to modify the location of vertices

  """

  center: typing.Tuple[float, float, float] = ...

  """

  Center of the hook, used for falloff and display

  """

  falloff_curve: CurveMapping = ...

  """

  Custom falloff curve

  """

  falloff_radius: float = ...

  """

  If not zero, the distance from the hook where influence ends

  """

  falloff_type: str = ...

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  matrix_inverse: typing.Tuple[typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float], typing.Tuple[float, float, float, float]] = ...

  """

  Reverse the transformation between this object and its target

  """

  object: Object = ...

  """

  Parent Object for hook, also recalculates and clears offset

  """

  strength: float = ...

  """

  Relative force of the hook

  """

  subtarget: str = ...

  """

  Name of Parent Bone for hook (if applicable), also recalculates and clears offset

  """

  use_falloff_uniform: bool = ...

  """

  Compensate for non-uniform object scale

  """

  vertex_group: str = ...

  """

  Name of Vertex Group which determines influence of modifier per point

  """

  vertex_indices: typing.Tuple[int, ...] = ...

  """

  Indices of vertices bound to the modifier. For bezier curves, handles count as additional vertices

  """

  def vertex_indices_set(self, indices: typing.Tuple[int, ...]) -> None:

    """

    Validates and assigns the array of vertex indices bound to the modifier

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LaplacianDeformModifier(bpy_struct, Modifier):

  """

  Mesh deform modifier

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  is_bind: bool = ...

  """

  Whether geometry has been bound to anchors

  """

  iterations: int = ...

  vertex_group: str = ...

  """

  Name of Vertex Group which determines Anchors

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LaplacianSmoothModifier(bpy_struct, Modifier):

  """

  Smoothing effect modifier

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  iterations: int = ...

  lambda_border: float = ...

  """

  Lambda factor in border

  """

  lambda_factor: float = ...

  """

  Smooth factor effect

  """

  use_normalized: bool = ...

  """

  Improve and stabilize the enhanced shape

  """

  use_volume_preserve: bool = ...

  """

  Apply volume preservation after smooth

  """

  use_x: bool = ...

  """

  Smooth object along X axis

  """

  use_y: bool = ...

  """

  Smooth object along Y axis

  """

  use_z: bool = ...

  """

  Smooth object along Z axis

  """

  vertex_group: str = ...

  """

  Name of Vertex Group which determines influence of modifier per point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LatticeModifier(bpy_struct, Modifier):

  """

  Lattice deformation modifier

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  object: Object = ...

  """

  Lattice object to deform with

  """

  strength: float = ...

  """

  Strength of modifier effect

  """

  vertex_group: str = ...

  """

  Name of Vertex Group which determines influence of modifier per point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaskModifier(bpy_struct, Modifier):

  """

  Mask modifier to hide parts of the mesh

  """

  armature: Object = ...

  """

  Armature to use as source of bones to mask

  """

  invert_vertex_group: bool = ...

  """

  Use vertices that are not part of region defined

  """

  mode: str = ...

  threshold: float = ...

  """

  Weights over this threshold remain

  """

  vertex_group: str = ...

  """

  Vertex group name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshCacheModifier(bpy_struct, Modifier):

  """

  Cache Mesh

  """

  cache_format: str = ...

  deform_mode: str = ...

  """

  * ``OVERWRITE``
Overwrite, Replace vertex coords with cached values.

  * ``INTEGRATE``
Integrate, Integrate deformation from this modifiers input with the mesh-cache coords (useful for shape keys).

  """

  eval_factor: float = ...

  """

  Evaluation time in seconds

  """

  eval_frame: float = ...

  """

  The frame to evaluate (starting at 0)

  """

  eval_time: float = ...

  """

  Evaluation time in seconds

  """

  factor: float = ...

  """

  Influence of the deformation

  """

  filepath: str = ...

  """

  Path to external displacements file

  """

  flip_axis: typing.Set[str] = ...

  forward_axis: str = ...

  frame_scale: float = ...

  """

  Evaluation time in seconds

  """

  frame_start: float = ...

  """

  Add this to the start frame

  """

  interpolation: str = ...

  play_mode: str = ...

  """

  * ``SCENE``
Scene, Use the time from the scene.

  * ``CUSTOM``
Custom, Use the modifier's own time evaluation.

  """

  time_mode: str = ...

  """

  Method to control playback time

  * ``FRAME``
Frame, Control playback using a frame-number (ignoring time FPS and start frame from the file).

  * ``TIME``
Time, Control playback using time in seconds.

  * ``FACTOR``
Factor, Control playback using a value between [0, 1].

  """

  up_axis: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshDeformModifier(bpy_struct, Modifier):

  """

  Mesh deformation modifier to deform with other meshes

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  is_bound: bool = ...

  """

  Whether geometry has been bound to control cage

  """

  object: Object = ...

  """

  Mesh object to deform with

  """

  precision: int = ...

  """

  The grid size for binding

  """

  use_dynamic_bind: bool = ...

  """

  Recompute binding dynamically on top of other deformers (slower and more memory consuming)

  """

  vertex_group: str = ...

  """

  Vertex group name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshSequenceCacheModifier(bpy_struct, Modifier):

  """

  Cache Mesh

  """

  cache_file: CacheFile = ...

  has_velocity: bool = ...

  object_path: str = ...

  """

  Path to the object in the Alembic archive used to lookup geometric data

  """

  read_data: typing.Set[str] = ...

  """

  Data to read from the cache

  """

  read_velocity: bool = ...

  use_vertex_interpolation: bool = ...

  """

  Allow interpolation of vertex positions

  """

  velocity_scale: float = ...

  """

  Multiplier used to control the magnitude of the velocity vectors for time effects

  """

  vertex_velocities: typing.Union[typing.Sequence[MeshCacheVertexVelocity], typing.Mapping[str, MeshCacheVertexVelocity], bpy_prop_collection] = ...

  """

  Vertices of the fluid mesh generated by simulation

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MeshToVolumeModifier(bpy_struct, Modifier):

  density: float = ...

  """

  Density of the new volume

  """

  exterior_band_width: float = ...

  """

  Width of the volume outside of the mesh

  """

  interior_band_width: float = ...

  """

  Width of the volume inside of the mesh

  """

  object: Object = ...

  """

  Object

  """

  resolution_mode: str = ...

  """

  Mode for how the desired voxel size is specified

  * ``VOXEL_AMOUNT``
Voxel Amount, Desired number of voxels along one axis.

  * ``VOXEL_SIZE``
Voxel Size, Desired voxel side length.

  """

  use_fill_volume: bool = ...

  """

  Initialize the density grid in every cell inside the enclosed volume

  """

  voxel_amount: int = ...

  """

  Approximate number of voxels along one axis

  """

  voxel_size: float = ...

  """

  Smaller values result in a higher resolution output

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MirrorModifier(bpy_struct, Modifier):

  """

  Mirroring modifier

  """

  merge_threshold: float = ...

  """

  Distance within which mirrored vertices are merged

  """

  mirror_object: Object = ...

  """

  Object to use as mirror

  """

  mirror_offset_u: float = ...

  """

  Amount to offset mirrored UVs flipping point from the 0.5 on the U axis

  """

  mirror_offset_v: float = ...

  """

  Amount to offset mirrored UVs flipping point from the 0.5 point on the V axis

  """

  offset_u: float = ...

  """

  Mirrored UV offset on the U axis

  """

  offset_v: float = ...

  """

  Mirrored UV offset on the V axis

  """

  use_axis: typing.Tuple[bool, bool, bool] = ...

  """

  Enable axis mirror

  """

  use_bisect_axis: typing.Tuple[bool, bool, bool] = ...

  """

  Cuts the mesh across the mirror plane

  """

  use_bisect_flip_axis: typing.Tuple[bool, bool, bool] = ...

  """

  Flips the direction of the slice

  """

  use_clip: bool = ...

  """

  Prevent vertices from going through the mirror during transform

  """

  use_mirror_merge: bool = ...

  """

  Merge vertices within the merge threshold

  """

  use_mirror_u: bool = ...

  """

  Mirror the U texture coordinate around the flip offset point

  """

  use_mirror_udim: bool = ...

  """

  Mirror the texture coordinate around each tile center

  """

  use_mirror_v: bool = ...

  """

  Mirror the V texture coordinate around the flip offset point

  """

  use_mirror_vertex_groups: bool = ...

  """

  Mirror vertex groups (e.g. .R->.L)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MultiresModifier(bpy_struct, Modifier):

  """

  Multiresolution mesh modifier

  """

  boundary_smooth: str = ...

  """

  Controls how open boundaries are smoothed

  * ``PRESERVE_CORNERS``
Keep Corners, Smooth boundaries, but corners are kept sharp.

  * ``ALL``
All, Smooth boundaries, including corners.

  """

  filepath: str = ...

  """

  Path to external displacements file

  """

  is_external: bool = ...

  """

  Store multires displacements outside the .blend file, to save memory

  """

  levels: int = ...

  """

  Number of subdivisions to use in the viewport

  """

  quality: int = ...

  """

  Accuracy of vertex positions, lower value is faster but less precise

  """

  render_levels: int = ...

  """

  The subdivision level visible at render time

  """

  sculpt_levels: int = ...

  """

  Number of subdivisions to use in sculpt mode

  """

  show_only_control_edges: bool = ...

  """

  Skip drawing/rendering of interior subdivided edges

  """

  subdivision_type: str = ...

  """

  Select type of subdivision algorithm

  """

  total_levels: int = ...

  """

  Number of subdivisions for which displacements are stored

  """

  use_creases: bool = ...

  """

  Use mesh edge crease information to sharpen edges

  """

  use_custom_normals: bool = ...

  """

  Interpolates existing custom normals to resulting mesh

  """

  use_sculpt_base_mesh: bool = ...

  """

  Make Sculpt Mode tools deform the base mesh while previewing the displacement of higher subdivision levels

  """

  uv_smooth: str = ...

  """

  Controls how smoothing is applied to UVs

  * ``NONE``
None, UVs are not smoothed, boundaries are kept sharp.

  * ``PRESERVE_CORNERS``
Keep Corners, UVs are smoothed, corners on discontinuous boundary are kept sharp.

  * ``PRESERVE_BOUNDARIES``
All, UVs and boundaries are smoothed.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NormalEditModifier(bpy_struct, Modifier):

  """

  Modifier affecting/generating custom normals

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  mix_factor: float = ...

  """

  How much of generated normals to mix with exiting ones

  """

  mix_limit: float = ...

  """

  Maximum angle between old and new normals

  """

  mix_mode: str = ...

  """

  How to mix generated normals with existing ones

  * ``COPY``
Copy, Copy new normals (overwrite existing).

  * ``ADD``
Add, Copy sum of new and old normals.

  * ``SUB``
Subtract, Copy new normals minus old normals.

  * ``MUL``
Multiply, Copy product of old and new normals (*not* cross product).

  """

  mode: str = ...

  """

  How to affect (generate) normals

  * ``RADIAL``
Radial, From an ellipsoid (shape defined by the boundbox's dimensions, target is optional).

  * ``DIRECTIONAL``
Directional, Normals 'track' (point to) the target object.

  """

  no_polynors_fix: bool = ...

  """

  Do not flip polygons when their normals are not consistent with their newly computed custom vertex normals

  """

  offset: typing.Tuple[float, float, float] = ...

  """

  Offset from object's center

  """

  target: Object = ...

  """

  Target object used to affect normals

  """

  use_direction_parallel: bool = ...

  """

  Use same direction for all normals, from origin to target's center (Directional mode only)

  """

  vertex_group: str = ...

  """

  Vertex group name for selecting/weighting the affected areas

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class OceanModifier(bpy_struct, Modifier):

  """

  Simulate an ocean surface

  """

  bake_foam_fade: float = ...

  """

  How much foam accumulates over time (baked ocean only)

  """

  choppiness: float = ...

  """

  Choppiness of the wave's crest (adds some horizontal component to the displacement)

  """

  damping: float = ...

  """

  Damp reflected waves going in opposite direction to the wind

  """

  depth: float = ...

  """

  Depth of the solid ground below the water surface

  """

  fetch_jonswap: float = ...

  """

  This is the distance from a lee shore, called the fetch, or the distance over which the wind blows with constant velocity. Used by 'JONSWAP' and 'TMA' models

  """

  filepath: str = ...

  """

  Path to a folder to store external baked images

  """

  foam_coverage: float = ...

  """

  Amount of generated foam

  """

  foam_layer_name: str = ...

  """

  Name of the vertex color layer used for foam

  """

  frame_end: int = ...

  """

  End frame of the ocean baking

  """

  frame_start: int = ...

  """

  Start frame of the ocean baking

  """

  geometry_mode: str = ...

  """

  Method of modifying geometry

  * ``GENERATE``
Generate, Generate ocean surface geometry at the specified resolution.

  * ``DISPLACE``
Displace, Displace existing geometry according to simulation.

  """

  invert_spray: bool = ...

  """

  Invert the spray direction map

  """

  is_cached: bool = ...

  """

  Whether the ocean is using cached data or simulating

  """

  random_seed: int = ...

  """

  Seed of the random generator

  """

  repeat_x: int = ...

  """

  Repetitions of the generated surface in X

  """

  repeat_y: int = ...

  """

  Repetitions of the generated surface in Y

  """

  resolution: int = ...

  """

  Resolution of the generated surface for rendering and baking

  """

  sharpen_peak_jonswap: float = ...

  """

  Peak sharpening for 'JONSWAP' and 'TMA' models

  """

  size: float = ...

  """

  Surface scale factor (does not affect the height of the waves)

  """

  spatial_size: int = ...

  """

  Size of the simulation domain (in meters), and of the generated geometry (in BU)

  """

  spectrum: str = ...

  """

  Spectrum to use

  * ``PHILLIPS``
Turbulent Ocean, Use for turbulent seas with foam.

  * ``PIERSON_MOSKOWITZ``
Established Ocean, Use for a large area, established ocean (Pierson-Moskowitz method).

  * ``JONSWAP``
Established Ocean (Sharp Peaks), Use for sharp peaks ('JONSWAP', Pierson-Moskowitz method) with peak sharpening.

  * ``TEXEL_MARSEN_ARSLOE``
Shallow Water, Use for shallow water ('JONSWAP', 'TMA' - Texel-Marsen-Arsloe method).

  """

  spray_layer_name: str = ...

  """

  Name of the vertex color layer used for the spray direction map

  """

  time: float = ...

  """

  Current time of the simulation

  """

  use_foam: bool = ...

  """

  Generate foam mask as a vertex color channel

  """

  use_normals: bool = ...

  """

  Output normals for bump mapping - disabling can speed up performance if its not needed

  """

  use_spray: bool = ...

  """

  Generate map of spray direction as a vertex color channel

  """

  viewport_resolution: int = ...

  """

  Viewport resolution of the generated surface

  """

  wave_alignment: float = ...

  """

  How much the waves are aligned to each other

  """

  wave_direction: float = ...

  """

  Main direction of the waves when they are (partially) aligned

  """

  wave_scale: float = ...

  """

  Scale of the displacement effect

  """

  wave_scale_min: float = ...

  """

  Shortest allowed wavelength

  """

  wind_velocity: float = ...

  """

  Wind speed

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleInstanceModifier(bpy_struct, Modifier):

  """

  Particle system instancing modifier

  """

  axis: str = ...

  """

  Pole axis for rotation

  """

  index_layer_name: str = ...

  """

  Custom data layer name for the index

  """

  object: Object = ...

  """

  Object that has the particle system

  """

  particle_amount: float = ...

  """

  Amount of particles to use for instancing

  """

  particle_offset: float = ...

  """

  Relative offset of particles to use for instancing, to avoid overlap of multiple instances

  """

  particle_system: ParticleSystem = ...

  particle_system_index: int = ...

  position: float = ...

  """

  Position along path

  """

  random_position: float = ...

  """

  Randomize position along path

  """

  random_rotation: float = ...

  """

  Randomize rotation around path

  """

  rotation: float = ...

  """

  Rotation around path

  """

  show_alive: bool = ...

  """

  Show instances when particles are alive

  """

  show_dead: bool = ...

  """

  Show instances when particles are dead

  """

  show_unborn: bool = ...

  """

  Show instances when particles are unborn

  """

  space: str = ...

  """

  Space to use for copying mesh data

  * ``LOCAL``
Local, Use offset from the particle object in the instance object.

  * ``WORLD``
World, Use world space offset in the instance object.

  """

  use_children: bool = ...

  """

  Create instances from child particles

  """

  use_normal: bool = ...

  """

  Create instances from normal particles

  """

  use_path: bool = ...

  """

  Create instances along particle paths

  """

  use_preserve_shape: bool = ...

  """

  Don't stretch the object

  """

  use_size: bool = ...

  """

  Use particle size to scale the instances

  """

  value_layer_name: str = ...

  """

  Custom data layer name for the randomized value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleSystemModifier(bpy_struct, Modifier):

  """

  Particle system simulation modifier

  """

  particle_system: ParticleSystem = ...

  """

  Particle System that this modifier controls

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RemeshModifier(bpy_struct, Modifier):

  """

  Generate a new surface with regular topology that follows the shape of the input mesh

  """

  adaptivity: float = ...

  """

  Reduces the final face count by simplifying geometry where detail is not needed, generating triangles. A value greater than 0 disables Fix Poles

  """

  mode: str = ...

  """

  * ``BLOCKS``
Blocks, Output a blocky surface with no smoothing.

  * ``SMOOTH``
Smooth, Output a smooth surface with no sharp-features detection.

  * ``SHARP``
Sharp, Output a surface that reproduces sharp edges and corners from the input mesh.

  * ``VOXEL``
Voxel, Output a mesh corresponding to the volume of the original mesh.

  """

  octree_depth: int = ...

  """

  Resolution of the octree; higher values give finer details

  """

  scale: float = ...

  """

  The ratio of the largest dimension of the model over the size of the grid

  """

  sharpness: float = ...

  """

  Tolerance for outliers; lower values filter noise while higher values will reproduce edges closer to the input

  """

  threshold: float = ...

  """

  If removing disconnected pieces, minimum size of components to preserve as a ratio of the number of polygons in the largest component

  """

  use_remove_disconnected: bool = ...

  use_smooth_shade: bool = ...

  """

  Output faces with smooth shading rather than flat shaded

  """

  voxel_size: float = ...

  """

  Size of the voxel in object space used for volume evaluation. Lower values preserve finer details

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ScrewModifier(bpy_struct, Modifier):

  """

  Revolve edges

  """

  angle: float = ...

  """

  Angle of revolution

  """

  axis: str = ...

  """

  Screw axis

  """

  iterations: int = ...

  """

  Number of times to apply the screw operation

  """

  merge_threshold: float = ...

  """

  Limit below which to merge vertices

  """

  object: Object = ...

  """

  Object to define the screw axis

  """

  render_steps: int = ...

  """

  Number of steps in the revolution

  """

  screw_offset: float = ...

  """

  Offset the revolution along its axis

  """

  steps: int = ...

  """

  Number of steps in the revolution

  """

  use_merge_vertices: bool = ...

  """

  Merge adjacent vertices (screw offset must be zero)

  """

  use_normal_calculate: bool = ...

  """

  Calculate the order of edges (needed for meshes, but not curves)

  """

  use_normal_flip: bool = ...

  """

  Flip normals of lathed faces

  """

  use_object_screw_offset: bool = ...

  """

  Use the distance between the objects to make a screw

  """

  use_smooth_shade: bool = ...

  """

  Output faces with smooth shading rather than flat shaded

  """

  use_stretch_u: bool = ...

  """

  Stretch the U coordinates between 0-1 when UV's are present

  """

  use_stretch_v: bool = ...

  """

  Stretch the V coordinates between 0-1 when UV's are present

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShrinkwrapModifier(bpy_struct, Modifier):

  """

  Shrink wrapping modifier to shrink wrap and object to a target

  """

  auxiliary_target: Object = ...

  """

  Additional mesh target to shrink to

  """

  cull_face: str = ...

  """

  Stop vertices from projecting to a face on the target when facing towards/away

  * ``OFF``
Off, No culling.

  * ``FRONT``
Front, No projection when in front of the face.

  * ``BACK``
Back, No projection when behind the face.

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  offset: float = ...

  """

  Distance to keep from the target

  """

  project_limit: float = ...

  """

  Limit the distance used for projection (zero disables)

  """

  subsurf_levels: int = ...

  """

  Number of subdivisions that must be performed before extracting vertices' positions and normals

  """

  target: Object = ...

  """

  Mesh target to shrink to

  """

  use_invert_cull: bool = ...

  """

  When projecting in the negative direction invert the face cull mode

  """

  use_negative_direction: bool = ...

  """

  Allow vertices to move in the negative direction of axis

  """

  use_positive_direction: bool = ...

  """

  Allow vertices to move in the positive direction of axis

  """

  use_project_x: bool = ...

  use_project_y: bool = ...

  use_project_z: bool = ...

  vertex_group: str = ...

  """

  Vertex group name

  """

  wrap_method: str = ...

  """

  * ``NEAREST_SURFACEPOINT``
Nearest Surface Point, Shrink the mesh to the nearest target surface.

  * ``PROJECT``
Project, Shrink the mesh to the nearest target surface along a given axis.

  * ``NEAREST_VERTEX``
Nearest Vertex, Shrink the mesh to the nearest target vertex.

  * ``TARGET_PROJECT``
Target Normal Project, Shrink the mesh to the nearest target surface along the interpolated vertex normals of the target.

  """

  wrap_mode: str = ...

  """

  Select how vertices are constrained to the target surface

  * ``ON_SURFACE``
On Surface, The point is constrained to the surface of the target object, with distance offset towards the original point location.

  * ``INSIDE``
Inside, The point is constrained to be inside the target object.

  * ``OUTSIDE``
Outside, The point is constrained to be outside the target object.

  * ``OUTSIDE_SURFACE``
Outside Surface, The point is constrained to the surface of the target object, with distance offset always to the outside, towards or away from the original location.

  * ``ABOVE_SURFACE``
Above Surface, The point is constrained to the surface of the target object, with distance offset applied exactly along the target normal.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SimpleDeformModifier(bpy_struct, Modifier):

  """

  Simple deformation modifier to apply effects such as twisting and bending

  """

  angle: float = ...

  """

  Angle of deformation

  """

  deform_axis: str = ...

  """

  Deform around local axis

  """

  deform_method: str = ...

  """

  * ``TWIST``
Twist, Rotate around the Z axis of the modifier space.

  * ``BEND``
Bend, Bend the mesh over the Z axis of the modifier space.

  * ``TAPER``
Taper, Linearly scale along Z axis of the modifier space.

  * ``STRETCH``
Stretch, Stretch the object along the Z axis of the modifier space.

  """

  factor: float = ...

  """

  Amount to deform object

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  limits: typing.Tuple[float, float] = ...

  """

  Lower/Upper limits for deform

  """

  lock_x: bool = ...

  """

  Do not allow deformation along the X axis

  """

  lock_y: bool = ...

  """

  Do not allow deformation along the Y axis

  """

  lock_z: bool = ...

  """

  Do not allow deformation along the Z axis

  """

  origin: Object = ...

  """

  Offset the origin and orientation of the deformation

  """

  vertex_group: str = ...

  """

  Vertex group name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SkinModifier(bpy_struct, Modifier):

  """

  Generate Skin

  """

  branch_smoothing: float = ...

  """

  Smooth complex geometry around branches

  """

  use_smooth_shade: bool = ...

  """

  Output faces with smooth shading rather than flat shaded

  """

  use_x_symmetry: bool = ...

  """

  Avoid making unsymmetrical quads across the X axis

  """

  use_y_symmetry: bool = ...

  """

  Avoid making unsymmetrical quads across the Y axis

  """

  use_z_symmetry: bool = ...

  """

  Avoid making unsymmetrical quads across the Z axis

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SmoothModifier(bpy_struct, Modifier):

  """

  Smoothing effect modifier

  """

  factor: float = ...

  """

  Strength of modifier effect

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  iterations: int = ...

  use_x: bool = ...

  """

  Smooth object along X axis

  """

  use_y: bool = ...

  """

  Smooth object along Y axis

  """

  use_z: bool = ...

  """

  Smooth object along Z axis

  """

  vertex_group: str = ...

  """

  Name of Vertex Group which determines influence of modifier per point

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SoftBodyModifier(bpy_struct, Modifier):

  """

  Soft body simulation modifier

  """

  point_cache: PointCache = ...

  settings: SoftBodySettings = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SolidifyModifier(bpy_struct, Modifier):

  """

  Create a solid skin, compensating for sharp angles

  """

  bevel_convex: float = ...

  """

  Edge bevel weight to be added to outside edges

  """

  edge_crease_inner: float = ...

  """

  Assign a crease to inner edges

  """

  edge_crease_outer: float = ...

  """

  Assign a crease to outer edges

  """

  edge_crease_rim: float = ...

  """

  Assign a crease to the edges making up the rim

  """

  invert_vertex_group: bool = ...

  """

  Invert the vertex group influence

  """

  material_offset: int = ...

  """

  Offset material index of generated faces

  """

  material_offset_rim: int = ...

  """

  Offset material index of generated rim faces

  """

  nonmanifold_boundary_mode: str = ...

  """

  Selects the boundary adjustment algorithm

  * ``NONE``
None, No shape correction.

  * ``ROUND``
Round, Round open perimeter shape.

  * ``FLAT``
Flat, Flat open perimeter shape.

  """

  nonmanifold_merge_threshold: float = ...

  """

  Distance within which degenerated geometry is merged

  """

  nonmanifold_thickness_mode: str = ...

  """

  Selects the used thickness algorithm

  * ``FIXED``
Fixed, Most basic thickness calculation.

  * ``EVEN``
Even, Even thickness calculation which takes the angle between faces into account.

  * ``CONSTRAINTS``
Constraints, Thickness calculation using constraints, most advanced.

  """

  offset: float = ...

  """

  Offset the thickness from the center

  """

  rim_vertex_group: str = ...

  """

  Vertex group that the generated rim geometry will be weighted to

  """

  shell_vertex_group: str = ...

  """

  Vertex group that the generated shell geometry will be weighted to

  """

  solidify_mode: str = ...

  """

  Selects the used algorithm

  * ``EXTRUDE``
Simple, Output a solidified version of a mesh by simple extrusion.

  * ``NON_MANIFOLD``
Complex, Output a manifold mesh even if the base mesh is non-manifold, where edges have 3 or more connecting faces.This method is slower.

  """

  thickness: float = ...

  """

  Thickness of the shell

  """

  thickness_clamp: float = ...

  """

  Offset clamp based on geometry scale

  """

  thickness_vertex_group: float = ...

  """

  Thickness factor to use for zero vertex group influence

  """

  use_even_offset: bool = ...

  """

  Maintain thickness by adjusting for sharp corners (slow, disable when not needed)

  """

  use_flat_faces: bool = ...

  """

  Make faces use the minimal vertex weight assigned to their vertices(ensures new faces remain parallel to their original ones, slow, disable when not needed)

  """

  use_flip_normals: bool = ...

  """

  Invert the face direction

  """

  use_quality_normals: bool = ...

  """

  Calculate normals which result in more even thickness (slow, disable when not needed)

  """

  use_rim: bool = ...

  """

  Create edge loops between the inner and outer surfaces on face edges (slow, disable when not needed)

  """

  use_rim_only: bool = ...

  """

  Only add the rim to the original data

  """

  use_thickness_angle_clamp: bool = ...

  """

  Clamp thickness based on angles

  """

  vertex_group: str = ...

  """

  Vertex group name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SubsurfModifier(bpy_struct, Modifier):

  """

  Subdivision surface modifier

  """

  boundary_smooth: str = ...

  """

  Controls how open boundaries are smoothed

  * ``PRESERVE_CORNERS``
Keep Corners, Smooth boundaries, but corners are kept sharp.

  * ``ALL``
All, Smooth boundaries, including corners.

  """

  levels: int = ...

  """

  Number of subdivisions to perform

  """

  quality: int = ...

  """

  Accuracy of vertex positions, lower value is faster but less precise

  """

  render_levels: int = ...

  """

  Number of subdivisions to perform when rendering

  """

  show_only_control_edges: bool = ...

  """

  Skip drawing/rendering of interior subdivided edges

  """

  subdivision_type: str = ...

  """

  Select type of subdivision algorithm

  """

  use_creases: bool = ...

  """

  Use mesh edge crease information to sharpen edges

  """

  use_custom_normals: bool = ...

  """

  Interpolates existing custom normals to resulting mesh

  """

  use_limit_surface: bool = ...

  """

  Place vertices at the surface that would be produced with infinite levels of subdivision (smoothest possible shape)

  """

  uv_smooth: str = ...

  """

  Controls how smoothing is applied to UVs

  * ``NONE``
None, UVs are not smoothed, boundaries are kept sharp.

  * ``PRESERVE_CORNERS``
Keep Corners, UVs are smoothed, corners on discontinuous boundary are kept sharp.

  * ``PRESERVE_BOUNDARIES``
All, UVs and boundaries are smoothed.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SurfaceDeformModifier(bpy_struct, Modifier):

  falloff: float = ...

  """

  Controls how much nearby polygons influence deformation

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  is_bound: bool = ...

  """

  Whether geometry has been bound to target mesh

  """

  strength: float = ...

  """

  Strength of modifier deformations

  """

  target: Object = ...

  """

  Mesh object to deform with

  """

  vertex_group: str = ...

  """

  Vertex group name for selecting/weighting the affected areas

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SurfaceModifier(bpy_struct, Modifier):

  """

  Surface modifier defining modifier stack position used for surface fields

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TriangulateModifier(bpy_struct, Modifier):

  """

  Triangulate Mesh

  """

  keep_custom_normals: bool = ...

  """

  Try to preserve custom normals (WARNING: depending on chosen triangulation method, shading may not be fully preserved, 'Fixed' method usually gives the best result here)

  """

  min_vertices: int = ...

  """

  Triangulate only polygons with vertex count greater than or equal to this number

  """

  ngon_method: str = ...

  """

  Method for splitting the polygons into triangles

  * ``BEAUTY``
Beauty, Arrange the new triangles evenly (slow).

  * ``CLIP``
Clip, Split the polygons with an ear clipping algorithm.

  """

  quad_method: str = ...

  """

  Method for splitting the quads into triangles

  * ``BEAUTY``
Beauty, Split the quads in nice triangles, slower method.

  * ``FIXED``
Fixed, Split the quads on the first and third vertices.

  * ``FIXED_ALTERNATE``
Fixed Alternate, Split the quads on the 2nd and 4th vertices.

  * ``SHORTEST_DIAGONAL``
Shortest Diagonal, Split the quads based on the distance between the vertices.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UVProjectModifier(bpy_struct, Modifier):

  """

  UV projection modifier to set UVs from a projector

  """

  aspect_x: float = ...

  aspect_y: float = ...

  projector_count: int = ...

  """

  Number of projectors to use

  """

  projectors: typing.Union[typing.Sequence[UVProjector], typing.Mapping[str, UVProjector], bpy_prop_collection] = ...

  scale_x: float = ...

  scale_y: float = ...

  uv_layer: str = ...

  """

  UV map name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UVWarpModifier(bpy_struct, Modifier):

  """

  Add target position to uv coordinates

  """

  axis_u: str = ...

  """

  Pole axis for rotation

  """

  axis_v: str = ...

  """

  Pole axis for rotation

  """

  bone_from: str = ...

  """

  Bone defining offset

  """

  bone_to: str = ...

  """

  Bone defining offset

  """

  center: typing.Tuple[float, float] = ...

  """

  Center point for rotate/scale

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  object_from: Object = ...

  """

  Object defining offset

  """

  object_to: Object = ...

  """

  Object defining offset

  """

  offset: typing.Tuple[float, float] = ...

  """

  2D Offset for the warp

  """

  rotation: float = ...

  """

  2D Rotation for the warp

  """

  scale: typing.Tuple[float, float] = ...

  """

  2D Scale for the warp

  """

  uv_layer: str = ...

  """

  UV Layer name

  """

  vertex_group: str = ...

  """

  Vertex group name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertexWeightEditModifier(bpy_struct, Modifier):

  """

  Edit the weights of vertices in a group

  """

  add_threshold: float = ...

  """

  Lower bound for a vertex's weight to be added to the vgroup

  """

  default_weight: float = ...

  """

  Default weight a vertex will have if it is not in the vgroup

  """

  falloff_type: str = ...

  """

  How weights are mapped to their new values

  * ``LINEAR``
Linear, Null action.

  * ``CURVE``
Custom Curve.

  * ``SHARP``
Sharp.

  * ``SMOOTH``
Smooth.

  * ``ROOT``
Root.

  * ``ICON_SPHERECURVE``
Sphere.

  * ``RANDOM``
Random.

  * ``STEP``
Median Step, Map all values below 0.5 to 0.0, and all others to 1.0.

  """

  invert_falloff: bool = ...

  """

  Invert the resulting falloff weight

  """

  invert_mask_vertex_group: bool = ...

  """

  Invert vertex group mask influence

  """

  map_curve: CurveMapping = ...

  """

  Custom mapping curve

  """

  mask_constant: float = ...

  """

  Global influence of current modifications on vgroup

  """

  mask_tex_map_bone: str = ...

  """

  Which bone to take texture coordinates from

  """

  mask_tex_map_object: Object = ...

  """

  Which object to take texture coordinates from

  """

  mask_tex_mapping: str = ...

  """

  Which texture coordinates to use for mapping

  * ``LOCAL``
Local, Use local generated coordinates.

  * ``GLOBAL``
Global, Use global coordinates.

  * ``OBJECT``
Object, Use local generated coordinates of another object.

  * ``UV``
UV, Use coordinates from an UV layer.

  """

  mask_tex_use_channel: str = ...

  """

  Which texture channel to use for masking

  """

  mask_tex_uv_layer: str = ...

  """

  UV map name

  """

  mask_texture: Texture = ...

  """

  Masking texture

  """

  mask_vertex_group: str = ...

  """

  Masking vertex group name

  """

  normalize: bool = ...

  """

  Normalize the resulting weights (otherwise they are only clamped within [0.0, 1.0] range)

  """

  remove_threshold: float = ...

  """

  Upper bound for a vertex's weight to be removed from the vgroup

  """

  use_add: bool = ...

  """

  Add vertices with weight over threshold to vgroup

  """

  use_remove: bool = ...

  """

  Remove vertices with weight below threshold from vgroup

  """

  vertex_group: str = ...

  """

  Vertex group name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertexWeightMixModifier(bpy_struct, Modifier):

  """

  Mix the weights of two vertex groups

  """

  default_weight_a: float = ...

  """

  Default weight a vertex will have if it is not in the first A vgroup

  """

  default_weight_b: float = ...

  """

  Default weight a vertex will have if it is not in the second B vgroup

  """

  invert_mask_vertex_group: bool = ...

  """

  Invert vertex group mask influence

  """

  invert_vertex_group_a: bool = ...

  """

  Invert the influence of vertex group A

  """

  invert_vertex_group_b: bool = ...

  """

  Invert the influence of vertex group B

  """

  mask_constant: float = ...

  """

  Global influence of current modifications on vgroup

  """

  mask_tex_map_bone: str = ...

  """

  Which bone to take texture coordinates from

  """

  mask_tex_map_object: Object = ...

  """

  Which object to take texture coordinates from

  """

  mask_tex_mapping: str = ...

  """

  Which texture coordinates to use for mapping

  * ``LOCAL``
Local, Use local generated coordinates.

  * ``GLOBAL``
Global, Use global coordinates.

  * ``OBJECT``
Object, Use local generated coordinates of another object.

  * ``UV``
UV, Use coordinates from an UV layer.

  """

  mask_tex_use_channel: str = ...

  """

  Which texture channel to use for masking

  """

  mask_tex_uv_layer: str = ...

  """

  UV map name

  """

  mask_texture: Texture = ...

  """

  Masking texture

  """

  mask_vertex_group: str = ...

  """

  Masking vertex group name

  """

  mix_mode: str = ...

  """

  How weights from vgroup B affect weights of vgroup A

  * ``SET``
Replace, Replace VGroup A's weights by VGroup B's ones.

  * ``ADD``
Add, Add VGroup B's weights to VGroup A's ones.

  * ``SUB``
Subtract, Subtract VGroup B's weights from VGroup A's ones.

  * ``MUL``
Multiply, Multiply VGroup A's weights by VGroup B's ones.

  * ``DIV``
Divide, Divide VGroup A's weights by VGroup B's ones.

  * ``DIF``
Difference, Difference between VGroup A's and VGroup B's weights.

  * ``AVG``
Average, Average value of VGroup A's and VGroup B's weights.

  """

  mix_set: str = ...

  """

  Which vertices should be affected

  * ``ALL``
All, Affect all vertices (might add some to VGroup A).

  * ``A``
VGroup A, Affect vertices in VGroup A.

  * ``B``
VGroup B, Affect vertices in VGroup B (might add some to VGroup A).

  * ``OR``
VGroup A or B, Affect vertices in at least one of both VGroups (might add some to VGroup A).

  * ``AND``
VGroup A and B, Affect vertices in both groups.

  """

  normalize: bool = ...

  """

  Normalize the resulting weights (otherwise they are only clamped within [0.0, 1.0] range)

  """

  vertex_group_a: str = ...

  """

  First vertex group name

  """

  vertex_group_b: str = ...

  """

  Second vertex group name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertexWeightProximityModifier(bpy_struct, Modifier):

  """

  Set the weights of vertices in a group from a target object's distance

  """

  falloff_type: str = ...

  """

  How weights are mapped to their new values

  * ``LINEAR``
Linear, Null action.

  * ``SHARP``
Sharp.

  * ``SMOOTH``
Smooth.

  * ``ROOT``
Root.

  * ``ICON_SPHERECURVE``
Sphere.

  * ``RANDOM``
Random.

  * ``STEP``
Median Step, Map all values below 0.5 to 0.0, and all others to 1.0.

  """

  invert_falloff: bool = ...

  """

  Invert the resulting falloff weight

  """

  invert_mask_vertex_group: bool = ...

  """

  Invert vertex group mask influence

  """

  mask_constant: float = ...

  """

  Global influence of current modifications on vgroup

  """

  mask_tex_map_bone: str = ...

  """

  Which bone to take texture coordinates from

  """

  mask_tex_map_object: Object = ...

  """

  Which object to take texture coordinates from

  """

  mask_tex_mapping: str = ...

  """

  Which texture coordinates to use for mapping

  * ``LOCAL``
Local, Use local generated coordinates.

  * ``GLOBAL``
Global, Use global coordinates.

  * ``OBJECT``
Object, Use local generated coordinates of another object.

  * ``UV``
UV, Use coordinates from an UV layer.

  """

  mask_tex_use_channel: str = ...

  """

  Which texture channel to use for masking

  """

  mask_tex_uv_layer: str = ...

  """

  UV map name

  """

  mask_texture: Texture = ...

  """

  Masking texture

  """

  mask_vertex_group: str = ...

  """

  Masking vertex group name

  """

  max_dist: float = ...

  """

  Distance mapping to weight 1.0

  """

  min_dist: float = ...

  """

  Distance mapping to weight 0.0

  """

  normalize: bool = ...

  """

  Normalize the resulting weights (otherwise they are only clamped within [0.0, 1.0] range)

  """

  proximity_geometry: typing.Set[str] = ...

  """

  Use the shortest computed distance to target object's geometry as weight

  * ``VERTEX``
Vertex, Compute distance to nearest vertex.

  * ``EDGE``
Edge, Compute distance to nearest edge.

  * ``FACE``
Face, Compute distance to nearest face.

  """

  proximity_mode: str = ...

  """

  Which distances to target object to use

  * ``OBJECT``
Object, Use distance between affected and target objects.

  * ``GEOMETRY``
Geometry, Use distance between affected object's vertices and target object, or target object's geometry.

  """

  target: Object = ...

  """

  Object to calculate vertices distances from

  """

  vertex_group: str = ...

  """

  Vertex group name

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VolumeDisplaceModifier(bpy_struct, Modifier):

  strength: float = ...

  """

  Strength of the displacement

  """

  texture: Texture = ...

  texture_map_mode: str = ...

  """

  * ``LOCAL``
Local, Use the local coordinate system for the texture coordinates.

  * ``GLOBAL``
Global, Use the global coordinate system for the texture coordinates.

  * ``OBJECT``
Object, Use the linked object's local coordinate system for the texture coordinates.

  """

  texture_map_object: Object = ...

  """

  Object to use for texture mapping

  """

  texture_mid_level: typing.Tuple[float, float, float] = ...

  """

  Subtracted from the texture color to get a displacement vector

  """

  texture_sample_radius: float = ...

  """

  Smaller values result in better performance but might cut off the volume

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VolumeToMeshModifier(bpy_struct, Modifier):

  adaptivity: float = ...

  """

  Reduces the final face count by simplifying geometry where detail is not needed

  """

  grid_name: str = ...

  """

  Grid in the volume object that is converted to a mesh

  """

  object: Object = ...

  """

  Object

  """

  resolution_mode: str = ...

  """

  Mode for how the desired voxel size is specified

  * ``GRID``
Grid, Use resolution of the volume grid.

  * ``VOXEL_AMOUNT``
Voxel Amount, Desired number of voxels along one axis.

  * ``VOXEL_SIZE``
Voxel Size, Desired voxel side length.

  """

  threshold: float = ...

  """

  Voxels with a larger value are inside the generated mesh

  """

  use_smooth_shade: bool = ...

  """

  Output faces with smooth shading rather than flat shaded

  """

  voxel_amount: int = ...

  """

  Approximate number of voxels along one axis

  """

  voxel_size: float = ...

  """

  Smaller values result in a higher resolution output

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WarpModifier(bpy_struct, Modifier):

  """

  Warp modifier

  """

  bone_from: str = ...

  """

  Bone to transform from

  """

  bone_to: str = ...

  """

  Bone defining offset

  """

  falloff_curve: CurveMapping = ...

  """

  Custom falloff curve

  """

  falloff_radius: float = ...

  """

  Radius to apply

  """

  falloff_type: str = ...

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  object_from: Object = ...

  """

  Object to transform from

  """

  object_to: Object = ...

  """

  Object to transform to

  """

  strength: float = ...

  texture: Texture = ...

  texture_coords: str = ...

  """

  * ``LOCAL``
Local, Use the local coordinate system for the texture coordinates.

  * ``GLOBAL``
Global, Use the global coordinate system for the texture coordinates.

  * ``OBJECT``
Object, Use the linked object's local coordinate system for the texture coordinates.

  * ``UV``
UV, Use UV coordinates for the texture coordinates.

  """

  texture_coords_bone: str = ...

  """

  Bone to set the texture coordinates

  """

  texture_coords_object: Object = ...

  """

  Object to set the texture coordinates

  """

  use_volume_preserve: bool = ...

  """

  Preserve volume when rotations are used

  """

  uv_layer: str = ...

  """

  UV map name

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the deform

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WaveModifier(bpy_struct, Modifier):

  """

  Wave effect modifier

  """

  damping_time: float = ...

  """

  Number of frames in which the wave damps out after it dies

  """

  falloff_radius: float = ...

  """

  Distance after which it fades out

  """

  height: float = ...

  """

  Height of the wave

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  lifetime: float = ...

  """

  Lifetime of the wave in frames, zero means infinite

  """

  narrowness: float = ...

  """

  Distance between the top and the base of a wave, the higher the value, the more narrow the wave

  """

  speed: float = ...

  """

  Speed of the wave, towards the starting point when negative

  """

  start_position_object: Object = ...

  """

  Object which defines the wave center

  """

  start_position_x: float = ...

  """

  X coordinate of the start position

  """

  start_position_y: float = ...

  """

  Y coordinate of the start position

  """

  texture: Texture = ...

  texture_coords: str = ...

  """

  * ``LOCAL``
Local, Use the local coordinate system for the texture coordinates.

  * ``GLOBAL``
Global, Use the global coordinate system for the texture coordinates.

  * ``OBJECT``
Object, Use the linked object's local coordinate system for the texture coordinates.

  * ``UV``
UV, Use UV coordinates for the texture coordinates.

  """

  texture_coords_bone: str = ...

  """

  Bone to set the texture coordinates

  """

  texture_coords_object: Object = ...

  """

  Object to set the texture coordinates

  """

  time_offset: float = ...

  """

  Either the starting frame (for positive speed) or ending frame (for negative speed.)

  """

  use_cyclic: bool = ...

  """

  Cyclic wave effect

  """

  use_normal: bool = ...

  """

  Displace along normals

  """

  use_normal_x: bool = ...

  """

  Enable displacement along the X normal

  """

  use_normal_y: bool = ...

  """

  Enable displacement along the Y normal

  """

  use_normal_z: bool = ...

  """

  Enable displacement along the Z normal

  """

  use_x: bool = ...

  """

  X axis motion

  """

  use_y: bool = ...

  """

  Y axis motion

  """

  uv_layer: str = ...

  """

  UV map name

  """

  vertex_group: str = ...

  """

  Vertex group name for modulating the wave

  """

  width: float = ...

  """

  Distance between the waves

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WeightedNormalModifier(bpy_struct, Modifier):

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  keep_sharp: bool = ...

  """

  Keep sharp edges as computed for default split normals, instead of setting a single weighted normal for each vertex

  """

  mode: str = ...

  """

  Weighted vertex normal mode to use

  * ``FACE_AREA``
Face Area, Generate face area weighted normals.

  * ``CORNER_ANGLE``
Corner Angle, Generate corner angle weighted normals.

  * ``FACE_AREA_WITH_ANGLE``
Face Area And Angle, Generated normals weighted by both face area and angle.

  """

  thresh: float = ...

  """

  Threshold value for different weights to be considered equal

  """

  use_face_influence: bool = ...

  """

  Use influence of face for weighting

  """

  vertex_group: str = ...

  """

  Vertex group name for modifying the selected areas

  """

  weight: int = ...

  """

  Corrective factor applied to faces' weights, 50 is neutral, lower values increase weight of weak faces, higher values increase weight of strong faces

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WeldModifier(bpy_struct, Modifier):

  """

  Weld modifier

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  merge_threshold: float = ...

  """

  Limit below which to merge vertices

  """

  vertex_group: str = ...

  """

  Vertex group name for selecting the affected areas

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WireframeModifier(bpy_struct, Modifier):

  """

  Wireframe effect modifier

  """

  crease_weight: float = ...

  """

  Crease weight (if active)

  """

  invert_vertex_group: bool = ...

  """

  Invert vertex group influence

  """

  material_offset: int = ...

  """

  Offset material index of generated faces

  """

  offset: float = ...

  """

  Offset the thickness from the center

  """

  thickness: float = ...

  """

  Thickness factor

  """

  thickness_vertex_group: float = ...

  """

  Thickness factor to use for zero vertex group influence

  """

  use_boundary: bool = ...

  """

  Support face boundaries

  """

  use_crease: bool = ...

  """

  Crease hub edges for improved subdivision surface

  """

  use_even_offset: bool = ...

  """

  Scale the offset to give more even thickness

  """

  use_relative_offset: bool = ...

  """

  Scale the offset by surrounding geometry

  """

  use_replace: bool = ...

  """

  Remove original geometry

  """

  vertex_group: str = ...

  """

  Vertex group name for selecting the affected areas

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeCustomGroup(bpy_struct, Node):

  """

  Base node type for custom registered node group types

  """

  interface: PropertyGroup = ...

  """

  Interface socket data

  """

  node_tree: NodeTree = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeInternal(Node):

  @classmethod

  def poll(cls, node_tree: NodeTree) -> bool:

    """

    If non-null output is returned, the node type can be added to the tree

    """

    ...

  def poll_instance(self, node_tree: NodeTree) -> bool:

    """

    If non-null output is returned, the node can be added to the tree

    """

    ...

  def update(self) -> None:

    """

    Update on node graph topology changes (adding or removing nodes and links)

    """

    ...

  def draw_buttons(self, context: Context, layout: UILayout) -> None:

    """

    Draw node buttons

    """

    ...

  def draw_buttons_ext(self, context: Context, layout: UILayout) -> None:

    """

    Draw node buttons in the sidebar

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketStandard(NodeSocket):

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  def draw(self, context: Context, layout: UILayout, node: Node, text: str) -> None:

    """

    Draw socket

    """

    ...

  def draw_color(self, context: Context, node: Node) -> typing.Tuple[float, float, float, float]:

    """

    Color of the socket icon

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceStandard(NodeSocketInterface):

  type: str = ...

  """

  Data type

  """

  def draw(self, context: Context, layout: UILayout) -> None:

    """

    Draw template settings

    """

    ...

  def draw_color(self, context: Context) -> typing.Tuple[float, float, float, float]:

    """

    Color of the socket icon

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GpPaint(bpy_struct, Paint):

  color_mode: str = ...

  """

  Paint Mode

  * ``MATERIAL``
Material, Paint using the active material base color.

  * ``VERTEXCOLOR``
Vertex Color, Paint the material with custom vertex color.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GpSculptPaint(bpy_struct, Paint):

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GpVertexPaint(bpy_struct, Paint):

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GpWeightPaint(bpy_struct, Paint):

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ImagePaint(bpy_struct, Paint):

  """

  Properties of image and texture painting mode

  """

  canvas: Image = ...

  """

  Image used as canvas

  """

  clone_image: Image = ...

  """

  Image used as clone source

  """

  dither: float = ...

  """

  Amount of dithering when painting on byte images

  """

  interpolation: str = ...

  """

  Texture filtering type

  * ``LINEAR``
Linear, Linear interpolation.

  * ``CLOSEST``
Closest, No interpolation (sample closest texel).

  """

  invert_stencil: bool = ...

  """

  Invert the stencil layer

  """

  missing_materials: bool = ...

  """

  The mesh is missing materials

  """

  missing_stencil: bool = ...

  """

  Image Painting does not have a stencil

  """

  missing_texture: bool = ...

  """

  Image Painting does not have a texture to paint on

  """

  missing_uvs: bool = ...

  """

  A UV layer is missing on the mesh

  """

  mode: str = ...

  """

  Mode of operation for projection painting

  * ``MATERIAL``
Material, Detect image slots from the material.

  * ``IMAGE``
Single Image, Set image for texture painting directly.

  """

  normal_angle: int = ...

  """

  Paint most on faces pointing towards the view according to this angle

  """

  screen_grab_size: typing.Tuple[int, int] = ...

  """

  Size to capture the image for re-projecting

  """

  seam_bleed: int = ...

  """

  Extend paint beyond the faces UVs to reduce seams (in pixels, slower)

  """

  stencil_color: typing.Tuple[float, float, float] = ...

  """

  Stencil color in the viewport

  """

  stencil_image: Image = ...

  """

  Image used as stencil

  """

  use_backface_culling: bool = ...

  """

  Ignore faces pointing away from the view (faster)

  """

  use_clone_layer: bool = ...

  """

  Use another UV map as clone source, otherwise use the 3D cursor as the source

  """

  use_normal_falloff: bool = ...

  """

  Paint most on faces pointing towards the view

  """

  use_occlude: bool = ...

  """

  Only paint onto the faces directly under the brush (slower)

  """

  use_stencil_layer: bool = ...

  """

  Set the mask layer from the UV map buttons

  """

  def detect_data(self) -> bool:

    """

    Check if required texpaint data exist

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class Sculpt(bpy_struct, Paint):

  constant_detail_resolution: float = ...

  """

  Maximum edge length for dynamic topology sculpting (as divisor of blender unit - higher value means smaller edge length)

  """

  detail_percent: float = ...

  """

  Maximum edge length for dynamic topology sculpting (in brush percenage)

  """

  detail_refine_method: str = ...

  """

  In dynamic-topology mode, how to add or remove mesh detail

  * ``SUBDIVIDE``
Subdivide Edges, Subdivide long edges to add mesh detail where needed.

  * ``COLLAPSE``
Collapse Edges, Collapse short edges to remove mesh detail where possible.

  * ``SUBDIVIDE_COLLAPSE``
Subdivide Collapse, Both subdivide long edges and collapse short edges to refine mesh detail.

  """

  detail_size: float = ...

  """

  Maximum edge length for dynamic topology sculpting (in pixels)

  """

  detail_type_method: str = ...

  """

  In dynamic-topology mode, how mesh detail size is calculated

  * ``RELATIVE``
Relative Detail, Mesh detail is relative to the brush size and detail size.

  * ``CONSTANT``
Constant Detail, Mesh detail is constant in world space according to detail size.

  * ``BRUSH``
Brush Detail, Mesh detail is relative to brush radius.

  * ``MANUAL``
Manual Detail, Mesh detail does not change on each stroke, only when using Flood Fill.

  """

  gravity: float = ...

  """

  Amount of gravity after each dab

  """

  gravity_object: Object = ...

  """

  Object whose Z axis defines orientation of gravity

  """

  lock_x: bool = ...

  """

  Disallow changes to the X axis of vertices

  """

  lock_y: bool = ...

  """

  Disallow changes to the Y axis of vertices

  """

  lock_z: bool = ...

  """

  Disallow changes to the Z axis of vertices

  """

  radial_symmetry: typing.Tuple[int, int, int] = ...

  """

  Number of times to copy strokes across the surface

  """

  show_face_sets: bool = ...

  """

  Show Face Sets as overlay on object

  """

  show_mask: bool = ...

  """

  Show mask as overlay on object

  """

  symmetrize_direction: str = ...

  """

  Source and destination for symmetrize operator

  """

  use_automasking_boundary_edges: bool = ...

  """

  Do not affect non manifold boundary edges

  """

  use_automasking_boundary_face_sets: bool = ...

  """

  Do not affect vertices that belong to a Face Set boundary

  """

  use_automasking_face_sets: bool = ...

  """

  Affect only vertices that share Face Sets with the active vertex

  """

  use_automasking_topology: bool = ...

  """

  Affect only vertices connected to the active vertex under the brush

  """

  use_deform_only: bool = ...

  """

  Use only deformation modifiers (temporary disable all constructive modifiers except multi-resolution)

  """

  use_smooth_shading: bool = ...

  """

  Show faces in dynamic-topology mode with smooth shading rather than flat shaded

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UvSculpt(bpy_struct, Paint):

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VertexPaint(bpy_struct, Paint):

  """

  Properties of vertex and weight paint mode

  """

  radial_symmetry: typing.Tuple[int, int, int] = ...

  """

  Number of times to copy strokes across the surface

  """

  use_group_restrict: bool = ...

  """

  Restrict painting to vertices in the group

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BoolProperty(bpy_struct, Property):

  """

  RNA boolean property definition

  """

  array_dimensions: typing.Tuple[int, int, int] = ...

  """

  Length of each dimension of the array

  """

  array_length: int = ...

  """

  Maximum length of the array, 0 means unlimited

  """

  default: bool = ...

  """

  Default value for this number

  """

  default_array: typing.Tuple[bool, bool, bool] = ...

  """

  Default value for this array

  """

  is_array: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CollectionProperty(bpy_struct, Property):

  """

  RNA collection property to define lists, arrays and mappings

  """

  fixed_type: Struct = ...

  """

  Fixed pointer type, empty if variable type

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class EnumProperty(bpy_struct, Property):

  """

  RNA enumeration property definition, to choose from a number of predefined options

  """

  default: str = ...

  """

  Default value for this enum

  """

  default_flag: typing.Set[str] = ...

  """

  Default value for this enum

  """

  enum_items: typing.Union[typing.Sequence[EnumPropertyItem], typing.Mapping[str, EnumPropertyItem], bpy_prop_collection] = ...

  """

  Possible values for the property

  """

  enum_items_static: typing.Union[typing.Sequence[EnumPropertyItem], typing.Mapping[str, EnumPropertyItem], bpy_prop_collection] = ...

  """

  Possible values for the property (never calls optional dynamic generation of those)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FloatProperty(bpy_struct, Property):

  """

  RNA floating point number (single precision) property definition

  """

  array_dimensions: typing.Tuple[int, int, int] = ...

  """

  Length of each dimension of the array

  """

  array_length: int = ...

  """

  Maximum length of the array, 0 means unlimited

  """

  default: float = ...

  """

  Default value for this number

  """

  default_array: typing.Tuple[float, float, float] = ...

  """

  Default value for this array

  """

  hard_max: float = ...

  """

  Maximum value used by buttons

  """

  hard_min: float = ...

  """

  Minimum value used by buttons

  """

  is_array: bool = ...

  precision: int = ...

  """

  Number of digits after the dot used by buttons

  """

  soft_max: float = ...

  """

  Maximum value used by buttons

  """

  soft_min: float = ...

  """

  Minimum value used by buttons

  """

  step: float = ...

  """

  Step size used by number buttons, for floats 1/100th of the step size

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IntProperty(bpy_struct, Property):

  """

  RNA integer number property definition

  """

  array_dimensions: typing.Tuple[int, int, int] = ...

  """

  Length of each dimension of the array

  """

  array_length: int = ...

  """

  Maximum length of the array, 0 means unlimited

  """

  default: int = ...

  """

  Default value for this number

  """

  default_array: typing.Tuple[int, int, int] = ...

  """

  Default value for this array

  """

  hard_max: int = ...

  """

  Maximum value used by buttons

  """

  hard_min: int = ...

  """

  Minimum value used by buttons

  """

  is_array: bool = ...

  soft_max: int = ...

  """

  Maximum value used by buttons

  """

  soft_min: int = ...

  """

  Minimum value used by buttons

  """

  step: int = ...

  """

  Step size used by number buttons, for floats 1/100th of the step size

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PointerProperty(bpy_struct, Property):

  """

  RNA pointer property to point to another RNA struct

  """

  fixed_type: Struct = ...

  """

  Fixed pointer type, empty if variable type

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class StringProperty(bpy_struct, Property):

  """

  RNA text string property definition

  """

  default: str = ...

  """

  string default value

  """

  length_max: int = ...

  """

  Maximum length of the string, 0 means unlimited

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class OperatorFileListElement(bpy_struct, PropertyGroup):

  name: str = ...

  """

  Name of a file or directory within a file list

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class OperatorMousePath(bpy_struct, PropertyGroup):

  """

  Mouse path values for operators that record such paths

  """

  loc: typing.Tuple[float, float] = ...

  """

  Mouse location

  """

  time: float = ...

  """

  Time of mouse location

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class OperatorStrokeElement(bpy_struct, PropertyGroup):

  is_start: bool = ...

  location: typing.Tuple[float, float, float] = ...

  mouse: typing.Tuple[float, float] = ...

  mouse_event: typing.Tuple[float, float] = ...

  pen_flip: bool = ...

  pressure: float = ...

  """

  Tablet pressure

  """

  size: float = ...

  """

  Brush size in screen space

  """

  time: float = ...

  x_tilt: float = ...

  y_tilt: float = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SelectedUvElement(bpy_struct, PropertyGroup):

  element_index: int = ...

  face_index: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class EffectSequence(Sequence):

  """

  Sequence strip applying an effect on the images created by other strips

  """

  alpha_mode: str = ...

  """

  Representation of alpha information in the RGBA pixels

  * ``STRAIGHT``
Straight, RGB channels in transparent pixels are unaffected by the alpha channel.

  * ``PREMUL``
Premultiplied, RGB channels in transparent pixels are multiplied by the alpha channel.

  """

  color_multiply: float = ...

  color_saturation: float = ...

  """

  Adjust the intensity of the input's color

  """

  crop: SequenceCrop = ...

  proxy: SequenceProxy = ...

  strobe: float = ...

  """

  Only display every nth frame

  """

  transform: SequenceTransform = ...

  use_crop: bool = ...

  """

  Crop image before processing

  """

  use_deinterlace: bool = ...

  """

  Remove fields from video movies

  """

  use_flip_x: bool = ...

  """

  Flip on the X axis

  """

  use_flip_y: bool = ...

  """

  Flip on the Y axis

  """

  use_float: bool = ...

  """

  Convert input to float data

  """

  use_proxy: bool = ...

  """

  Use a preview proxy and/or time-code index for this strip

  """

  use_reverse_frames: bool = ...

  """

  Reverse frame order

  """

  use_translation: bool = ...

  """

  Translate image before processing

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ImageSequence(bpy_struct, Sequence):

  """

  Sequence strip to load one or more images

  """

  alpha_mode: str = ...

  """

  Representation of alpha information in the RGBA pixels

  * ``STRAIGHT``
Straight, RGB channels in transparent pixels are unaffected by the alpha channel.

  * ``PREMUL``
Premultiplied, RGB channels in transparent pixels are multiplied by the alpha channel.

  """

  animation_offset_end: int = ...

  """

  Animation end offset (trim end)

  """

  animation_offset_start: int = ...

  """

  Animation start offset (trim start)

  """

  color_multiply: float = ...

  color_saturation: float = ...

  """

  Adjust the intensity of the input's color

  """

  colorspace_settings: ColorManagedInputColorspaceSettings = ...

  """

  Input color space settings

  """

  crop: SequenceCrop = ...

  directory: str = ...

  elements: typing.Union[SequenceElements, typing.Sequence[SequenceElement], typing.Mapping[str, SequenceElement], bpy_prop_collection] = ...

  proxy: SequenceProxy = ...

  stereo_3d_format: Stereo3dFormat = ...

  """

  Settings for stereo 3d

  """

  strobe: float = ...

  """

  Only display every nth frame

  """

  transform: SequenceTransform = ...

  use_crop: bool = ...

  """

  Crop image before processing

  """

  use_deinterlace: bool = ...

  """

  Remove fields from video movies

  """

  use_flip_x: bool = ...

  """

  Flip on the X axis

  """

  use_flip_y: bool = ...

  """

  Flip on the Y axis

  """

  use_float: bool = ...

  """

  Convert input to float data

  """

  use_multiview: bool = ...

  """

  Use Multiple Views (when available)

  """

  use_proxy: bool = ...

  """

  Use a preview proxy and/or time-code index for this strip

  """

  use_reverse_frames: bool = ...

  """

  Reverse frame order

  """

  use_translation: bool = ...

  """

  Translate image before processing

  """

  views_format: str = ...

  """

  Mode to load image views

  * ``INDIVIDUAL``
Individual, Individual files for each view with the prefix as defined by the scene views.

  * ``STEREO_3D``
Stereo 3D, Single file with an encoded stereo pair.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MaskSequence(bpy_struct, Sequence):

  """

  Sequence strip to load a video from a mask

  """

  alpha_mode: str = ...

  """

  Representation of alpha information in the RGBA pixels

  * ``STRAIGHT``
Straight, RGB channels in transparent pixels are unaffected by the alpha channel.

  * ``PREMUL``
Premultiplied, RGB channels in transparent pixels are multiplied by the alpha channel.

  """

  animation_offset_end: int = ...

  """

  Animation end offset (trim end)

  """

  animation_offset_start: int = ...

  """

  Animation start offset (trim start)

  """

  color_multiply: float = ...

  color_saturation: float = ...

  """

  Adjust the intensity of the input's color

  """

  crop: SequenceCrop = ...

  mask: Mask = ...

  """

  Mask that this sequence uses

  """

  strobe: float = ...

  """

  Only display every nth frame

  """

  transform: SequenceTransform = ...

  use_crop: bool = ...

  """

  Crop image before processing

  """

  use_deinterlace: bool = ...

  """

  Remove fields from video movies

  """

  use_flip_x: bool = ...

  """

  Flip on the X axis

  """

  use_flip_y: bool = ...

  """

  Flip on the Y axis

  """

  use_float: bool = ...

  """

  Convert input to float data

  """

  use_reverse_frames: bool = ...

  """

  Reverse frame order

  """

  use_translation: bool = ...

  """

  Translate image before processing

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MetaSequence(bpy_struct, Sequence):

  """

  Sequence strip to group other strips as a single sequence strip

  """

  alpha_mode: str = ...

  """

  Representation of alpha information in the RGBA pixels

  * ``STRAIGHT``
Straight, RGB channels in transparent pixels are unaffected by the alpha channel.

  * ``PREMUL``
Premultiplied, RGB channels in transparent pixels are multiplied by the alpha channel.

  """

  animation_offset_end: int = ...

  """

  Animation end offset (trim end)

  """

  animation_offset_start: int = ...

  """

  Animation start offset (trim start)

  """

  color_multiply: float = ...

  color_saturation: float = ...

  """

  Adjust the intensity of the input's color

  """

  crop: SequenceCrop = ...

  proxy: SequenceProxy = ...

  sequences: typing.Union[typing.Sequence[Sequence], typing.Mapping[str, Sequence], bpy_prop_collection] = ...

  strobe: float = ...

  """

  Only display every nth frame

  """

  transform: SequenceTransform = ...

  use_crop: bool = ...

  """

  Crop image before processing

  """

  use_deinterlace: bool = ...

  """

  Remove fields from video movies

  """

  use_flip_x: bool = ...

  """

  Flip on the X axis

  """

  use_flip_y: bool = ...

  """

  Flip on the Y axis

  """

  use_float: bool = ...

  """

  Convert input to float data

  """

  use_proxy: bool = ...

  """

  Use a preview proxy and/or time-code index for this strip

  """

  use_reverse_frames: bool = ...

  """

  Reverse frame order

  """

  use_translation: bool = ...

  """

  Translate image before processing

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieClipSequence(bpy_struct, Sequence):

  """

  Sequence strip to load a video from the clip editor

  """

  alpha_mode: str = ...

  """

  Representation of alpha information in the RGBA pixels

  * ``STRAIGHT``
Straight, RGB channels in transparent pixels are unaffected by the alpha channel.

  * ``PREMUL``
Premultiplied, RGB channels in transparent pixels are multiplied by the alpha channel.

  """

  animation_offset_end: int = ...

  """

  Animation end offset (trim end)

  """

  animation_offset_start: int = ...

  """

  Animation start offset (trim start)

  """

  color_multiply: float = ...

  color_saturation: float = ...

  """

  Adjust the intensity of the input's color

  """

  crop: SequenceCrop = ...

  fps: float = ...

  """

  Frames per second

  """

  stabilize2d: bool = ...

  """

  Use the 2D stabilized version of the clip

  """

  strobe: float = ...

  """

  Only display every nth frame

  """

  transform: SequenceTransform = ...

  undistort: bool = ...

  """

  Use the undistorted version of the clip

  """

  use_crop: bool = ...

  """

  Crop image before processing

  """

  use_deinterlace: bool = ...

  """

  Remove fields from video movies

  """

  use_flip_x: bool = ...

  """

  Flip on the X axis

  """

  use_flip_y: bool = ...

  """

  Flip on the Y axis

  """

  use_float: bool = ...

  """

  Convert input to float data

  """

  use_reverse_frames: bool = ...

  """

  Reverse frame order

  """

  use_translation: bool = ...

  """

  Translate image before processing

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MovieSequence(bpy_struct, Sequence):

  """

  Sequence strip to load a video

  """

  alpha_mode: str = ...

  """

  Representation of alpha information in the RGBA pixels

  * ``STRAIGHT``
Straight, RGB channels in transparent pixels are unaffected by the alpha channel.

  * ``PREMUL``
Premultiplied, RGB channels in transparent pixels are multiplied by the alpha channel.

  """

  animation_offset_end: int = ...

  """

  Animation end offset (trim end)

  """

  animation_offset_start: int = ...

  """

  Animation start offset (trim start)

  """

  color_multiply: float = ...

  color_saturation: float = ...

  """

  Adjust the intensity of the input's color

  """

  colorspace_settings: ColorManagedInputColorspaceSettings = ...

  """

  Input color space settings

  """

  crop: SequenceCrop = ...

  elements: typing.Union[typing.Sequence[SequenceElement], typing.Mapping[str, SequenceElement], bpy_prop_collection] = ...

  filepath: str = ...

  fps: float = ...

  """

  Frames per second

  """

  mpeg_preseek: int = ...

  """

  For MPEG movies, preseek this many frames

  """

  proxy: SequenceProxy = ...

  stereo_3d_format: Stereo3dFormat = ...

  """

  Settings for stereo 3d

  """

  stream_index: int = ...

  """

  For files with several movie streams, use the stream with the given index

  """

  strobe: float = ...

  """

  Only display every nth frame

  """

  transform: SequenceTransform = ...

  use_crop: bool = ...

  """

  Crop image before processing

  """

  use_deinterlace: bool = ...

  """

  Remove fields from video movies

  """

  use_flip_x: bool = ...

  """

  Flip on the X axis

  """

  use_flip_y: bool = ...

  """

  Flip on the Y axis

  """

  use_float: bool = ...

  """

  Convert input to float data

  """

  use_multiview: bool = ...

  """

  Use Multiple Views (when available)

  """

  use_proxy: bool = ...

  """

  Use a preview proxy and/or time-code index for this strip

  """

  use_reverse_frames: bool = ...

  """

  Reverse frame order

  """

  use_translation: bool = ...

  """

  Translate image before processing

  """

  views_format: str = ...

  """

  Mode to load movie views

  * ``INDIVIDUAL``
Individual, Individual files for each view with the prefix as defined by the scene views.

  * ``STEREO_3D``
Stereo 3D, Single file with an encoded stereo pair.

  """

  def reload_if_needed(self) -> bool:

    """

    reload_if_needed

    """

    ...

  def metadata(self) -> IDPropertyWrapPtr:

    """

    Retrieve metadata of the movie file

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SceneSequence(bpy_struct, Sequence):

  """

  Sequence strip to used the rendered image of a scene

  """

  alpha_mode: str = ...

  """

  Representation of alpha information in the RGBA pixels

  * ``STRAIGHT``
Straight, RGB channels in transparent pixels are unaffected by the alpha channel.

  * ``PREMUL``
Premultiplied, RGB channels in transparent pixels are multiplied by the alpha channel.

  """

  animation_offset_end: int = ...

  """

  Animation end offset (trim end)

  """

  animation_offset_start: int = ...

  """

  Animation start offset (trim start)

  """

  color_multiply: float = ...

  color_saturation: float = ...

  """

  Adjust the intensity of the input's color

  """

  crop: SequenceCrop = ...

  fps: float = ...

  """

  Frames per second

  """

  proxy: SequenceProxy = ...

  scene: Scene = ...

  """

  Scene that this sequence uses

  """

  scene_camera: Object = ...

  """

  Override the scenes active camera

  """

  scene_input: str = ...

  """

  Input type to use for the Scene strip

  * ``CAMERA``
Camera, Use the Scene's 3D camera as input.

  * ``SEQUENCER``
Sequencer, Use the Scene's Sequencer timeline as input.

  """

  strobe: float = ...

  """

  Only display every nth frame

  """

  transform: SequenceTransform = ...

  use_crop: bool = ...

  """

  Crop image before processing

  """

  use_deinterlace: bool = ...

  """

  Remove fields from video movies

  """

  use_flip_x: bool = ...

  """

  Flip on the X axis

  """

  use_flip_y: bool = ...

  """

  Flip on the Y axis

  """

  use_float: bool = ...

  """

  Convert input to float data

  """

  use_grease_pencil: bool = ...

  """

  Show Grease Pencil strokes in OpenGL previews

  """

  use_proxy: bool = ...

  """

  Use a preview proxy and/or time-code index for this strip

  """

  use_reverse_frames: bool = ...

  """

  Reverse frame order

  """

  use_translation: bool = ...

  """

  Translate image before processing

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SoundSequence(bpy_struct, Sequence):

  """

  Sequence strip defining a sound to be played over a period of time

  """

  animation_offset_end: int = ...

  """

  Animation end offset (trim end)

  """

  animation_offset_start: int = ...

  """

  Animation start offset (trim start)

  """

  pan: float = ...

  """

  Playback panning of the sound (only for Mono sources)

  """

  pitch: float = ...

  """

  Playback pitch of the sound

  """

  show_waveform: bool = ...

  """

  Display the audio waveform inside the strip

  """

  sound: Sound = ...

  """

  Sound data-block used by this sequence

  """

  volume: float = ...

  """

  Playback volume of the sound

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequenceColorBalance(bpy_struct, SequenceColorBalanceData):

  """

  Color balance parameters for a sequence strip

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BrightContrastModifier(bpy_struct, SequenceModifier):

  """

  Bright/contrast modifier data for sequence strip

  """

  bright: float = ...

  """

  Adjust the luminosity of the colors

  """

  contrast: float = ...

  """

  Adjust the difference in luminosity between pixels

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorBalanceModifier(bpy_struct, SequenceModifier):

  """

  Color balance modifier for sequence strip

  """

  color_balance: SequenceColorBalanceData = ...

  color_multiply: float = ...

  """

  Multiply the intensity of each pixel

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CurvesModifier(bpy_struct, SequenceModifier):

  """

  RGB curves modifier for sequence strip

  """

  curve_mapping: CurveMapping = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class HueCorrectModifier(bpy_struct, SequenceModifier):

  """

  Hue correction modifier for sequence strip

  """

  curve_mapping: CurveMapping = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SequencerTonemapModifierData(bpy_struct, SequenceModifier):

  """

  Tone mapping modifier

  """

  adaptation: float = ...

  """

  If 0, global; if 1, based on pixel intensity

  """

  contrast: float = ...

  """

  Set to 0 to use estimate from input image

  """

  correction: float = ...

  """

  If 0, same for all channels; if 1, each independent

  """

  gamma: float = ...

  """

  If not used, set to 1

  """

  intensity: float = ...

  """

  If less than zero, darkens image; otherwise, makes it brighter

  """

  key: float = ...

  """

  The value the average luminance is mapped to

  """

  offset: float = ...

  """

  Normally always 1, but can be used as an extra control to alter the brightness curve

  """

  tonemap_type: str = ...

  """

  Tone mapping algorithm

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WhiteBalanceModifier(bpy_struct, SequenceModifier):

  """

  White balance modifier for sequence strip

  """

  white_value: typing.Tuple[float, float, float] = ...

  """

  This color defines white in the strip

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderFxBlur(bpy_struct, ShaderFx):

  """

  Gaussian Blur effect

  """

  rotation: float = ...

  """

  Rotation of the effect

  """

  samples: int = ...

  """

  Number of Blur Samples (zero, disable blur)

  """

  size: typing.Tuple[float, float] = ...

  """

  Factor of Blur

  """

  use_dof_mode: bool = ...

  """

  Blur using camera depth of field

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderFxColorize(bpy_struct, ShaderFx):

  """

  Colorize effect

  """

  factor: float = ...

  """

  Mix factor

  """

  high_color: typing.Tuple[float, float, float, float] = ...

  """

  Second color used for effect

  """

  low_color: typing.Tuple[float, float, float, float] = ...

  """

  First color used for effect

  """

  mode: str = ...

  """

  Effect mode

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderFxFlip(bpy_struct, ShaderFx):

  """

  Flip effect

  """

  flip_horizontal: bool = ...

  """

  Flip image horizontally

  """

  flip_vertical: bool = ...

  """

  Flip image vertically

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderFxGlow(bpy_struct, ShaderFx):

  """

  Glow effect

  """

  blend_mode: str = ...

  """

  Blend mode

  """

  glow_color: typing.Tuple[float, float, float] = ...

  """

  Color used for generated glow

  """

  mode: str = ...

  """

  Glow mode

  """

  opacity: float = ...

  """

  Effect Opacity

  """

  rotation: float = ...

  """

  Rotation of the effect

  """

  samples: int = ...

  """

  Number of Blur Samples

  """

  select_color: typing.Tuple[float, float, float] = ...

  """

  Color selected to apply glow

  """

  size: typing.Tuple[float, float] = ...

  """

  Size of the effect

  """

  threshold: float = ...

  """

  Limit to select color for glow effect

  """

  use_glow_under: bool = ...

  """

  Glow only areas with alpha (not supported with Regular blend mode)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderFxPixel(bpy_struct, ShaderFx):

  """

  Pixelate effect

  """

  size: typing.Tuple[int, int] = ...

  """

  Pixel size

  """

  use_antialiasing: bool = ...

  """

  Antialias pixels

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderFxRim(bpy_struct, ShaderFx):

  """

  Rim effect

  """

  blur: typing.Tuple[int, int] = ...

  """

  Number of pixels for blurring rim (set to 0 to disable)

  """

  mask_color: typing.Tuple[float, float, float] = ...

  """

  Color that must be kept

  """

  mode: str = ...

  """

  Blend mode

  """

  offset: typing.Tuple[int, int] = ...

  """

  Offset of the rim

  """

  rim_color: typing.Tuple[float, float, float] = ...

  """

  Color used for Rim

  """

  samples: int = ...

  """

  Number of Blur Samples (zero, disable blur)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderFxShadow(bpy_struct, ShaderFx):

  """

  Shadow effect

  """

  amplitude: float = ...

  """

  Amplitude of Wave

  """

  blur: typing.Tuple[int, int] = ...

  """

  Number of pixels for blurring shadow (set to 0 to disable)

  """

  object: Object = ...

  """

  Object to determine center of rotation

  """

  offset: typing.Tuple[int, int] = ...

  """

  Offset of the shadow

  """

  orientation: str = ...

  """

  Direction of the wave

  """

  period: float = ...

  """

  Period of Wave

  """

  phase: float = ...

  """

  Phase Shift of Wave

  """

  rotation: float = ...

  """

  Rotation around center or object

  """

  samples: int = ...

  """

  Number of Blur Samples (zero, disable blur)

  """

  scale: typing.Tuple[float, float] = ...

  """

  Offset of the shadow

  """

  shadow_color: typing.Tuple[float, float, float, float] = ...

  """

  Color used for Shadow

  """

  use_object: bool = ...

  """

  Use object as center of rotation

  """

  use_wave: bool = ...

  """

  Use wave effect

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderFxSwirl(bpy_struct, ShaderFx):

  """

  Swirl effect

  """

  angle: float = ...

  """

  Angle of rotation

  """

  object: Object = ...

  """

  Object to determine center location

  """

  radius: int = ...

  """

  Radius to apply

  """

  use_transparent: bool = ...

  """

  Make image transparent outside of radius

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderFxWave(bpy_struct, ShaderFx):

  """

  Wave Deformation effect

  """

  amplitude: float = ...

  """

  Amplitude of Wave

  """

  orientation: str = ...

  """

  Direction of the wave

  """

  period: float = ...

  """

  Period of Wave

  """

  phase: float = ...

  """

  Phase Shift of Wave

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SpaceClipEditor(bpy_struct, Space):

  """

  Clip editor space data

  """

  annotation_source: str = ...

  """

  Where the annotation comes from

  * ``CLIP``
Clip, Show annotation data-block which belongs to movie clip.

  * ``TRACK``
Track, Show annotation data-block which belongs to active track.

  """

  clip: MovieClip = ...

  """

  Movie clip displayed and edited in this space

  """

  clip_user: MovieClipUser = ...

  """

  Parameters defining which frame of the movie clip is displayed

  """

  lock_selection: bool = ...

  """

  Lock viewport to selected markers during playback

  """

  lock_time_cursor: bool = ...

  """

  Lock curves view to time cursor during playback and tracking

  """

  mask: Mask = ...

  """

  Mask displayed and edited in this space

  """

  mask_display_type: str = ...

  """

  Display type for mask splines

  * ``OUTLINE``
Outline, Display white edges with black outline.

  * ``DASH``
Dash, Display dashed black-white edges.

  * ``BLACK``
Black, Display black edges.

  * ``WHITE``
White, Display white edges.

  """

  mask_overlay_mode: str = ...

  """

  Overlay mode of rasterized mask

  * ``ALPHACHANNEL``
Alpha Channel, Show alpha channel of the mask.

  * ``COMBINED``
Combined, Combine space background image with the mask.

  """

  mode: str = ...

  """

  Editing context being displayed

  * ``TRACKING``
Tracking, Show tracking and solving tools.

  * ``MASK``
Mask, Show mask editing tools.

  """

  path_length: int = ...

  """

  Length of displaying path, in frames

  """

  pivot_point: str = ...

  """

  Pivot center for rotation/scaling

  * ``BOUNDING_BOX_CENTER``
Bounding Box Center, Pivot around bounding box center of selected object(s).

  * ``CURSOR``
2D Cursor, Pivot around the 2D cursor.

  * ``INDIVIDUAL_ORIGINS``
Individual Origins, Pivot around each object's own origin.

  * ``MEDIAN_POINT``
Median Point, Pivot around the median point of selected objects.

  """

  scopes: MovieClipScopes = ...

  """

  Scopes to visualize movie clip statistics

  """

  show_annotation: bool = ...

  """

  Show annotations for this view

  """

  show_blue_channel: bool = ...

  """

  Show blue channel in the frame

  """

  show_bundles: bool = ...

  """

  Show projection of 3D markers into footage

  """

  show_disabled: bool = ...

  """

  Show disabled tracks from the footage

  """

  show_filters: bool = ...

  """

  Show filters for graph editor

  """

  show_graph_frames: bool = ...

  """

  Show curve for per-frame average error (camera motion should be solved first)

  """

  show_graph_hidden: bool = ...

  """

  Include channels from objects/bone that aren't visible

  """

  show_graph_only_selected: bool = ...

  """

  Only include channels relating to selected objects and data

  """

  show_graph_tracks_error: bool = ...

  """

  Display the reprojection error curve for selected tracks

  """

  show_graph_tracks_motion: bool = ...

  """

  Display the speed curves (in "x" direction red, in "y" direction green) for the selected tracks

  """

  show_green_channel: bool = ...

  """

  Show green channel in the frame

  """

  show_grid: bool = ...

  """

  Show grid showing lens distortion

  """

  show_marker_pattern: bool = ...

  """

  Show pattern boundbox for markers

  """

  show_marker_search: bool = ...

  """

  Show search boundbox for markers

  """

  show_mask_overlay: bool = ...

  show_mask_smooth: bool = ...

  show_metadata: bool = ...

  """

  Show metadata of clip

  """

  show_names: bool = ...

  """

  Show track names and status

  """

  show_red_channel: bool = ...

  """

  Show red channel in the frame

  """

  show_region_hud: bool = ...

  show_region_toolbar: bool = ...

  show_region_ui: bool = ...

  show_seconds: bool = ...

  """

  Show timing in seconds not frames

  """

  show_stable: bool = ...

  """

  Show stable footage in editor (if stabilization is enabled)

  """

  show_tiny_markers: bool = ...

  """

  Show markers in a more compact manner

  """

  show_track_path: bool = ...

  """

  Show path of how track moves

  """

  use_grayscale_preview: bool = ...

  """

  Display frame in grayscale mode

  """

  use_manual_calibration: bool = ...

  """

  Use manual calibration helpers

  """

  use_mute_footage: bool = ...

  """

  Mute footage and show black background instead

  """

  view: str = ...

  """

  Type of the clip editor view

  * ``CLIP``
Clip, Show editing clip preview.

  * ``GRAPH``
Graph, Show graph view for active element.

  * ``DOPESHEET``
Dopesheet, Dopesheet view for tracking data.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceConsole(bpy_struct, Space):

  """

  Interactive python console

  """

  font_size: int = ...

  """

  Font size to use for displaying the text

  """

  history: typing.Union[typing.Sequence[ConsoleLine], typing.Mapping[str, ConsoleLine], bpy_prop_collection] = ...

  """

  Command history

  """

  language: str = ...

  """

  Command line prompt language

  """

  prompt: str = ...

  """

  Command line prompt

  """

  scrollback: typing.Union[typing.Sequence[ConsoleLine], typing.Mapping[str, ConsoleLine], bpy_prop_collection] = ...

  """

  Command output

  """

  select_end: int = ...

  select_start: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceDopeSheetEditor(bpy_struct, Space):

  """

  Dope Sheet space data

  """

  action: Action = ...

  """

  Action displayed and edited in this space

  """

  auto_snap: str = ...

  """

  Automatic time snapping settings for transformations

  * ``NONE``
No Auto-Snap.

  * ``STEP``
Frame Step, Snap to 1.0 frame intervals.

  * ``TIME_STEP``
Second Step, Snap to 1.0 second intervals.

  * ``FRAME``
Nearest Frame, Snap to actual frames (nla-action time).

  * ``SECOND``
Nearest Second, Snap to actual seconds (nla-action time).

  * ``MARKER``
Nearest Marker, Snap to nearest marker.

  """

  cache_cloth: bool = ...

  """

  Show the active object's cloth point cache

  """

  cache_dynamicpaint: bool = ...

  """

  Show the active object's Dynamic Paint cache

  """

  cache_particles: bool = ...

  """

  Show the active object's particle point cache

  """

  cache_rigidbody: bool = ...

  """

  Show the active object's Rigid Body cache

  """

  cache_smoke: bool = ...

  """

  Show the active object's smoke cache

  """

  cache_softbody: bool = ...

  """

  Show the active object's softbody point cache

  """

  dopesheet: DopeSheet = ...

  """

  Settings for filtering animation data

  """

  mode: str = ...

  """

  Editing context being displayed

  * ``DOPESHEET``
Dope Sheet, Edit all keyframes in scene.

  * ``TIMELINE``
Timeline, Timeline and playback controls.

  * ``ACTION``
Action Editor, Edit keyframes in active object's Object-level action.

  * ``SHAPEKEY``
Shape Key Editor, Edit keyframes in active object's Shape Keys action.

  * ``GPENCIL``
Grease Pencil, Edit timings for all Grease Pencil sketches in file.

  * ``MASK``
Mask, Edit timings for Mask Editor splines.

  * ``CACHEFILE``
Cache File, Edit timings for Cache File data-blocks.

  """

  show_cache: bool = ...

  """

  Show the status of cached frames in the timeline

  """

  show_extremes: bool = ...

  """

  Mark keyframes where the key value flow changes direction, based on comparison with adjacent keys

  """

  show_group_colors: bool = ...

  """

  Display groups and channels with colors matching their corresponding groups (pose bones only currently)

  """

  show_interpolation: bool = ...

  """

  Display keyframe handle types and non-bezier interpolation modes

  """

  show_markers: bool = ...

  """

  If any exists, show markers in a separate row at the bottom of the editor

  """

  show_pose_markers: bool = ...

  """

  Show markers belonging to the active action instead of Scene markers (Action and Shape Key Editors only)

  """

  show_region_ui: bool = ...

  show_seconds: bool = ...

  """

  Show timing in seconds not frames

  """

  show_sliders: bool = ...

  """

  Show sliders beside F-Curve channels

  """

  ui_mode: str = ...

  """

  Editing context being displayed

  * ``DOPESHEET``
Dope Sheet, Edit all keyframes in scene.

  * ``ACTION``
Action Editor, Edit keyframes in active object's Object-level action.

  * ``SHAPEKEY``
Shape Key Editor, Edit keyframes in active object's Shape Keys action.

  * ``GPENCIL``
Grease Pencil, Edit timings for all Grease Pencil sketches in file.

  * ``MASK``
Mask, Edit timings for Mask Editor splines.

  * ``CACHEFILE``
Cache File, Edit timings for Cache File data-blocks.

  """

  use_auto_merge_keyframes: bool = ...

  """

  Automatically merge nearby keyframes

  """

  use_marker_sync: bool = ...

  """

  Sync Markers with keyframe edits

  """

  use_realtime_update: bool = ...

  """

  When transforming keyframes, changes to the animation data are flushed to other views

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceFileBrowser(bpy_struct, Space):

  """

  File browser space data

  """

  active_operator: Operator = ...

  bookmarks: typing.Union[typing.Sequence[FileBrowserFSMenuEntry], typing.Mapping[str, FileBrowserFSMenuEntry], bpy_prop_collection] = ...

  """

  User's bookmarks

  """

  bookmarks_active: int = ...

  """

  Index of active bookmark (-1 if none)

  """

  operator: Operator = ...

  params: FileSelectParams = ...

  """

  Parameters and Settings for the Filebrowser

  """

  recent_folders: typing.Union[typing.Sequence[FileBrowserFSMenuEntry], typing.Mapping[str, FileBrowserFSMenuEntry], bpy_prop_collection] = ...

  recent_folders_active: int = ...

  """

  Index of active recent folder (-1 if none)

  """

  show_region_toolbar: bool = ...

  show_region_ui: bool = ...

  system_bookmarks: typing.Union[typing.Sequence[FileBrowserFSMenuEntry], typing.Mapping[str, FileBrowserFSMenuEntry], bpy_prop_collection] = ...

  """

  System's bookmarks

  """

  system_bookmarks_active: int = ...

  """

  Index of active system bookmark (-1 if none)

  """

  system_folders: typing.Union[typing.Sequence[FileBrowserFSMenuEntry], typing.Mapping[str, FileBrowserFSMenuEntry], bpy_prop_collection] = ...

  """

  System's folders (usually root, available hard drives, etc)

  """

  system_folders_active: int = ...

  """

  Index of active system folder (-1 if none)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceGraphEditor(bpy_struct, Space):

  """

  Graph Editor space data

  """

  auto_snap: str = ...

  """

  Automatic time snapping settings for transformations

  * ``NONE``
No Auto-Snap.

  * ``STEP``
Frame Step, Snap to 1.0 frame intervals.

  * ``TIME_STEP``
Second Step, Snap to 1.0 second intervals.

  * ``FRAME``
Nearest Frame, Snap to actual frames (nla-action time).

  * ``SECOND``
Nearest Second, Snap to actual seconds (nla-action time).

  * ``MARKER``
Nearest Marker, Snap to nearest marker.

  """

  cursor_position_x: float = ...

  """

  Graph Editor 2D-Value cursor - X-Value component

  """

  cursor_position_y: float = ...

  """

  Graph Editor 2D-Value cursor - Y-Value component

  """

  dopesheet: DopeSheet = ...

  """

  Settings for filtering animation data

  """

  has_ghost_curves: bool = ...

  """

  Graph Editor instance has some ghost curves stored

  """

  mode: str = ...

  """

  Editing context being displayed

  * ``FCURVES``
Graph Editor, Edit animation/keyframes displayed as 2D curves.

  * ``DRIVERS``
Drivers, Edit drivers.

  """

  pivot_point: str = ...

  """

  Pivot center for rotation/scaling

  """

  show_cursor: bool = ...

  """

  Show 2D cursor

  """

  show_group_colors: bool = ...

  """

  Display groups and channels with colors matching their corresponding groups

  """

  show_handles: bool = ...

  """

  Show handles of Bezier control points

  """

  show_markers: bool = ...

  """

  If any exists, show markers in a separate row at the bottom of the editor

  """

  show_region_hud: bool = ...

  show_region_ui: bool = ...

  show_seconds: bool = ...

  """

  Show timing in seconds not frames

  """

  show_sliders: bool = ...

  """

  Show sliders beside F-Curve channels

  """

  use_auto_merge_keyframes: bool = ...

  """

  Automatically merge nearby keyframes

  """

  use_auto_normalization: bool = ...

  """

  Automatically recalculate curve normalization on every curve edit

  """

  use_beauty_drawing: bool = ...

  """

  Display F-Curves using Anti-Aliasing and other fancy effects (disable for better performance)

  """

  use_normalization: bool = ...

  """

  Display curves in normalized to -1..1 range, for easier editing of multiple curves with different ranges

  """

  use_only_selected_curves_handles: bool = ...

  """

  Only keyframes of selected F-Curves are visible and editable

  """

  use_only_selected_keyframe_handles: bool = ...

  """

  Only show and edit handles of selected keyframes

  """

  use_realtime_update: bool = ...

  """

  When transforming keyframes, changes to the animation data are flushed to other views

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceImageEditor(bpy_struct, Space):

  """

  Image and UV editor space data

  """

  cursor_location: typing.Tuple[float, float] = ...

  """

  2D cursor location for this view

  """

  display_channels: str = ...

  """

  Channels of the image to draw

  * ``COLOR_ALPHA``
Color and Alpha, Display image with RGB colors and alpha transparency.

  * ``COLOR``
Color, Display image with RGB colors.

  * ``ALPHA``
Alpha, Display  alpha transparency channel.

  * ``Z_BUFFER``
Z-Buffer, Display Z-buffer associated with image (mapped from camera clip start to end).

  * ``RED``
Red.

  * ``GREEN``
Green.

  * ``BLUE``
Blue.

  """

  grease_pencil: GreasePencil = ...

  """

  Grease pencil data for this space

  """

  image: Image = ...

  """

  Image displayed and edited in this space

  """

  image_user: ImageUser = ...

  """

  Parameters defining which layer, pass and frame of the image is displayed

  """

  mask: Mask = ...

  """

  Mask displayed and edited in this space

  """

  mask_display_type: str = ...

  """

  Display type for mask splines

  * ``OUTLINE``
Outline, Display white edges with black outline.

  * ``DASH``
Dash, Display dashed black-white edges.

  * ``BLACK``
Black, Display black edges.

  * ``WHITE``
White, Display white edges.

  """

  mask_overlay_mode: str = ...

  """

  Overlay mode of rasterized mask

  * ``ALPHACHANNEL``
Alpha Channel, Show alpha channel of the mask.

  * ``COMBINED``
Combined, Combine space background image with the mask.

  """

  mode: str = ...

  """

  Editing context being displayed

  * ``VIEW``
View, View the image.

  * ``UV``
UV Editor, UV edit in mesh editmode.

  * ``PAINT``
Paint, 2D image painting mode.

  * ``MASK``
Mask, Mask editing.

  """

  overlay: SpaceImageOverlay = ...

  """

  Settings for display of overlays in the UV/Image editor

  """

  pivot_point: str = ...

  """

  Rotation/Scaling Pivot

  * ``BOUNDING_BOX_CENTER``
Bounding Box Center, Pivot around bounding box center of selected object(s).

  * ``CURSOR``
3D Cursor, Pivot around the 3D cursor.

  * ``INDIVIDUAL_ORIGINS``
Individual Origins, Pivot around each object's own origin.

  * ``MEDIAN_POINT``
Median Point, Pivot around the median point of selected objects.

  * ``ACTIVE_ELEMENT``
Active Element, Pivot around active object.

  """

  sample_histogram: Histogram = ...

  """

  Sampled colors along line

  """

  scopes: Scopes = ...

  """

  Scopes to visualize image statistics

  """

  show_annotation: bool = ...

  """

  Show annotations for this view

  """

  show_mask_overlay: bool = ...

  show_mask_smooth: bool = ...

  show_maskedit: bool = ...

  """

  Show Mask editing related properties

  """

  show_paint: bool = ...

  """

  Show paint related properties

  """

  show_region_hud: bool = ...

  show_region_tool_header: bool = ...

  show_region_toolbar: bool = ...

  show_region_ui: bool = ...

  show_render: bool = ...

  """

  Show render related properties

  """

  show_repeat: bool = ...

  """

  Display the image repeated outside of the main view

  """

  show_stereo_3d: bool = ...

  """

  Display the image in Stereo 3D

  """

  show_uvedit: bool = ...

  """

  Show UV editing related properties

  """

  ui_mode: str = ...

  """

  Editing context being displayed

  * ``VIEW``
View, View the image.

  * ``PAINT``
Paint, 2D image painting mode.

  * ``MASK``
Mask, Mask editing.

  """

  use_image_pin: bool = ...

  """

  Display current image regardless of object selection

  """

  use_realtime_update: bool = ...

  """

  Update other affected window spaces automatically to reflect changes during interactive operations such as transform

  """

  uv_editor: SpaceUVEditor = ...

  """

  UV editor settings

  """

  zoom: typing.Tuple[float, float] = ...

  """

  Zoom factor

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceInfo(bpy_struct, Space):

  """

  Info space data

  """

  show_report_debug: bool = ...

  """

  Display debug reporting info

  """

  show_report_error: bool = ...

  """

  Display error text

  """

  show_report_info: bool = ...

  """

  Display general information

  """

  show_report_operator: bool = ...

  """

  Display the operator log

  """

  show_report_warning: bool = ...

  """

  Display warnings

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceNLA(bpy_struct, Space):

  """

  NLA editor space data

  """

  auto_snap: str = ...

  """

  Automatic time snapping settings for transformations

  * ``NONE``
No Auto-Snap.

  * ``STEP``
Frame Step, Snap to 1.0 frame intervals.

  * ``TIME_STEP``
Second Step, Snap to 1.0 second intervals.

  * ``FRAME``
Nearest Frame, Snap to actual frames (nla-action time).

  * ``SECOND``
Nearest Second, Snap to actual seconds (nla-action time).

  * ``MARKER``
Nearest Marker, Snap to nearest marker.

  """

  dopesheet: DopeSheet = ...

  """

  Settings for filtering animation data

  """

  show_local_markers: bool = ...

  """

  Show action-local markers on the strips, useful when synchronizing timing across strips

  """

  show_markers: bool = ...

  """

  If any exists, show markers in a separate row at the bottom of the editor

  """

  show_region_ui: bool = ...

  show_seconds: bool = ...

  """

  Show timing in seconds not frames

  """

  show_strip_curves: bool = ...

  """

  Show influence F-Curves on strips

  """

  use_realtime_update: bool = ...

  """

  When transforming strips, changes to the animation data are flushed to other views

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceNodeEditor(bpy_struct, Space):

  """

  Node editor space data

  """

  backdrop_channels: str = ...

  """

  Channels of the image to draw

  * ``COLOR_ALPHA``
Color and Alpha, Display image with RGB colors and alpha transparency.

  * ``COLOR``
Color, Display image with RGB colors.

  * ``ALPHA``
Alpha, Display alpha transparency channel.

  * ``RED``
Red.

  * ``GREEN``
Green.

  * ``BLUE``
Blue.

  """

  backdrop_offset: typing.Tuple[float, float] = ...

  """

  Backdrop offset

  """

  backdrop_zoom: float = ...

  """

  Backdrop zoom factor

  """

  cursor_location: typing.Tuple[float, float] = ...

  """

  Location for adding new nodes

  """

  edit_tree: NodeTree = ...

  """

  Node tree being displayed and edited

  """

  id: ID = ...

  """

  Data-block whose nodes are being edited

  """

  id_from: ID = ...

  """

  Data-block from which the edited data-block is linked

  """

  insert_offset_direction: str = ...

  """

  Direction to offset nodes on insertion

  """

  node_tree: NodeTree = ...

  """

  Base node tree from context

  """

  path: typing.Union[SpaceNodeEditorPath, typing.Sequence[NodeTreePath], typing.Mapping[str, NodeTreePath], bpy_prop_collection] = ...

  """

  Path from the data-block to the currently edited node tree

  """

  pin: bool = ...

  """

  Use the pinned node tree

  """

  shader_type: str = ...

  """

  Type of data to take shader from

  * ``OBJECT``
Object, Edit shader nodes from Object.

  * ``WORLD``
World, Edit shader nodes from World.

  * ``LINESTYLE``
Line Style, Edit shader nodes from Line Style.

  """

  show_annotation: bool = ...

  """

  Show annotations for this view

  """

  show_backdrop: bool = ...

  """

  Use active Viewer Node output as backdrop for compositing nodes

  """

  show_region_toolbar: bool = ...

  show_region_ui: bool = ...

  texture_type: str = ...

  """

  Type of data to take texture from

  * ``WORLD``
World, Edit texture nodes from World.

  * ``BRUSH``
Brush, Edit texture nodes from Brush.

  * ``LINESTYLE``
Line Style, Edit texture nodes from Line Style.

  """

  tree_type: str = ...

  """

  Node tree type to display and edit

  """

  use_auto_render: bool = ...

  """

  Re-render and composite changed layers on 3D edits

  """

  use_insert_offset: bool = ...

  """

  Automatically offset the following or previous nodes in a chain when inserting a new node

  """

  def cursor_location_from_region(self, x: int, y: int) -> None:

    """

    Set the cursor location using region coordinates

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceOutliner(bpy_struct, Space):

  """

  Outliner space data

  """

  display_mode: str = ...

  """

  Type of information to display

  * ``SCENES``
Scenes, Display scenes and their view layers, collections and objects.

  * ``VIEW_LAYER``
View Layer, Display collections and objects in the view layer.

  * ``SEQUENCE``
Video Sequencer, Display data belonging to the Video Sequencer.

  * ``LIBRARIES``
Blender File, Display data of current file and linked libraries.

  * ``DATA_API``
Data API, Display low level Blender data and its properties.

  * ``ORPHAN_DATA``
Orphan Data, Display data-blocks which are unused and/or will be lost when the file is reloaded.

  """

  filter_id_type: str = ...

  """

  Data-block type to show

  """

  filter_state: str = ...

  """

  * ``ALL``
All, Show all objects in the view layer.

  * ``VISIBLE``
Visible, Show visible objects.

  * ``HIDDEN``
Hidden, Show hidden objects.

  * ``SELECTED``
Selected, Show selected objects.

  * ``ACTIVE``
Active, Show only the active object.

  """

  filter_text: str = ...

  """

  Live search filtering string

  """

  show_mode_column: bool = ...

  """

  Show the mode column for mode toggle and activation

  """

  show_restrict_column_enable: bool = ...

  """

  Exclude from view layer

  """

  show_restrict_column_hide: bool = ...

  """

  Temporarily hide in viewport

  """

  show_restrict_column_holdout: bool = ...

  """

  Holdout

  """

  show_restrict_column_indirect_only: bool = ...

  """

  Indirect only

  """

  show_restrict_column_render: bool = ...

  """

  Globally disable in renders

  """

  show_restrict_column_select: bool = ...

  """

  Selectable

  """

  show_restrict_column_viewport: bool = ...

  """

  Globally disable in viewports

  """

  use_filter_case_sensitive: bool = ...

  """

  Only use case sensitive matches of search string

  """

  use_filter_children: bool = ...

  """

  Show children

  """

  use_filter_collection: bool = ...

  """

  Show collections

  """

  use_filter_complete: bool = ...

  """

  Only use complete matches of search string

  """

  use_filter_id_type: bool = ...

  """

  Show only data-blocks of one type

  """

  use_filter_object: bool = ...

  """

  Show objects

  """

  use_filter_object_armature: bool = ...

  """

  Show armature objects

  """

  use_filter_object_camera: bool = ...

  """

  Show camera objects

  """

  use_filter_object_content: bool = ...

  """

  Show what is inside the objects elements

  """

  use_filter_object_empty: bool = ...

  """

  Show empty objects

  """

  use_filter_object_light: bool = ...

  """

  Show light objects

  """

  use_filter_object_mesh: bool = ...

  """

  Show mesh objects

  """

  use_filter_object_others: bool = ...

  """

  Show curves, lattices, light probes, fonts, ...

  """

  use_sort_alpha: bool = ...

  use_sync_select: bool = ...

  """

  Sync outliner selection with other editors

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpacePreferences(bpy_struct, Space):

  """

  Blender preferences space data

  """

  filter_text: str = ...

  """

  Search term for filtering in the UI

  """

  filter_type: str = ...

  """

  Filter method

  * ``NAME``
Name, Filter based on the operator name.

  * ``KEY``
Key-Binding, Filter based on key bindings.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceProperties(bpy_struct, Space):

  """

  Properties space data

  """

  context: str = ...

  """

  * ``TOOL``
Tool, Active Tool and Workspace settings.

  * ``SCENE``
Scene, Scene Properties.

  * ``RENDER``
Render, Render Properties.

  * ``OUTPUT``
Output, Output Properties.

  * ``VIEW_LAYER``
View Layer, View Layer Properties.

  * ``WORLD``
World, World Properties.

  * ``OBJECT``
Object, Object Properties.

  * ``CONSTRAINT``
Constraints, Object Constraint Properties.

  * ``MODIFIER``
Modifiers, Modifier Properties.

  * ``DATA``
Data, Object Data Properties.

  * ``BONE``
Bone, Bone Properties.

  * ``BONE_CONSTRAINT``
Bone Constraints, Bone Constraint Properties.

  * ``MATERIAL``
Material, Material Properties.

  * ``TEXTURE``
Texture, Texture Properties.

  * ``PARTICLES``
Particles, Particle Properties.

  * ``PHYSICS``
Physics, Physics Properties.

  * ``SHADERFX``
Effects, Visual Effects Properties.

  """

  pin_id: ID = ...

  search_filter: str = ...

  """

  Live search filtering string

  """

  tab_search_results: bool = ...

  """

  Whether or not each visible tab has a search result

  """

  use_pin_id: bool = ...

  """

  Use the pinned context

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceSequenceEditor(bpy_struct, Space):

  """

  Sequence editor space data

  """

  display_channel: int = ...

  """

  The channel number shown in the image preview. 0 is the result of all strips combined

  """

  display_mode: str = ...

  """

  View mode to use for displaying sequencer output

  """

  grease_pencil: GreasePencil = ...

  """

  Grease Pencil data for this Preview region

  """

  overlay_type: str = ...

  """

  Overlay draw type

  * ``RECTANGLE``
Rectangle, Show rectangle area overlay.

  * ``REFERENCE``
Reference, Show reference frame only.

  * ``CURRENT``
Current, Show current frame only.

  """

  preview_channels: str = ...

  """

  Channels of the preview to draw

  * ``COLOR_ALPHA``
Color and Alpha, Display image with RGB colors and alpha transparency.

  * ``COLOR``
Color, Display image with RGB colors.

  """

  proxy_render_size: str = ...

  """

  Display preview using full resolution or different proxy resolutions

  """

  show_annotation: bool = ...

  """

  Show annotations for this view

  """

  show_backdrop: bool = ...

  """

  Display result under strips

  """

  show_fcurves: bool = ...

  """

  Display strip opacity/volume curve

  """

  show_frames: bool = ...

  """

  Display frames rather than seconds

  """

  show_markers: bool = ...

  """

  If any exists, show markers in a separate row at the bottom of the editor

  """

  show_metadata: bool = ...

  """

  Show metadata of first visible strip

  """

  show_overexposed: int = ...

  """

  Show overexposed areas with zebra stripes

  """

  show_region_hud: bool = ...

  show_region_tool_header: bool = ...

  show_region_toolbar: bool = ...

  show_region_ui: bool = ...

  show_safe_areas: bool = ...

  """

  Show TV title safe and action safe areas in preview

  """

  show_safe_center: bool = ...

  """

  Show safe areas to fit content in a different aspect ratio

  """

  show_seconds: bool = ...

  """

  Show timing in seconds not frames

  """

  show_separate_color: bool = ...

  """

  Separate color channels in preview

  """

  show_strip_offset: bool = ...

  """

  Display strip in/out offsets

  """

  use_marker_sync: bool = ...

  """

  Transform markers as well as strips

  """

  use_zoom_to_fit: bool = ...

  """

  Automatically zoom preview image to make it fully fit the region

  """

  view_type: str = ...

  """

  Type of the Sequencer view (sequencer, preview or both)

  """

  waveform_display_type: str = ...

  """

  How Waveforms are drawn

  * ``NO_WAVEFORMS``
Waveforms Off, No waveforms drawn for any sound strips.

  * ``ALL_WAVEFORMS``
Waveforms On, Waveforms drawn for all sound strips.

  * ``DEFAULT_WAVEFORMS``
Use Strip Option, Waveforms drawn according to strip setting.

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceTextEditor(bpy_struct, Space):

  """

  Text editor space data

  """

  find_text: str = ...

  """

  Text to search for with the find tool

  """

  font_size: int = ...

  """

  Font size to use for displaying the text

  """

  margin_column: int = ...

  """

  Column number to show right margin at

  """

  replace_text: str = ...

  """

  Text to replace selected text with using the replace tool

  """

  show_line_highlight: bool = ...

  """

  Highlight the current line

  """

  show_line_numbers: bool = ...

  """

  Show line numbers next to the text

  """

  show_margin: bool = ...

  """

  Show right margin

  """

  show_region_footer: bool = ...

  show_region_ui: bool = ...

  show_syntax_highlight: bool = ...

  """

  Syntax highlight for scripting

  """

  show_word_wrap: bool = ...

  """

  Wrap words if there is not enough horizontal space

  """

  tab_width: int = ...

  """

  Number of spaces to display tabs with

  """

  text: Text = ...

  """

  Text displayed and edited in this space

  """

  top: int = ...

  """

  Top line visible

  """

  use_find_all: bool = ...

  """

  Search in all text data-blocks, instead of only the active one

  """

  use_find_wrap: bool = ...

  """

  Search again from the start of the file when reaching the end

  """

  use_live_edit: bool = ...

  """

  Run python while editing

  """

  use_match_case: bool = ...

  """

  Search string is sensitive to uppercase and lowercase letters

  """

  use_overwrite: bool = ...

  """

  Overwrite characters when typing rather than inserting them

  """

  visible_lines: int = ...

  """

  Amount of lines that can be visible in current editor

  """

  def is_syntax_highlight_supported(self) -> bool:

    """

    Returns True if the editor supports syntax highlighting for the current text datablock

    """

    ...

  def region_location_from_cursor(self, line: int, column: int) -> typing.Tuple[int, int]:

    """

    Retrieve the region position from the given line and character position

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class SpaceView3D(bpy_struct, Space):

  """

  3D View space data

  """

  camera: Object = ...

  """

  Active camera used in this view (when unlocked from the scene's active camera)

  """

  clip_end: float = ...

  """

  3D View far clipping distance

  """

  clip_start: float = ...

  """

  3D View near clipping distance (perspective view only)

  """

  icon_from_show_object_viewport: int = ...

  lens: float = ...

  """

  Viewport lens angle

  """

  local_view: SpaceView3D = ...

  """

  Display an isolated sub-set of objects, apart from the scene visibility

  """

  lock_bone: str = ...

  """

  3D View center is locked to this bone's position

  """

  lock_camera: bool = ...

  """

  Enable view navigation within the camera view

  """

  lock_cursor: bool = ...

  """

  3D View center is locked to the cursor's position

  """

  lock_object: Object = ...

  """

  3D View center is locked to this object's position

  """

  mirror_xr_session: bool = ...

  """

  Synchronize the viewer perspective of virtual reality sessions with this 3D viewport

  """

  overlay: View3DOverlay = ...

  """

  Settings for display of overlays in the 3D viewport

  """

  region_3d: RegionView3D = ...

  """

  3D region in this space, in case of quad view the camera region

  """

  region_quadviews: typing.Union[typing.Sequence[RegionView3D], typing.Mapping[str, RegionView3D], bpy_prop_collection] = ...

  """

  3D regions (the third one defines quad view settings, the fourth one is same as 'region_3d')

  """

  render_border_max_x: float = ...

  """

  Maximum X value for the render region

  """

  render_border_max_y: float = ...

  """

  Maximum Y value for the render region

  """

  render_border_min_x: float = ...

  """

  Minimum X value for the render region

  """

  render_border_min_y: float = ...

  """

  Minimum Y value for the render region

  """

  shading: View3DShading = ...

  """

  Settings for shading in the 3D viewport

  """

  show_bundle_names: bool = ...

  """

  Show names for reconstructed tracks objects

  """

  show_camera_path: bool = ...

  """

  Show reconstructed camera path

  """

  show_gizmo: bool = ...

  """

  Show gizmos of all types

  """

  show_gizmo_camera_dof_distance: bool = ...

  """

  Gizmo to adjust camera focus distance (depends on limits display)

  """

  show_gizmo_camera_lens: bool = ...

  """

  Gizmo to adjust camera lens & ortho size

  """

  show_gizmo_context: bool = ...

  """

  Context sensitive gizmos for the active item

  """

  show_gizmo_empty_force_field: bool = ...

  """

  Gizmo to adjust the force field

  """

  show_gizmo_empty_image: bool = ...

  """

  Gizmo to adjust image size and position

  """

  show_gizmo_light_look_at: bool = ...

  """

  Gizmo to adjust the direction of the light

  """

  show_gizmo_light_size: bool = ...

  """

  Gizmo to adjust spot and area size

  """

  show_gizmo_navigate: bool = ...

  """

  Viewport navigation gizmo

  """

  show_gizmo_object_rotate: bool = ...

  """

  Gizmo to adjust rotation

  """

  show_gizmo_object_scale: bool = ...

  """

  Gizmo to adjust scale

  """

  show_gizmo_object_translate: bool = ...

  """

  Gizmo to adjust location

  """

  show_gizmo_tool: bool = ...

  """

  Active tool gizmo

  """

  show_object_select_armature: bool = ...

  show_object_select_camera: bool = ...

  show_object_select_curve: bool = ...

  show_object_select_empty: bool = ...

  show_object_select_font: bool = ...

  show_object_select_grease_pencil: bool = ...

  show_object_select_hair: bool = ...

  show_object_select_lattice: bool = ...

  show_object_select_light: bool = ...

  show_object_select_light_probe: bool = ...

  show_object_select_mesh: bool = ...

  show_object_select_meta: bool = ...

  show_object_select_pointcloud: bool = ...

  show_object_select_speaker: bool = ...

  show_object_select_surf: bool = ...

  show_object_select_volume: bool = ...

  show_object_viewport_armature: bool = ...

  show_object_viewport_camera: bool = ...

  show_object_viewport_curve: bool = ...

  show_object_viewport_empty: bool = ...

  show_object_viewport_font: bool = ...

  show_object_viewport_grease_pencil: bool = ...

  show_object_viewport_hair: bool = ...

  show_object_viewport_lattice: bool = ...

  show_object_viewport_light: bool = ...

  show_object_viewport_light_probe: bool = ...

  show_object_viewport_mesh: bool = ...

  show_object_viewport_meta: bool = ...

  show_object_viewport_pointcloud: bool = ...

  show_object_viewport_speaker: bool = ...

  show_object_viewport_surf: bool = ...

  show_object_viewport_volume: bool = ...

  show_reconstruction: bool = ...

  """

  Display reconstruction data from active movie clip

  """

  show_region_hud: bool = ...

  show_region_tool_header: bool = ...

  show_region_toolbar: bool = ...

  show_region_ui: bool = ...

  show_stereo_3d_cameras: bool = ...

  """

  Show the left and right cameras

  """

  show_stereo_3d_convergence_plane: bool = ...

  """

  Show the stereo 3d convergence plane

  """

  show_stereo_3d_volume: bool = ...

  """

  Show the stereo 3d frustum volume

  """

  stereo_3d_camera: str = ...

  stereo_3d_convergence_plane_alpha: float = ...

  """

  Opacity (alpha) of the convergence plane

  """

  stereo_3d_eye: str = ...

  """

  Current stereo eye being drawn

  """

  stereo_3d_volume_alpha: float = ...

  """

  Opacity (alpha) of the cameras' frustum volume

  """

  tracks_display_size: float = ...

  """

  Display size of tracks from reconstructed data

  """

  tracks_display_type: str = ...

  """

  Viewport display style for tracks

  """

  use_local_camera: bool = ...

  """

  Use a local camera in this view, rather than scene's active camera

  """

  use_local_collections: bool = ...

  """

  Display a different set of collections in this viewport

  """

  use_render_border: bool = ...

  """

  Use a region within the frame size for rendered viewport(when not viewing through the camera)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

  def draw_handler_add(self, callback: typing.Callable, args: typing.Tuple[typing.Any, ...], region_type: str, draw_type: str) -> Object:

    """

    Add a new draw handler to this space type.
It will be called every time the specified region in the space type will be drawn.
Note: All arguments are positional only for now.

    """

    ...

  def draw_handler_remove(self, handler: Object, region_type: str) -> None:

    """

    Remove a draw handler that was added previously.

    """

    ...

class BrushTextureSlot(bpy_struct, TextureSlot):

  """

  Texture slot for textures in a Brush data-block

  """

  angle: float = ...

  """

  Brush texture rotation

  """

  has_random_texture_angle: bool = ...

  has_texture_angle: bool = ...

  has_texture_angle_source: bool = ...

  map_mode: str = ...

  mask_map_mode: str = ...

  random_angle: float = ...

  """

  Brush texture random angle

  """

  tex_paint_map_mode: str = ...

  use_rake: bool = ...

  use_random: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleTextureSlot(bpy_struct, TextureSlot):

  """

  Texture slot for textures in a LineStyle data-block

  """

  alpha_factor: float = ...

  """

  Amount texture affects alpha

  """

  diffuse_color_factor: float = ...

  """

  Amount texture affects diffuse color

  """

  mapping: str = ...

  """

  * ``FLAT``
Flat, Map X and Y coordinates directly.

  * ``CUBE``
Cube, Map using the normal vector.

  * ``TUBE``
Tube, Map with Z as central axis.

  * ``SPHERE``
Sphere, Map with Z as central axis.

  """

  mapping_x: str = ...

  mapping_y: str = ...

  mapping_z: str = ...

  texture_coords: str = ...

  """

  Texture coordinates used to map the texture onto the background

  * ``WINDOW``
Window, Use screen coordinates as texture coordinates.

  * ``GLOBAL``
Global, Use global coordinates for the texture coordinates.

  * ``ALONG_STROKE``
Along stroke, Use stroke length for texture coordinates.

  * ``ORCO``
Generated, Use the original undeformed coordinates of the object.

  """

  use_map_alpha: bool = ...

  """

  The texture affects the alpha value

  """

  use_map_color_diffuse: bool = ...

  """

  The texture affects basic color of the stroke

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ParticleSettingsTextureSlot(bpy_struct, TextureSlot):

  """

  Texture slot for textures in a Particle Settings data-block

  """

  clump_factor: float = ...

  """

  Amount texture affects child clump

  """

  damp_factor: float = ...

  """

  Amount texture affects particle damping

  """

  density_factor: float = ...

  """

  Amount texture affects particle density

  """

  field_factor: float = ...

  """

  Amount texture affects particle force fields

  """

  gravity_factor: float = ...

  """

  Amount texture affects particle gravity

  """

  kink_amp_factor: float = ...

  """

  Amount texture affects child kink amplitude

  """

  kink_freq_factor: float = ...

  """

  Amount texture affects child kink frequency

  """

  length_factor: float = ...

  """

  Amount texture affects child hair length

  """

  life_factor: float = ...

  """

  Amount texture affects particle life time

  """

  mapping: str = ...

  """

  * ``FLAT``
Flat, Map X and Y coordinates directly.

  * ``CUBE``
Cube, Map using the normal vector.

  * ``TUBE``
Tube, Map with Z as central axis.

  * ``SPHERE``
Sphere, Map with Z as central axis.

  """

  mapping_x: str = ...

  mapping_y: str = ...

  mapping_z: str = ...

  object: Object = ...

  """

  Object to use for mapping with Object texture coordinates

  """

  rough_factor: float = ...

  """

  Amount texture affects child roughness

  """

  size_factor: float = ...

  """

  Amount texture affects physical particle size

  """

  texture_coords: str = ...

  """

  Texture coordinates used to map the texture onto the background

  * ``GLOBAL``
Global, Use global coordinates for the texture coordinates.

  * ``OBJECT``
Object, Use linked object's coordinates for texture coordinates.

  * ``UV``
UV, Use UV coordinates for texture coordinates.

  * ``ORCO``
Generated, Use the original undeformed coordinates of the object.

  * ``STRAND``
Strand / Particle, Use normalized strand texture coordinate (1D) or particle age (X) and trail position (Y).

  """

  time_factor: float = ...

  """

  Amount texture affects particle emission time

  """

  twist_factor: float = ...

  """

  Amount texture affects child twist

  """

  use_map_clump: bool = ...

  """

  Affect the child clumping

  """

  use_map_damp: bool = ...

  """

  Affect the particle velocity damping

  """

  use_map_density: bool = ...

  """

  Affect the density of the particles

  """

  use_map_field: bool = ...

  """

  Affect the particle force fields

  """

  use_map_gravity: bool = ...

  """

  Affect the particle gravity

  """

  use_map_kink_amp: bool = ...

  """

  Affect the child kink amplitude

  """

  use_map_kink_freq: bool = ...

  """

  Affect the child kink frequency

  """

  use_map_length: bool = ...

  """

  Affect the child hair length

  """

  use_map_life: bool = ...

  """

  Affect the life time of the particles

  """

  use_map_rough: bool = ...

  """

  Affect the child rough

  """

  use_map_size: bool = ...

  """

  Affect the particle size

  """

  use_map_time: bool = ...

  """

  Affect the emission time of the particles

  """

  use_map_twist: bool = ...

  """

  Affect the child twist

  """

  use_map_velocity: bool = ...

  """

  Affect the particle initial velocity

  """

  uv_layer: str = ...

  """

  UV map to use for mapping with UV texture coordinates

  """

  velocity_factor: float = ...

  """

  Amount texture affects particle initial velocity

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CLIP_UL_tracking_objects(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, _icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CYCLES_RENDER_UL_aov(bpy_struct, UIList):

  def draw_item(self, context: typing.Any, layout: typing.Any, data: typing.Any, item: typing.Any, icon: typing.Any, active_data: typing.Any, active_propname: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FILEBROWSER_UL_dir(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPENCIL_UL_annotation_layer(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPENCIL_UL_layer(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPENCIL_UL_masks(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPENCIL_UL_matslots(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GPENCIL_UL_vgroups(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class HAIR_UL_attributes(bpy_struct, UIList):

  def draw_item(self, context: typing.Any, layout: typing.Any, data: typing.Any, attribute: typing.Any, icon: typing.Any, active_data: typing.Any, active_propname: typing.Any, index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IMAGE_UL_render_slots(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, _icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class IMAGE_UL_udim_tiles(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, _icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MASK_UL_layers(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MATERIAL_UL_matslots(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MESH_UL_fmaps(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MESH_UL_shape_keys(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, active_data: typing.Any, _active_propname: typing.Any, index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MESH_UL_uvmaps(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MESH_UL_vcols(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MESH_UL_vgroups(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data_: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NODE_UL_interface_sockets(bpy_struct, UIList):

  def draw_item(self, context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PARTICLE_UL_particle_systems(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any, _flt_flag: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PHYSICS_UL_dynapaint_surfaces(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class POINTCLOUD_UL_attributes(bpy_struct, UIList):

  def draw_item(self, context: typing.Any, layout: typing.Any, data: typing.Any, attribute: typing.Any, icon: typing.Any, active_data: typing.Any, active_propname: typing.Any, index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class RENDER_UL_renderviews(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SCENE_UL_keying_set_paths(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TEXTURE_UL_texpaintslots(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TEXTURE_UL_texslots(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, _index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class UI_UL_list(bpy_struct, UIList):

  @staticmethod

  def filter_items_by_name(pattern: typing.Any, bitflag: typing.Any, items: typing.Any, propname: typing.Any = 'name', flags: typing.Any = None, reverse: typing.Any = False) -> None:

    """

    Set FILTER_ITEM for items which name matches filter_name one (case-insensitive).
pattern is the filtering pattern.
propname is the name of the string property to use for filtering.
flags must be a list of integers the same length as items, or None!
return a list of flags (based on given flags if not None),
or an empty list if no flags were given and no filtering has been done.

    """

    ...

  @staticmethod

  def sort_items_helper(sort_data: typing.Any, key: typing.Any, reverse: typing.Any = False) -> None:

    """

    Common sorting utility. Returns a neworder list mapping org_idx -> new_idx.
sort_data must be an (unordered) list of tuples [(org_idx, ...), (org_idx, ...), ...].
key must be the same kind of callable you would use for sorted() builtin function.
reverse will reverse the sorting!

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VIEWLAYER_UL_linesets(bpy_struct, UIList):

  def draw_item(self, _context: typing.Any, layout: typing.Any, _data: typing.Any, item: typing.Any, icon: typing.Any, _active_data: typing.Any, _active_propname: typing.Any, index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VOLUME_UL_grids(bpy_struct, UIList):

  def draw_item(self, context: typing.Any, layout: typing.Any, data: typing.Any, grid: typing.Any, icon: typing.Any, active_data: typing.Any, active_propname: typing.Any, index: typing.Any) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SurfaceCurve(bpy_struct, Curve, ID):

  """

  Curve data-block used for storing surfaces

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextCurve(bpy_struct, Curve, ID):

  """

  Curve data-block used for storing text

  """

  active_textbox: int = ...

  align_x: str = ...

  """

  Text horizontal align from the object center

  * ``LEFT``
Left, Align text to the left.

  * ``CENTER``
Center, Center text.

  * ``RIGHT``
Right, Align text to the right.

  * ``JUSTIFY``
Justify, Align to the left and the right.

  * ``FLUSH``
Flush, Align to the left and the right, with equal character spacing.

  """

  align_y: str = ...

  """

  Text vertical align from the object center

  * ``TOP_BASELINE``
Top Base-Line, Align to top but use the base-line of the text.

  * ``TOP``
Top, Align text to the top.

  * ``CENTER``
Center, Align text to the middle.

  * ``BOTTOM``
Bottom, Align text to the bottom.

  * ``BOTTOM_BASELINE``
Bottom Base-Line, Align text to the bottom but use the base-line of the text.

  """

  body: str = ...

  """

  Content of this text object

  """

  body_format: typing.Union[typing.Sequence[TextCharacterFormat], typing.Mapping[str, TextCharacterFormat], bpy_prop_collection] = ...

  """

  Stores the style of each character

  """

  edit_format: TextCharacterFormat = ...

  """

  Editing settings character formatting

  """

  family: str = ...

  """

  Use objects as font characters (give font objects a common name followed by the character they represent, eg. 'family-a', 'family-b', etc, set this setting to 'family-', and turn on Vertex Instancing)

  """

  follow_curve: Object = ...

  """

  Curve deforming text object

  """

  font: VectorFont = ...

  font_bold: VectorFont = ...

  font_bold_italic: VectorFont = ...

  font_italic: VectorFont = ...

  offset_x: float = ...

  """

  Horizontal offset from the object origin

  """

  offset_y: float = ...

  """

  Vertical offset from the object origin

  """

  overflow: str = ...

  """

  Handle the text behavior when it doesn't fit in the text boxes

  * ``NONE``
Overflow, Let the text overflow outside the text boxes.

  * ``SCALE``
Scale to Fit, Scale down the text to fit inside the text boxes.

  * ``TRUNCATE``
Truncate, Truncate the text that would go outside the text boxes.

  """

  shear: float = ...

  """

  Italic angle of the characters

  """

  size: float = ...

  small_caps_scale: float = ...

  """

  Scale of small capitals

  """

  space_character: float = ...

  space_line: float = ...

  space_word: float = ...

  text_boxes: typing.Union[typing.Sequence[TextBox], typing.Mapping[str, TextBox], bpy_prop_collection] = ...

  underline_height: float = ...

  underline_position: float = ...

  """

  Vertical position of underline

  """

  use_fast_edit: bool = ...

  """

  Don't fill polygons while editing

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AreaLight(bpy_struct, Light, ID):

  """

  Directional area Light

  """

  constant_coefficient: float = ...

  """

  Constant distance attenuation coefficient

  """

  contact_shadow_bias: float = ...

  """

  Bias to avoid self shadowing

  """

  contact_shadow_distance: float = ...

  """

  World space distance in which to search for screen space occluder

  """

  contact_shadow_thickness: float = ...

  """

  Pixel thickness used to detect occlusion

  """

  energy: float = ...

  """

  Light energy emitted over the entire area of the light in all directions

  """

  falloff_curve: CurveMapping = ...

  """

  Custom light falloff curve

  """

  falloff_type: str = ...

  """

  Intensity Decay with distance

  """

  linear_attenuation: float = ...

  """

  Linear distance attenuation

  """

  linear_coefficient: float = ...

  """

  Linear distance attenuation coefficient

  """

  quadratic_attenuation: float = ...

  """

  Quadratic distance attenuation

  """

  quadratic_coefficient: float = ...

  """

  Quadratic distance attenuation coefficient

  """

  shadow_buffer_bias: float = ...

  """

  Bias for reducing self shadowing

  """

  shadow_buffer_clip_start: float = ...

  """

  Shadow map clip start, below which objects will not generate shadows

  """

  shadow_buffer_samples: int = ...

  """

  Number of shadow buffer samples

  """

  shadow_buffer_size: int = ...

  """

  Resolution of the shadow buffer, higher values give crisper shadows but use more memory

  """

  shadow_color: typing.Tuple[float, float, float] = ...

  """

  Color of shadows cast by the light

  """

  shadow_soft_size: float = ...

  """

  Light size for ray shadow sampling (Raytraced shadows)

  """

  shape: str = ...

  """

  Shape of the area Light

  """

  size: float = ...

  """

  Size of the area of the area light, X direction size for rectangle shapes

  """

  size_y: float = ...

  """

  Size of the area of the area light in the Y direction for rectangle shapes

  """

  use_contact_shadow: bool = ...

  """

  Use screen space raytracing to have correct shadowing near occluder, or for small features that does not appear in shadow maps

  """

  use_shadow: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class PointLight(bpy_struct, Light, ID):

  """

  Omnidirectional point Light

  """

  constant_coefficient: float = ...

  """

  Constant distance attenuation coefficient

  """

  contact_shadow_bias: float = ...

  """

  Bias to avoid self shadowing

  """

  contact_shadow_distance: float = ...

  """

  World space distance in which to search for screen space occluder

  """

  contact_shadow_thickness: float = ...

  """

  Pixel thickness used to detect occlusion

  """

  energy: float = ...

  """

  Light energy emitted over the entire area of the light in all directions

  """

  falloff_curve: CurveMapping = ...

  """

  Custom light falloff curve

  """

  falloff_type: str = ...

  """

  Intensity Decay with distance

  """

  linear_attenuation: float = ...

  """

  Linear distance attenuation

  """

  linear_coefficient: float = ...

  """

  Linear distance attenuation coefficient

  """

  quadratic_attenuation: float = ...

  """

  Quadratic distance attenuation

  """

  quadratic_coefficient: float = ...

  """

  Quadratic distance attenuation coefficient

  """

  shadow_buffer_bias: float = ...

  """

  Bias for reducing self shadowing

  """

  shadow_buffer_clip_start: float = ...

  """

  Shadow map clip start, below which objects will not generate shadows

  """

  shadow_buffer_samples: int = ...

  """

  Number of shadow buffer samples

  """

  shadow_buffer_size: int = ...

  """

  Resolution of the shadow buffer, higher values give crisper shadows but use more memory

  """

  shadow_color: typing.Tuple[float, float, float] = ...

  """

  Color of shadows cast by the light

  """

  shadow_soft_size: float = ...

  """

  Light size for ray shadow sampling (Raytraced shadows)

  """

  use_contact_shadow: bool = ...

  """

  Use screen space raytracing to have correct shadowing near occluder, or for small features that does not appear in shadow maps

  """

  use_shadow: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SpotLight(bpy_struct, Light, ID):

  """

  Directional cone Light

  """

  constant_coefficient: float = ...

  """

  Constant distance attenuation coefficient

  """

  contact_shadow_bias: float = ...

  """

  Bias to avoid self shadowing

  """

  contact_shadow_distance: float = ...

  """

  World space distance in which to search for screen space occluder

  """

  contact_shadow_thickness: float = ...

  """

  Pixel thickness used to detect occlusion

  """

  energy: float = ...

  """

  The energy this light would emit over its entire area if it wasn't limited by the spot angle

  """

  falloff_curve: CurveMapping = ...

  """

  Custom light falloff curve

  """

  falloff_type: str = ...

  """

  Intensity Decay with distance

  """

  linear_attenuation: float = ...

  """

  Linear distance attenuation

  """

  linear_coefficient: float = ...

  """

  Linear distance attenuation coefficient

  """

  quadratic_attenuation: float = ...

  """

  Quadratic distance attenuation

  """

  quadratic_coefficient: float = ...

  """

  Quadratic distance attenuation coefficient

  """

  shadow_buffer_bias: float = ...

  """

  Bias for reducing self shadowing

  """

  shadow_buffer_clip_start: float = ...

  """

  Shadow map clip start, below which objects will not generate shadows

  """

  shadow_buffer_samples: int = ...

  """

  Number of shadow buffer samples

  """

  shadow_buffer_size: int = ...

  """

  Resolution of the shadow buffer, higher values give crisper shadows but use more memory

  """

  shadow_color: typing.Tuple[float, float, float] = ...

  """

  Color of shadows cast by the light

  """

  shadow_soft_size: float = ...

  """

  Light size for ray shadow sampling (Raytraced shadows)

  """

  show_cone: bool = ...

  """

  Draw transparent cone in 3D view to visualize which objects are contained in it

  """

  spot_blend: float = ...

  """

  The softness of the spotlight edge

  """

  spot_size: float = ...

  """

  Angle of the spotlight beam

  """

  use_contact_shadow: bool = ...

  """

  Use screen space raytracing to have correct shadowing near occluder, or for small features that does not appear in shadow maps

  """

  use_shadow: bool = ...

  use_square: bool = ...

  """

  Cast a square spot light shape

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SunLight(bpy_struct, Light, ID):

  """

  Constant direction parallel ray Light

  """

  angle: float = ...

  """

  Angular diameter of the Sun as seen from the Earth

  """

  contact_shadow_bias: float = ...

  """

  Bias to avoid self shadowing

  """

  contact_shadow_distance: float = ...

  """

  World space distance in which to search for screen space occluder

  """

  contact_shadow_thickness: float = ...

  """

  Pixel thickness used to detect occlusion

  """

  energy: float = ...

  """

  Sunlight strength in watts per meter squared (W/m^2)

  """

  shadow_buffer_bias: float = ...

  """

  Bias for reducing self shadowing

  """

  shadow_buffer_clip_start: float = ...

  """

  Shadow map clip start, below which objects will not generate shadows

  """

  shadow_buffer_samples: int = ...

  """

  Number of shadow buffer samples

  """

  shadow_buffer_size: int = ...

  """

  Resolution of the shadow buffer, higher values give crisper shadows but use more memory

  """

  shadow_cascade_count: int = ...

  """

  Number of texture used by the cascaded shadow map

  """

  shadow_cascade_exponent: float = ...

  """

  Higher value increase resolution towards the viewpoint

  """

  shadow_cascade_fade: float = ...

  """

  How smooth is the transition between each cascade

  """

  shadow_cascade_max_distance: float = ...

  """

  End distance of the cascaded shadow map (only in perspective view)

  """

  shadow_color: typing.Tuple[float, float, float] = ...

  """

  Color of shadows cast by the light

  """

  shadow_soft_size: float = ...

  """

  Light size for ray shadow sampling (Raytraced shadows)

  """

  use_contact_shadow: bool = ...

  """

  Use screen space raytracing to have correct shadowing near occluder, or for small features that does not appear in shadow maps

  """

  use_shadow: bool = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeTree(bpy_struct, ID, NodeTree):

  """

  Node tree consisting of linked nodes used for compositing

  """

  chunk_size: str = ...

  """

  Max size of a tile (smaller values gives better distribution of multiple threads, but more overhead)

  * ``32``
32x32, Chunksize of 32x32.

  * ``64``
64x64, Chunksize of 64x64.

  * ``128``
128x128, Chunksize of 128x128.

  * ``256``
256x256, Chunksize of 256x256.

  * ``512``
512x512, Chunksize of 512x512.

  * ``1024``
1024x1024, Chunksize of 1024x1024.

  """

  edit_quality: str = ...

  """

  Quality when editing

  * ``HIGH``
High, High quality.

  * ``MEDIUM``
Medium, Medium quality.

  * ``LOW``
Low, Low quality.

  """

  render_quality: str = ...

  """

  Quality when rendering

  * ``HIGH``
High, High quality.

  * ``MEDIUM``
Medium, Medium quality.

  * ``LOW``
Low, Low quality.

  """

  use_groupnode_buffer: bool = ...

  """

  Enable buffering of group nodes

  """

  use_opencl: bool = ...

  """

  Enable GPU calculations

  """

  use_two_pass: bool = ...

  """

  Use two pass execution during editing: first calculate fast nodes, second pass calculate all nodes

  """

  use_viewer_border: bool = ...

  """

  Use boundaries for viewer nodes and composite backdrop

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTree(bpy_struct, ID, NodeTree):

  """

  Node tree consisting of linked nodes used for materials (and other shading data-blocks)

  """

  def get_output_node(self, target: str) -> ShaderNode:

    """

    Return active shader output node for the specified target

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SimulationNodeTree(bpy_struct, ID, NodeTree):

  """

  Node tree consisting of linked nodes used for simulations

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTree(bpy_struct, ID, NodeTree):

  """

  Node tree consisting of linked nodes used for textures

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class BlendTexture(bpy_struct, ID, Texture):

  """

  Procedural color blending texture

  """

  progression: str = ...

  """

  Style of the color blending

  * ``LINEAR``
Linear, Create a linear progression.

  * ``QUADRATIC``
Quadratic, Create a quadratic progression.

  * ``EASING``
Easing, Create a progression easing from one step to the next.

  * ``DIAGONAL``
Diagonal, Create a diagonal progression.

  * ``SPHERICAL``
Spherical, Create a spherical progression.

  * ``QUADRATIC_SPHERE``
Quadratic sphere, Create a quadratic progression in the shape of a sphere.

  * ``RADIAL``
Radial, Create a radial progression.

  """

  use_flip_axis: str = ...

  """

  Flip the texture's X and Y axis

  * ``HORIZONTAL``
Horizontal, No flipping.

  * ``VERTICAL``
Vertical, Flip the texture's X and Y axis.

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CloudsTexture(bpy_struct, ID, Texture):

  """

  Procedural noise texture

  """

  cloud_type: str = ...

  """

  Determine whether Noise returns grayscale or RGB values

  """

  nabla: float = ...

  """

  Size of derivative offset used for calculating normal

  """

  noise_basis: str = ...

  """

  Noise basis used for turbulence

  * ``BLENDER_ORIGINAL``
Blender Original, Noise algorithm - Blender original: Smooth interpolated noise.

  * ``ORIGINAL_PERLIN``
Original Perlin, Noise algorithm - Original Perlin: Smooth interpolated noise.

  * ``IMPROVED_PERLIN``
Improved Perlin, Noise algorithm - Improved Perlin: Smooth interpolated noise.

  * ``VORONOI_F1``
Voronoi F1, Noise algorithm - Voronoi F1: Returns distance to the closest feature point.

  * ``VORONOI_F2``
Voronoi F2, Noise algorithm - Voronoi F2: Returns distance to the 2nd closest feature point.

  * ``VORONOI_F3``
Voronoi F3, Noise algorithm - Voronoi F3: Returns distance to the 3rd closest feature point.

  * ``VORONOI_F4``
Voronoi F4, Noise algorithm - Voronoi F4: Returns distance to the 4th closest feature point.

  * ``VORONOI_F2_F1``
Voronoi F2-F1, Noise algorithm - Voronoi F1-F2.

  * ``VORONOI_CRACKLE``
Voronoi Crackle, Noise algorithm - Voronoi Crackle: Voronoi tessellation with sharp edges.

  * ``CELL_NOISE``
Cell Noise, Noise algorithm - Cell Noise: Square cell tessellation.

  """

  noise_depth: int = ...

  """

  Depth of the cloud calculation

  """

  noise_scale: float = ...

  """

  Scaling for noise input

  """

  noise_type: str = ...

  """

  * ``SOFT_NOISE``
Soft, Generate soft noise (smooth transitions).

  * ``HARD_NOISE``
Hard, Generate hard noise (sharp transitions).

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class DistortedNoiseTexture(bpy_struct, ID, Texture):

  """

  Procedural distorted noise texture

  """

  distortion: float = ...

  """

  Amount of distortion

  """

  nabla: float = ...

  """

  Size of derivative offset used for calculating normal

  """

  noise_basis: str = ...

  """

  Noise basis used for turbulence

  * ``BLENDER_ORIGINAL``
Blender Original, Noise algorithm - Blender original: Smooth interpolated noise.

  * ``ORIGINAL_PERLIN``
Original Perlin, Noise algorithm - Original Perlin: Smooth interpolated noise.

  * ``IMPROVED_PERLIN``
Improved Perlin, Noise algorithm - Improved Perlin: Smooth interpolated noise.

  * ``VORONOI_F1``
Voronoi F1, Noise algorithm - Voronoi F1: Returns distance to the closest feature point.

  * ``VORONOI_F2``
Voronoi F2, Noise algorithm - Voronoi F2: Returns distance to the 2nd closest feature point.

  * ``VORONOI_F3``
Voronoi F3, Noise algorithm - Voronoi F3: Returns distance to the 3rd closest feature point.

  * ``VORONOI_F4``
Voronoi F4, Noise algorithm - Voronoi F4: Returns distance to the 4th closest feature point.

  * ``VORONOI_F2_F1``
Voronoi F2-F1, Noise algorithm - Voronoi F1-F2.

  * ``VORONOI_CRACKLE``
Voronoi Crackle, Noise algorithm - Voronoi Crackle: Voronoi tessellation with sharp edges.

  * ``CELL_NOISE``
Cell Noise, Noise algorithm - Cell Noise: Square cell tessellation.

  """

  noise_distortion: str = ...

  """

  Noise basis for the distortion

  * ``BLENDER_ORIGINAL``
Blender Original, Noise algorithm - Blender original: Smooth interpolated noise.

  * ``ORIGINAL_PERLIN``
Original Perlin, Noise algorithm - Original Perlin: Smooth interpolated noise.

  * ``IMPROVED_PERLIN``
Improved Perlin, Noise algorithm - Improved Perlin: Smooth interpolated noise.

  * ``VORONOI_F1``
Voronoi F1, Noise algorithm - Voronoi F1: Returns distance to the closest feature point.

  * ``VORONOI_F2``
Voronoi F2, Noise algorithm - Voronoi F2: Returns distance to the 2nd closest feature point.

  * ``VORONOI_F3``
Voronoi F3, Noise algorithm - Voronoi F3: Returns distance to the 3rd closest feature point.

  * ``VORONOI_F4``
Voronoi F4, Noise algorithm - Voronoi F4: Returns distance to the 4th closest feature point.

  * ``VORONOI_F2_F1``
Voronoi F2-F1, Noise algorithm - Voronoi F1-F2.

  * ``VORONOI_CRACKLE``
Voronoi Crackle, Noise algorithm - Voronoi Crackle: Voronoi tessellation with sharp edges.

  * ``CELL_NOISE``
Cell Noise, Noise algorithm - Cell Noise: Square cell tessellation.

  """

  noise_scale: float = ...

  """

  Scaling for noise input

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ImageTexture(bpy_struct, ID, Texture):

  checker_distance: float = ...

  """

  Distance between checker tiles

  """

  crop_max_x: float = ...

  """

  Maximum X value to crop the image

  """

  crop_max_y: float = ...

  """

  Maximum Y value to crop the image

  """

  crop_min_x: float = ...

  """

  Minimum X value to crop the image

  """

  crop_min_y: float = ...

  """

  Minimum Y value to crop the image

  """

  extension: str = ...

  """

  How the image is extrapolated past its original bounds

  * ``EXTEND``
Extend, Extend by repeating edge pixels of the image.

  * ``CLIP``
Clip, Clip to image size and set exterior pixels as transparent.

  * ``CLIP_CUBE``
Clip Cube, Clip to cubic-shaped area around the image and set exterior pixels as transparent.

  * ``REPEAT``
Repeat, Cause the image to repeat horizontally and vertically.

  * ``CHECKER``
Checker, Cause the image to repeat in checker board pattern.

  """

  filter_eccentricity: int = ...

  """

  Maximum eccentricity (higher gives less blur at distant/oblique angles, but is also slower)

  """

  filter_lightprobes: int = ...

  """

  Maximum number of samples (higher gives less blur at distant/oblique angles, but is also slower)

  """

  filter_size: float = ...

  """

  Multiply the filter size used by MIP Map and Interpolation

  """

  filter_type: str = ...

  """

  Texture filter to use for sampling image

  """

  image: Image = ...

  image_user: ImageUser = ...

  """

  Parameters defining which layer, pass and frame of the image is displayed

  """

  invert_alpha: bool = ...

  """

  Invert all the alpha values in the image

  """

  repeat_x: int = ...

  """

  Repetition multiplier in the X direction

  """

  repeat_y: int = ...

  """

  Repetition multiplier in the Y direction

  """

  use_alpha: bool = ...

  """

  Use the alpha channel information in the image

  """

  use_calculate_alpha: bool = ...

  """

  Calculate an alpha channel based on RGB values in the image

  """

  use_checker_even: bool = ...

  """

  Even checker tiles

  """

  use_checker_odd: bool = ...

  """

  Odd checker tiles

  """

  use_filter_size_min: bool = ...

  """

  Use Filter Size as a minimal filter value in pixels

  """

  use_flip_axis: bool = ...

  """

  Flip the texture's X and Y axis

  """

  use_interpolation: bool = ...

  """

  Interpolate pixels using selected filter

  """

  use_mipmap: bool = ...

  """

  Use auto-generated MIP maps for the image

  """

  use_mipmap_gauss: bool = ...

  """

  Use Gauss filter to sample down MIP maps

  """

  use_mirror_x: bool = ...

  """

  Mirror the image repetition on the X direction

  """

  use_mirror_y: bool = ...

  """

  Mirror the image repetition on the Y direction

  """

  use_normal_map: bool = ...

  """

  Use image RGB values for normal mapping

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MagicTexture(bpy_struct, ID, Texture):

  """

  Procedural noise texture

  """

  noise_depth: int = ...

  """

  Depth of the noise

  """

  turbulence: float = ...

  """

  Turbulence of the noise

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MarbleTexture(bpy_struct, ID, Texture):

  """

  Procedural noise texture

  """

  marble_type: str = ...

  """

  * ``SOFT``
Soft, Use soft marble.

  * ``SHARP``
Sharp, Use more clearly defined marble.

  * ``SHARPER``
Sharper, Use very clearly defined marble.

  """

  nabla: float = ...

  """

  Size of derivative offset used for calculating normal

  """

  noise_basis: str = ...

  """

  Noise basis used for turbulence

  * ``BLENDER_ORIGINAL``
Blender Original, Noise algorithm - Blender original: Smooth interpolated noise.

  * ``ORIGINAL_PERLIN``
Original Perlin, Noise algorithm - Original Perlin: Smooth interpolated noise.

  * ``IMPROVED_PERLIN``
Improved Perlin, Noise algorithm - Improved Perlin: Smooth interpolated noise.

  * ``VORONOI_F1``
Voronoi F1, Noise algorithm - Voronoi F1: Returns distance to the closest feature point.

  * ``VORONOI_F2``
Voronoi F2, Noise algorithm - Voronoi F2: Returns distance to the 2nd closest feature point.

  * ``VORONOI_F3``
Voronoi F3, Noise algorithm - Voronoi F3: Returns distance to the 3rd closest feature point.

  * ``VORONOI_F4``
Voronoi F4, Noise algorithm - Voronoi F4: Returns distance to the 4th closest feature point.

  * ``VORONOI_F2_F1``
Voronoi F2-F1, Noise algorithm - Voronoi F1-F2.

  * ``VORONOI_CRACKLE``
Voronoi Crackle, Noise algorithm - Voronoi Crackle: Voronoi tessellation with sharp edges.

  * ``CELL_NOISE``
Cell Noise, Noise algorithm - Cell Noise: Square cell tessellation.

  """

  noise_basis_2: str = ...

  """

  * ``SIN``
Sin, Use a sine wave to produce bands.

  * ``SAW``
Saw, Use a saw wave to produce bands.

  * ``TRI``
Tri, Use a triangle wave to produce bands.

  """

  noise_depth: int = ...

  """

  Depth of the cloud calculation

  """

  noise_scale: float = ...

  """

  Scaling for noise input

  """

  noise_type: str = ...

  """

  * ``SOFT_NOISE``
Soft, Generate soft noise (smooth transitions).

  * ``HARD_NOISE``
Hard, Generate hard noise (sharp transitions).

  """

  turbulence: float = ...

  """

  Turbulence of the bandnoise and ringnoise types

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MusgraveTexture(bpy_struct, ID, Texture):

  """

  Procedural musgrave texture

  """

  dimension_max: float = ...

  """

  Highest fractal dimension

  """

  gain: float = ...

  """

  The gain multiplier

  """

  lacunarity: float = ...

  """

  Gap between successive frequencies

  """

  musgrave_type: str = ...

  """

  Fractal noise algorithm

  * ``MULTIFRACTAL``
Multifractal, Use Perlin noise as a basis.

  * ``RIDGED_MULTIFRACTAL``
Ridged Multifractal, Use Perlin noise with inflection as a basis.

  * ``HYBRID_MULTIFRACTAL``
Hybrid Multifractal, Use Perlin noise as a basis, with extended controls.

  * ``FBM``
fBM, Fractal Brownian Motion, use Brownian noise as a basis.

  * ``HETERO_TERRAIN``
Hetero Terrain, Similar to multifractal.

  """

  nabla: float = ...

  """

  Size of derivative offset used for calculating normal

  """

  noise_basis: str = ...

  """

  Noise basis used for turbulence

  * ``BLENDER_ORIGINAL``
Blender Original, Noise algorithm - Blender original: Smooth interpolated noise.

  * ``ORIGINAL_PERLIN``
Original Perlin, Noise algorithm - Original Perlin: Smooth interpolated noise.

  * ``IMPROVED_PERLIN``
Improved Perlin, Noise algorithm - Improved Perlin: Smooth interpolated noise.

  * ``VORONOI_F1``
Voronoi F1, Noise algorithm - Voronoi F1: Returns distance to the closest feature point.

  * ``VORONOI_F2``
Voronoi F2, Noise algorithm - Voronoi F2: Returns distance to the 2nd closest feature point.

  * ``VORONOI_F3``
Voronoi F3, Noise algorithm - Voronoi F3: Returns distance to the 3rd closest feature point.

  * ``VORONOI_F4``
Voronoi F4, Noise algorithm - Voronoi F4: Returns distance to the 4th closest feature point.

  * ``VORONOI_F2_F1``
Voronoi F2-F1, Noise algorithm - Voronoi F1-F2.

  * ``VORONOI_CRACKLE``
Voronoi Crackle, Noise algorithm - Voronoi Crackle: Voronoi tessellation with sharp edges.

  * ``CELL_NOISE``
Cell Noise, Noise algorithm - Cell Noise: Square cell tessellation.

  """

  noise_intensity: float = ...

  """

  Intensity of the noise

  """

  noise_scale: float = ...

  """

  Scaling for noise input

  """

  octaves: float = ...

  """

  Number of frequencies used

  """

  offset: float = ...

  """

  The fractal offset

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NoiseTexture(bpy_struct, ID, Texture):

  """

  Procedural noise texture

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class StucciTexture(bpy_struct, ID, Texture):

  """

  Procedural noise texture

  """

  noise_basis: str = ...

  """

  Noise basis used for turbulence

  * ``BLENDER_ORIGINAL``
Blender Original, Noise algorithm - Blender original: Smooth interpolated noise.

  * ``ORIGINAL_PERLIN``
Original Perlin, Noise algorithm - Original Perlin: Smooth interpolated noise.

  * ``IMPROVED_PERLIN``
Improved Perlin, Noise algorithm - Improved Perlin: Smooth interpolated noise.

  * ``VORONOI_F1``
Voronoi F1, Noise algorithm - Voronoi F1: Returns distance to the closest feature point.

  * ``VORONOI_F2``
Voronoi F2, Noise algorithm - Voronoi F2: Returns distance to the 2nd closest feature point.

  * ``VORONOI_F3``
Voronoi F3, Noise algorithm - Voronoi F3: Returns distance to the 3rd closest feature point.

  * ``VORONOI_F4``
Voronoi F4, Noise algorithm - Voronoi F4: Returns distance to the 4th closest feature point.

  * ``VORONOI_F2_F1``
Voronoi F2-F1, Noise algorithm - Voronoi F1-F2.

  * ``VORONOI_CRACKLE``
Voronoi Crackle, Noise algorithm - Voronoi Crackle: Voronoi tessellation with sharp edges.

  * ``CELL_NOISE``
Cell Noise, Noise algorithm - Cell Noise: Square cell tessellation.

  """

  noise_scale: float = ...

  """

  Scaling for noise input

  """

  noise_type: str = ...

  """

  * ``SOFT_NOISE``
Soft, Generate soft noise (smooth transitions).

  * ``HARD_NOISE``
Hard, Generate hard noise (sharp transitions).

  """

  stucci_type: str = ...

  """

  * ``PLASTIC``
Plastic, Use standard stucci.

  * ``WALL_IN``
Wall in, Create Dimples.

  * ``WALL_OUT``
Wall out, Create Ridges.

  """

  turbulence: float = ...

  """

  Turbulence of the noise

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class VoronoiTexture(bpy_struct, ID, Texture):

  """

  Procedural voronoi texture

  """

  color_mode: str = ...

  """

  * ``INTENSITY``
Intensity, Only calculate intensity.

  * ``POSITION``
Position, Color cells by position.

  * ``POSITION_OUTLINE``
Position and Outline, Use position plus an outline based on F2-F1.

  * ``POSITION_OUTLINE_INTENSITY``
Position, Outline, and Intensity, Multiply position and outline by intensity.

  """

  distance_metric: str = ...

  """

  Algorithm used to calculate distance of sample points to feature points

  * ``DISTANCE``
Actual Distance, sqrt(x*x+y*y+z*z).

  * ``DISTANCE_SQUARED``
Distance Squared, (x*x+y*y+z*z).

  * ``MANHATTAN``
Manhattan, The length of the distance in axial directions.

  * ``CHEBYCHEV``
Chebychev, The length of the longest Axial journey.

  * ``MINKOVSKY_HALF``
Minkowski 1/2, Set Minkowski variable to 0.5.

  * ``MINKOVSKY_FOUR``
Minkowski 4, Set Minkowski variable to 4.

  * ``MINKOVSKY``
Minkowski, Use the Minkowski function to calculate distance (exponent value determines the shape of the boundaries).

  """

  minkovsky_exponent: float = ...

  """

  Minkowski exponent

  """

  nabla: float = ...

  """

  Size of derivative offset used for calculating normal

  """

  noise_intensity: float = ...

  """

  Scales the intensity of the noise

  """

  noise_scale: float = ...

  """

  Scaling for noise input

  """

  weight_1: float = ...

  """

  Voronoi feature weight 1

  """

  weight_2: float = ...

  """

  Voronoi feature weight 2

  """

  weight_3: float = ...

  """

  Voronoi feature weight 3

  """

  weight_4: float = ...

  """

  Voronoi feature weight 4

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WoodTexture(bpy_struct, ID, Texture):

  """

  Procedural noise texture

  """

  nabla: float = ...

  """

  Size of derivative offset used for calculating normal

  """

  noise_basis: str = ...

  """

  Noise basis used for turbulence

  * ``BLENDER_ORIGINAL``
Blender Original, Noise algorithm - Blender original: Smooth interpolated noise.

  * ``ORIGINAL_PERLIN``
Original Perlin, Noise algorithm - Original Perlin: Smooth interpolated noise.

  * ``IMPROVED_PERLIN``
Improved Perlin, Noise algorithm - Improved Perlin: Smooth interpolated noise.

  * ``VORONOI_F1``
Voronoi F1, Noise algorithm - Voronoi F1: Returns distance to the closest feature point.

  * ``VORONOI_F2``
Voronoi F2, Noise algorithm - Voronoi F2: Returns distance to the 2nd closest feature point.

  * ``VORONOI_F3``
Voronoi F3, Noise algorithm - Voronoi F3: Returns distance to the 3rd closest feature point.

  * ``VORONOI_F4``
Voronoi F4, Noise algorithm - Voronoi F4: Returns distance to the 4th closest feature point.

  * ``VORONOI_F2_F1``
Voronoi F2-F1, Noise algorithm - Voronoi F1-F2.

  * ``VORONOI_CRACKLE``
Voronoi Crackle, Noise algorithm - Voronoi Crackle: Voronoi tessellation with sharp edges.

  * ``CELL_NOISE``
Cell Noise, Noise algorithm - Cell Noise: Square cell tessellation.

  """

  noise_basis_2: str = ...

  """

  * ``SIN``
Sine, Use a sine wave to produce bands.

  * ``SAW``
Saw, Use a saw wave to produce bands.

  * ``TRI``
Tri, Use a triangle wave to produce bands.

  """

  noise_scale: float = ...

  """

  Scaling for noise input

  """

  noise_type: str = ...

  """

  * ``SOFT_NOISE``
Soft, Generate soft noise (smooth transitions).

  * ``HARD_NOISE``
Hard, Generate hard noise (sharp transitions).

  """

  turbulence: float = ...

  """

  Turbulence of the bandnoise and ringnoise types

  """

  wood_type: str = ...

  """

  * ``BANDS``
Bands, Use standard wood texture in bands.

  * ``RINGS``
Rings, Use wood texture in rings.

  * ``BANDNOISE``
Band Noise, Add noise to standard wood.

  * ``RINGNOISE``
Ring Noise, Add noise to rings.

  """

  users_material: typing.Any = ...

  """

  Materials that use this texture

  (readonly)

  """

  users_object_modifier: typing.Any = ...

  """

  Object modifiers that use this texture

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleAlphaModifier_AlongStroke(bpy_struct, LineStyleModifier, LineStyleAlphaModifier):

  """

  Change alpha transparency along stroke

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleAlphaModifier_CreaseAngle(bpy_struct, LineStyleModifier, LineStyleAlphaModifier):

  """

  Alpha transparency based on the angle between two adjacent faces

  """

  angle_max: float = ...

  """

  Maximum angle to modify thickness

  """

  angle_min: float = ...

  """

  Minimum angle to modify thickness

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleAlphaModifier_Curvature_3D(bpy_struct, LineStyleModifier, LineStyleAlphaModifier):

  """

  Alpha transparency based on the radial curvature of 3D mesh surfaces

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curvature_max: float = ...

  """

  Maximum Curvature

  """

  curvature_min: float = ...

  """

  Minimum Curvature

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleAlphaModifier_DistanceFromCamera(bpy_struct, LineStyleModifier, LineStyleAlphaModifier):

  """

  Change alpha transparency based on the distance from the camera

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  range_max: float = ...

  """

  Upper bound of the input range the mapping is applied

  """

  range_min: float = ...

  """

  Lower bound of the input range the mapping is applied

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleAlphaModifier_DistanceFromObject(bpy_struct, LineStyleModifier, LineStyleAlphaModifier):

  """

  Change alpha transparency based on the distance from an object

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  range_max: float = ...

  """

  Upper bound of the input range the mapping is applied

  """

  range_min: float = ...

  """

  Lower bound of the input range the mapping is applied

  """

  target: Object = ...

  """

  Target object from which the distance is measured

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleAlphaModifier_Material(bpy_struct, LineStyleModifier, LineStyleAlphaModifier):

  """

  Change alpha transparency based on a material attribute

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  material_attribute: str = ...

  """

  Specify which material attribute is used

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleAlphaModifier_Noise(bpy_struct, LineStyleModifier, LineStyleAlphaModifier):

  """

  Alpha transparency based on random noise

  """

  amplitude: float = ...

  """

  Amplitude of the noise

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  period: float = ...

  """

  Period of the noise

  """

  seed: int = ...

  """

  Seed for the noise generation

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleAlphaModifier_Tangent(bpy_struct, LineStyleModifier, LineStyleAlphaModifier):

  """

  Alpha transparency based on the direction of the stroke

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleColorModifier_AlongStroke(bpy_struct, LineStyleModifier, LineStyleColorModifier):

  """

  Change line color along stroke

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  color_ramp: ColorRamp = ...

  """

  Color ramp used to change line color

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleColorModifier_CreaseAngle(bpy_struct, LineStyleModifier, LineStyleColorModifier):

  """

  Change line color based on the underlying crease angle

  """

  angle_max: float = ...

  """

  Maximum angle to modify thickness

  """

  angle_min: float = ...

  """

  Minimum angle to modify thickness

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  color_ramp: ColorRamp = ...

  """

  Color ramp used to change line color

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleColorModifier_Curvature_3D(bpy_struct, LineStyleModifier, LineStyleColorModifier):

  """

  Change line color based on the radial curvature of 3D mesh surfaces

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  color_ramp: ColorRamp = ...

  """

  Color ramp used to change line color

  """

  curvature_max: float = ...

  """

  Maximum Curvature

  """

  curvature_min: float = ...

  """

  Minimum Curvature

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleColorModifier_DistanceFromCamera(bpy_struct, LineStyleModifier, LineStyleColorModifier):

  """

  Change line color based on the distance from the camera

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  color_ramp: ColorRamp = ...

  """

  Color ramp used to change line color

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  name: str = ...

  """

  Name of the modifier

  """

  range_max: float = ...

  """

  Upper bound of the input range the mapping is applied

  """

  range_min: float = ...

  """

  Lower bound of the input range the mapping is applied

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleColorModifier_DistanceFromObject(bpy_struct, LineStyleModifier, LineStyleColorModifier):

  """

  Change line color based on the distance from an object

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  color_ramp: ColorRamp = ...

  """

  Color ramp used to change line color

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  name: str = ...

  """

  Name of the modifier

  """

  range_max: float = ...

  """

  Upper bound of the input range the mapping is applied

  """

  range_min: float = ...

  """

  Lower bound of the input range the mapping is applied

  """

  target: Object = ...

  """

  Target object from which the distance is measured

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleColorModifier_Material(bpy_struct, LineStyleModifier, LineStyleColorModifier):

  """

  Change line color based on a material attribute

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  color_ramp: ColorRamp = ...

  """

  Color ramp used to change line color

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  material_attribute: str = ...

  """

  Specify which material attribute is used

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  use_ramp: bool = ...

  """

  Use color ramp to map the BW average into an RGB color

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleColorModifier_Noise(bpy_struct, LineStyleModifier, LineStyleColorModifier):

  """

  Change line color based on random noise

  """

  amplitude: float = ...

  """

  Amplitude of the noise

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  color_ramp: ColorRamp = ...

  """

  Color ramp used to change line color

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  name: str = ...

  """

  Name of the modifier

  """

  period: float = ...

  """

  Period of the noise

  """

  seed: int = ...

  """

  Seed for the noise generation

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleColorModifier_Tangent(bpy_struct, LineStyleModifier, LineStyleColorModifier):

  """

  Change line color based on the direction of a stroke

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  color_ramp: ColorRamp = ...

  """

  Color ramp used to change line color

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_2DOffset(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Add two-dimensional offsets to stroke backbone geometry

  """

  end: float = ...

  """

  Displacement that is applied from the end of the stroke

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  start: float = ...

  """

  Displacement that is applied from the beginning of the stroke

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  x: float = ...

  """

  Displacement that is applied to the X coordinates of stroke vertices

  """

  y: float = ...

  """

  Displacement that is applied to the Y coordinates of stroke vertices

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_2DTransform(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Apply two-dimensional scaling and rotation to stroke backbone geometry

  """

  angle: float = ...

  """

  Rotation angle

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  pivot: str = ...

  """

  Pivot of scaling and rotation operations

  """

  pivot_u: float = ...

  """

  Pivot in terms of the stroke point parameter u (0 <= u <= 1)

  """

  pivot_x: float = ...

  """

  2D X coordinate of the absolute pivot

  """

  pivot_y: float = ...

  """

  2D Y coordinate of the absolute pivot

  """

  scale_x: float = ...

  """

  Scaling factor that is applied along the X axis

  """

  scale_y: float = ...

  """

  Scaling factor that is applied along the Y axis

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_BackboneStretcher(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Stretch the beginning and the end of stroke backbone

  """

  backbone_length: float = ...

  """

  Amount of backbone stretching

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_BezierCurve(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Replace stroke backbone geometry by a Bezier curve approximation of the original backbone geometry

  """

  error: float = ...

  """

  Maximum distance allowed between the new Bezier curve and the original backbone geometry

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_Blueprint(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Produce a blueprint using circular, elliptic, and square contour strokes

  """

  backbone_length: float = ...

  """

  Amount of backbone stretching

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  random_backbone: int = ...

  """

  Randomness of the backbone stretching

  """

  random_center: int = ...

  """

  Randomness of the center

  """

  random_radius: int = ...

  """

  Randomness of the radius

  """

  rounds: int = ...

  """

  Number of rounds in contour strokes

  """

  shape: str = ...

  """

  Select the shape of blueprint contour strokes

  * ``CIRCLES``
Circles, Draw a blueprint using circular contour strokes.

  * ``ELLIPSES``
Ellipses, Draw a blueprint using elliptic contour strokes.

  * ``SQUARES``
Squares, Draw a blueprint using square contour strokes.

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_GuidingLines(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Modify the stroke geometry so that it corresponds to its main direction line

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  offset: float = ...

  """

  Displacement that is applied to the main direction line along its normal

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_PerlinNoise1D(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Add one-dimensional Perlin noise to stroke backbone geometry

  """

  amplitude: float = ...

  """

  Amplitude of the Perlin noise

  """

  angle: float = ...

  """

  Displacement direction

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  frequency: float = ...

  """

  Frequency of the Perlin noise

  """

  name: str = ...

  """

  Name of the modifier

  """

  octaves: int = ...

  """

  Number of octaves (i.e., the amount of detail of the Perlin noise)

  """

  seed: int = ...

  """

  Seed for random number generation (if negative, time is used as a seed instead)

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_PerlinNoise2D(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Add two-dimensional Perlin noise to stroke backbone geometry

  """

  amplitude: float = ...

  """

  Amplitude of the Perlin noise

  """

  angle: float = ...

  """

  Displacement direction

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  frequency: float = ...

  """

  Frequency of the Perlin noise

  """

  name: str = ...

  """

  Name of the modifier

  """

  octaves: int = ...

  """

  Number of octaves (i.e., the amount of detail of the Perlin noise)

  """

  seed: int = ...

  """

  Seed for random number generation (if negative, time is used as a seed instead)

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_Polygonalization(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Modify the stroke geometry so that it looks more 'polygonal'

  """

  error: float = ...

  """

  Maximum distance between the original stroke and its polygonal approximation

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_Sampling(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Specify a new sampling value that determines the resolution of stroke polylines

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  sampling: float = ...

  """

  New sampling value to be used for subsequent modifiers

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_Simplification(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Simplify the stroke set

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  tolerance: float = ...

  """

  Distance below which segments will be merged

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_SinusDisplacement(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Add sinus displacement to stroke backbone geometry

  """

  amplitude: float = ...

  """

  Amplitude of the sinus displacement

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  phase: float = ...

  """

  Phase of the sinus displacement

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  wavelength: float = ...

  """

  Wavelength of the sinus displacement

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_SpatialNoise(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Add spatial noise to stroke backbone geometry

  """

  amplitude: float = ...

  """

  Amplitude of the spatial noise

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  octaves: int = ...

  """

  Number of octaves (i.e., the amount of detail of the spatial noise)

  """

  scale: float = ...

  """

  Scale of the spatial noise

  """

  smooth: bool = ...

  """

  If true, the spatial noise is smooth

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  use_pure_random: bool = ...

  """

  If true, the spatial noise does not show any coherence

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleGeometryModifier_TipRemover(bpy_struct, LineStyleModifier, LineStyleGeometryModifier):

  """

  Remove a piece of stroke at the beginning and the end of stroke backbone

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  name: str = ...

  """

  Name of the modifier

  """

  tip_length: float = ...

  """

  Length of tips to be removed

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifier_AlongStroke(bpy_struct, LineStyleModifier, LineStyleThicknessModifier):

  """

  Change line thickness along stroke

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  value_max: float = ...

  """

  Maximum output value of the mapping

  """

  value_min: float = ...

  """

  Minimum output value of the mapping

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifier_Calligraphy(bpy_struct, LineStyleModifier, LineStyleThicknessModifier):

  """

  Change line thickness so that stroke looks like made with a calligraphic pen

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  name: str = ...

  """

  Name of the modifier

  """

  orientation: float = ...

  """

  Angle of the main direction

  """

  thickness_max: float = ...

  """

  Maximum thickness in the main direction

  """

  thickness_min: float = ...

  """

  Minimum thickness in the direction perpendicular to the main direction

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifier_CreaseAngle(bpy_struct, LineStyleModifier, LineStyleThicknessModifier):

  """

  Line thickness based on the angle between two adjacent faces

  """

  angle_max: float = ...

  """

  Maximum angle to modify thickness

  """

  angle_min: float = ...

  """

  Minimum angle to modify thickness

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  thickness_max: float = ...

  """

  Maximum thickness

  """

  thickness_min: float = ...

  """

  Minimum thickness

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifier_Curvature_3D(bpy_struct, LineStyleModifier, LineStyleThicknessModifier):

  """

  Line thickness based on the radial curvature of 3D mesh surfaces

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curvature_max: float = ...

  """

  Maximum Curvature

  """

  curvature_min: float = ...

  """

  Minimum Curvature

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  thickness_max: float = ...

  """

  Maximum thickness

  """

  thickness_min: float = ...

  """

  Minimum thickness

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifier_DistanceFromCamera(bpy_struct, LineStyleModifier, LineStyleThicknessModifier):

  """

  Change line thickness based on the distance from the camera

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  range_max: float = ...

  """

  Upper bound of the input range the mapping is applied

  """

  range_min: float = ...

  """

  Lower bound of the input range the mapping is applied

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  value_max: float = ...

  """

  Maximum output value of the mapping

  """

  value_min: float = ...

  """

  Minimum output value of the mapping

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifier_DistanceFromObject(bpy_struct, LineStyleModifier, LineStyleThicknessModifier):

  """

  Change line thickness based on the distance from an object

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  range_max: float = ...

  """

  Upper bound of the input range the mapping is applied

  """

  range_min: float = ...

  """

  Lower bound of the input range the mapping is applied

  """

  target: Object = ...

  """

  Target object from which the distance is measured

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  value_max: float = ...

  """

  Maximum output value of the mapping

  """

  value_min: float = ...

  """

  Minimum output value of the mapping

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifier_Material(bpy_struct, LineStyleModifier, LineStyleThicknessModifier):

  """

  Change line thickness based on a material attribute

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  material_attribute: str = ...

  """

  Specify which material attribute is used

  """

  name: str = ...

  """

  Name of the modifier

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  value_max: float = ...

  """

  Maximum output value of the mapping

  """

  value_min: float = ...

  """

  Minimum output value of the mapping

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifier_Noise(bpy_struct, LineStyleModifier, LineStyleThicknessModifier):

  """

  Line thickness based on random noise

  """

  amplitude: float = ...

  """

  Amplitude of the noise

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  name: str = ...

  """

  Name of the modifier

  """

  period: float = ...

  """

  Period of the noise

  """

  seed: int = ...

  """

  Seed for the noise generation

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  use_asymmetric: bool = ...

  """

  Allow thickness to be assigned asymmetrically

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class LineStyleThicknessModifier_Tangent(bpy_struct, LineStyleModifier, LineStyleThicknessModifier):

  """

  Thickness based on the direction of the stroke

  """

  blend: str = ...

  """

  Specify how the modifier value is blended into the base value

  """

  curve: CurveMapping = ...

  """

  Curve used for the curve mapping

  """

  expanded: bool = ...

  """

  True if the modifier tab is expanded

  """

  influence: float = ...

  """

  Influence factor by which the modifier changes the property

  """

  invert: bool = ...

  """

  Invert the fade-out direction of the linear mapping

  """

  mapping: str = ...

  """

  Select the mapping type

  * ``LINEAR``
Linear, Use linear mapping.

  * ``CURVE``
Curve, Use curve mapping.

  """

  name: str = ...

  """

  Name of the modifier

  """

  thickness_max: float = ...

  """

  Maximum thickness

  """

  thickness_min: float = ...

  """

  Minimum thickness

  """

  type: str = ...

  """

  Type of the modifier

  """

  use: bool = ...

  """

  Enable or disable this modifier during stroke rendering

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNode(NodeInternal):

  def tag_need_exec(self) -> None:

    """

    Tag the node for compositor update

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FunctionNode(NodeInternal):

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeFrame(bpy_struct, NodeInternal, Node):

  label_size: int = ...

  """

  Font size to use for displaying the label

  """

  shrink: bool = ...

  """

  Shrink the frame to minimal bounding box

  """

  text: Text = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeGroup(bpy_struct, NodeInternal, Node):

  interface: PropertyGroup = ...

  """

  Interface socket data

  """

  node_tree: NodeTree = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeGroupInput(bpy_struct, NodeInternal, Node):

  interface: PropertyGroup = ...

  """

  Interface socket data

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeGroupOutput(bpy_struct, NodeInternal, Node):

  interface: PropertyGroup = ...

  """

  Interface socket data

  """

  is_active_output: bool = ...

  """

  True if this node is used as the active group output

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeReroute(bpy_struct, NodeInternal, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNode(NodeInternal):

  """

  Material shader node

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SimulationNode(NodeInternal):

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNode(NodeInternal):

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketBool(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Boolean value socket of a node

  """

  default_value: bool = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketColor(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  RGBA color socket of a node

  """

  default_value: typing.Tuple[float, float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketFloat(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketFloatAngle(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketFloatFactor(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketFloatPercentage(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketFloatTime(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketFloatUnsigned(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketImage(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Image socket of a node

  """

  default_value: Image = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInt(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Integer number socket of a node

  """

  default_value: int = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketIntFactor(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Integer number socket of a node

  """

  default_value: int = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketIntPercentage(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Integer number socket of a node

  """

  default_value: int = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketIntUnsigned(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Integer number socket of a node

  """

  default_value: int = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketObject(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Object socket of a node

  """

  default_value: Object = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketShader(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Shader socket of a node

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketString(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  String socket of a node

  """

  default_value: str = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketVector(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketVectorAcceleration(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketVectorDirection(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketVectorEuler(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketVectorTranslation(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketVectorVelocity(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketVectorXYZ(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketVirtual(bpy_struct, NodeSocketStandard, NodeSocket):

  """

  Virtual socket of a node

  """

  links: typing.Any = ...

  """

  List of node links from or to this socket.

  Note: Takes ``O(len(nodetree.links))`` time.

  (readonly)

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceBool(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Boolean value socket of a node

  """

  default_value: bool = ...

  """

  Input value used for unconnected socket

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceColor(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  RGBA color socket of a node

  """

  default_value: typing.Tuple[float, float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceFloat(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceFloatAngle(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceFloatFactor(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceFloatPercentage(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceFloatTime(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceFloatUnsigned(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Floating point number socket of a node

  """

  default_value: float = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceImage(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Image socket of a node

  """

  default_value: Image = ...

  """

  Input value used for unconnected socket

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceInt(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Integer number socket of a node

  """

  default_value: int = ...

  """

  Input value used for unconnected socket

  """

  max_value: int = ...

  """

  Maximum value

  """

  min_value: int = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceIntFactor(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Integer number socket of a node

  """

  default_value: int = ...

  """

  Input value used for unconnected socket

  """

  max_value: int = ...

  """

  Maximum value

  """

  min_value: int = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceIntPercentage(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Integer number socket of a node

  """

  default_value: int = ...

  """

  Input value used for unconnected socket

  """

  max_value: int = ...

  """

  Maximum value

  """

  min_value: int = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceIntUnsigned(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Integer number socket of a node

  """

  default_value: int = ...

  """

  Input value used for unconnected socket

  """

  max_value: int = ...

  """

  Maximum value

  """

  min_value: int = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceObject(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Object socket of a node

  """

  default_value: Object = ...

  """

  Input value used for unconnected socket

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceShader(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  Shader socket of a node

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceString(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  String socket of a node

  """

  default_value: str = ...

  """

  Input value used for unconnected socket

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceVector(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceVectorAcceleration(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceVectorDirection(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceVectorEuler(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceVectorTranslation(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceVectorVelocity(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class NodeSocketInterfaceVectorXYZ(bpy_struct, NodeSocketInterfaceStandard, NodeSocketInterface):

  """

  3D vector socket of a node

  """

  default_value: typing.Tuple[float, float, float] = ...

  """

  Input value used for unconnected socket

  """

  max_value: float = ...

  """

  Maximum value

  """

  min_value: float = ...

  """

  Minimum value

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AddSequence(bpy_struct, Sequence, EffectSequence):

  """

  Add Sequence

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_2: Sequence = ...

  """

  Second input for the effect strip

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AdjustmentSequence(bpy_struct, Sequence, EffectSequence):

  """

  Sequence strip to perform filter adjustments to layers below

  """

  animation_offset_end: int = ...

  """

  Animation end offset (trim end)

  """

  animation_offset_start: int = ...

  """

  Animation start offset (trim start)

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AlphaOverSequence(bpy_struct, Sequence, EffectSequence):

  """

  Alpha Over Sequence

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_2: Sequence = ...

  """

  Second input for the effect strip

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class AlphaUnderSequence(bpy_struct, Sequence, EffectSequence):

  """

  Alpha Under Sequence

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_2: Sequence = ...

  """

  Second input for the effect strip

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorMixSequence(bpy_struct, Sequence, EffectSequence):

  """

  Color Mix Sequence

  """

  blend_effect: str = ...

  """

  Method for controlling how the strip combines with other strips

  """

  factor: float = ...

  """

  Percentage of how much the strip's colors affect other strips

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_2: Sequence = ...

  """

  Second input for the effect strip

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ColorSequence(bpy_struct, Sequence, EffectSequence):

  """

  Sequence strip creating an image filled with a single color

  """

  color: typing.Tuple[float, float, float] = ...

  """

  Effect Strip color

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CrossSequence(bpy_struct, Sequence, EffectSequence):

  """

  Cross Sequence

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_2: Sequence = ...

  """

  Second input for the effect strip

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GammaCrossSequence(bpy_struct, Sequence, EffectSequence):

  """

  Gamma Cross Sequence

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_2: Sequence = ...

  """

  Second input for the effect strip

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GaussianBlurSequence(bpy_struct, Sequence, EffectSequence):

  """

  Sequence strip creating a gaussian blur

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_count: int = ...

  size_x: float = ...

  """

  Size of the blur along X axis

  """

  size_y: float = ...

  """

  Size of the blur along Y axis

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class GlowSequence(bpy_struct, Sequence, EffectSequence):

  """

  Sequence strip creating a glow effect

  """

  blur_radius: float = ...

  """

  Radius of glow effect

  """

  boost_factor: float = ...

  """

  Brightness multiplier

  """

  clamp: float = ...

  """

  Brightness limit of intensity

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_count: int = ...

  quality: int = ...

  """

  Accuracy of the blur effect

  """

  threshold: float = ...

  """

  Minimum intensity to trigger a glow

  """

  use_only_boost: bool = ...

  """

  Show the glow buffer only

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MulticamSequence(bpy_struct, Sequence, EffectSequence):

  """

  Sequence strip to perform multicam editing

  """

  animation_offset_end: int = ...

  """

  Animation end offset (trim end)

  """

  animation_offset_start: int = ...

  """

  Animation start offset (trim start)

  """

  input_count: int = ...

  multicam_source: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class MultiplySequence(bpy_struct, Sequence, EffectSequence):

  """

  Multiply Sequence

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_2: Sequence = ...

  """

  Second input for the effect strip

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class OverDropSequence(bpy_struct, Sequence, EffectSequence):

  """

  Over Drop Sequence

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_2: Sequence = ...

  """

  Second input for the effect strip

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SpeedControlSequence(bpy_struct, Sequence, EffectSequence):

  """

  Sequence strip to control the speed of other strips

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_count: int = ...

  multiply_speed: float = ...

  """

  Multiply the resulting speed after the speed factor

  """

  use_as_speed: bool = ...

  """

  Interpret the value as speed instead of a frame number

  """

  use_frame_interpolate: bool = ...

  """

  Do crossfade blending between current and next frame

  """

  use_scale_to_length: bool = ...

  """

  Scale values from 0.0 to 1.0 to target sequence length

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SubtractSequence(bpy_struct, Sequence, EffectSequence):

  """

  Subtract Sequence

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_2: Sequence = ...

  """

  Second input for the effect strip

  """

  input_count: int = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextSequence(bpy_struct, Sequence, EffectSequence):

  """

  Sequence strip creating text

  """

  align_x: str = ...

  """

  Align the text along the X axis, relative to the text bounds

  """

  align_y: str = ...

  """

  Align the text along the Y axis, relative to the text bounds

  """

  color: typing.Tuple[float, float, float, float] = ...

  """

  Text color

  """

  font: VectorFont = ...

  """

  Font of the text. Falls back to the UI font by default

  """

  font_size: int = ...

  """

  Size of the text

  """

  input_count: int = ...

  location: typing.Tuple[float, float] = ...

  """

  Location of the text

  """

  shadow_color: typing.Tuple[float, float, float, float] = ...

  text: str = ...

  """

  Text that will be displayed

  """

  use_shadow: bool = ...

  """

  Display shadow behind text

  """

  wrap_width: float = ...

  """

  Word wrap width as factor, zero disables

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TransformSequence(bpy_struct, Sequence, EffectSequence):

  """

  Sequence strip applying affine transformations to other strips

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_count: int = ...

  interpolation: str = ...

  """

  Method to determine how missing pixels are created

  * ``NONE``
None, No interpolation.

  * ``BILINEAR``
Bilinear, Bilinear interpolation.

  * ``BICUBIC``
Bicubic, Bicubic interpolation.

  """

  rotation_start: float = ...

  """

  Degrees to rotate the input

  """

  scale_start_x: float = ...

  """

  Amount to scale the input in the X axis

  """

  scale_start_y: float = ...

  """

  Amount to scale the input in the Y axis

  """

  translate_start_x: float = ...

  """

  Amount to move the input on the X axis

  """

  translate_start_y: float = ...

  """

  Amount to move the input on the Y axis

  """

  translation_unit: str = ...

  """

  Unit of measure to translate the input

  """

  use_uniform_scale: bool = ...

  """

  Scale uniformly, preserving aspect ratio

  """

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class WipeSequence(bpy_struct, Sequence, EffectSequence):

  """

  Sequence strip creating a wipe transition

  """

  angle: float = ...

  """

  Edge angle

  """

  blur_width: float = ...

  """

  Width of the blur edge, in percentage relative to the image size

  """

  direction: str = ...

  """

  Wipe direction

  """

  input_1: Sequence = ...

  """

  First input for the effect strip

  """

  input_2: Sequence = ...

  """

  Second input for the effect strip

  """

  input_count: int = ...

  transition_type: str = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeAlphaOver(bpy_struct, NodeInternal, Node, CompositorNode):

  premul: float = ...

  """

  Mix Factor

  """

  use_premultiply: bool = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeBilateralblur(bpy_struct, NodeInternal, Node, CompositorNode):

  iterations: int = ...

  sigma_color: float = ...

  sigma_space: float = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeBlur(bpy_struct, NodeInternal, Node, CompositorNode):

  aspect_correction: str = ...

  """

  Type of aspect correction to use

  """

  factor: float = ...

  factor_x: float = ...

  factor_y: float = ...

  filter_type: str = ...

  size_x: int = ...

  size_y: int = ...

  use_bokeh: bool = ...

  """

  Use circular filter (slower)

  """

  use_extended_bounds: bool = ...

  """

  Extend bounds of the input image to fully fit blurred image

  """

  use_gamma_correction: bool = ...

  """

  Apply filter on gamma corrected values

  """

  use_relative: bool = ...

  """

  Use relative (percent) values to define blur radius

  """

  use_variable_size: bool = ...

  """

  Support variable blur per-pixel when using an image for size input

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeBokehBlur(bpy_struct, NodeInternal, Node, CompositorNode):

  blur_max: float = ...

  """

  Blur limit, maximum CoC radius

  """

  use_extended_bounds: bool = ...

  """

  Extend bounds of the input image to fully fit blurred image

  """

  use_variable_size: bool = ...

  """

  Support variable blur per-pixel when using an image for size input

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeBokehImage(bpy_struct, NodeInternal, Node, CompositorNode):

  angle: float = ...

  """

  Angle of the bokeh

  """

  catadioptric: float = ...

  """

  Level of catadioptric of the bokeh

  """

  flaps: int = ...

  """

  Number of flaps

  """

  rounding: float = ...

  """

  Level of rounding of the bokeh

  """

  shift: float = ...

  """

  Shift of the lens components

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeBoxMask(bpy_struct, NodeInternal, Node, CompositorNode):

  height: float = ...

  """

  Height of the box

  """

  mask_type: str = ...

  rotation: float = ...

  """

  Rotation angle of the box

  """

  width: float = ...

  """

  Width of the box

  """

  x: float = ...

  """

  X position of the middle of the box

  """

  y: float = ...

  """

  Y position of the middle of the box

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeBrightContrast(bpy_struct, NodeInternal, Node, CompositorNode):

  use_premultiply: bool = ...

  """

  Keep output image premultiplied alpha

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeChannelMatte(bpy_struct, NodeInternal, Node, CompositorNode):

  color_space: str = ...

  """

  * ``RGB``
RGB, RGB Color Space.

  * ``HSV``
HSV, HSV Color Space.

  * ``YUV``
YUV, YUV Color Space.

  * ``YCC``
YCbCr, YCbCr Color Space.

  """

  limit_channel: str = ...

  """

  Limit by this channel's value

  """

  limit_max: float = ...

  """

  Values higher than this setting are 100% opaque

  """

  limit_method: str = ...

  """

  Algorithm to use to limit channel

  * ``SINGLE``
Single, Limit by single channel.

  * ``MAX``
Max, Limit by max of other channels.

  """

  limit_min: float = ...

  """

  Values lower than this setting are 100% keyed

  """

  matte_channel: str = ...

  """

  Channel used to determine matte

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeChromaMatte(bpy_struct, NodeInternal, Node, CompositorNode):

  gain: float = ...

  """

  Alpha falloff

  """

  lift: float = ...

  """

  Alpha lift

  """

  shadow_adjust: float = ...

  """

  Adjusts the brightness of any shadows captured

  """

  threshold: float = ...

  """

  Tolerance below which colors will be considered as exact matches

  """

  tolerance: float = ...

  """

  Tolerance for a color to be considered a keying color

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeColorBalance(bpy_struct, NodeInternal, Node, CompositorNode):

  correction_method: str = ...

  """

  * ``LIFT_GAMMA_GAIN``
Lift/Gamma/Gain.

  * ``OFFSET_POWER_SLOPE``
Offset/Power/Slope (ASC-CDL), ASC-CDL standard color correction.

  """

  gain: typing.Tuple[float, float, float] = ...

  """

  Correction for Highlights

  """

  gamma: typing.Tuple[float, float, float] = ...

  """

  Correction for Midtones

  """

  lift: typing.Tuple[float, float, float] = ...

  """

  Correction for Shadows

  """

  offset: typing.Tuple[float, float, float] = ...

  """

  Correction for entire tonal range

  """

  offset_basis: float = ...

  """

  Support negative color by using this as the RGB basis

  """

  power: typing.Tuple[float, float, float] = ...

  """

  Correction for Midtones

  """

  slope: typing.Tuple[float, float, float] = ...

  """

  Correction for Highlights

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeColorCorrection(bpy_struct, NodeInternal, Node, CompositorNode):

  blue: bool = ...

  """

  Blue channel active

  """

  green: bool = ...

  """

  Green channel active

  """

  highlights_contrast: float = ...

  """

  Highlights contrast

  """

  highlights_gain: float = ...

  """

  Highlights gain

  """

  highlights_gamma: float = ...

  """

  Highlights gamma

  """

  highlights_lift: float = ...

  """

  Highlights lift

  """

  highlights_saturation: float = ...

  """

  Highlights saturation

  """

  master_contrast: float = ...

  """

  Master contrast

  """

  master_gain: float = ...

  """

  Master gain

  """

  master_gamma: float = ...

  """

  Master gamma

  """

  master_lift: float = ...

  """

  Master lift

  """

  master_saturation: float = ...

  """

  Master saturation

  """

  midtones_contrast: float = ...

  """

  Midtones contrast

  """

  midtones_end: float = ...

  """

  End of midtones

  """

  midtones_gain: float = ...

  """

  Midtones gain

  """

  midtones_gamma: float = ...

  """

  Midtones gamma

  """

  midtones_lift: float = ...

  """

  Midtones lift

  """

  midtones_saturation: float = ...

  """

  Midtones saturation

  """

  midtones_start: float = ...

  """

  Start of midtones

  """

  red: bool = ...

  """

  Red channel active

  """

  shadows_contrast: float = ...

  """

  Shadows contrast

  """

  shadows_gain: float = ...

  """

  Shadows gain

  """

  shadows_gamma: float = ...

  """

  Shadows gamma

  """

  shadows_lift: float = ...

  """

  Shadows lift

  """

  shadows_saturation: float = ...

  """

  Shadows saturation

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeColorMatte(bpy_struct, NodeInternal, Node, CompositorNode):

  color_hue: float = ...

  """

  Hue tolerance for colors to be considered a keying color

  """

  color_saturation: float = ...

  """

  Saturation Tolerance for the color

  """

  color_value: float = ...

  """

  Value Tolerance for the color

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeColorSpill(bpy_struct, NodeInternal, Node, CompositorNode):

  channel: str = ...

  """

  * ``R``
R, Red Spill Suppression.

  * ``G``
G, Green Spill Suppression.

  * ``B``
B, Blue Spill Suppression.

  """

  limit_channel: str = ...

  """

  * ``R``
R, Limit by Red.

  * ``G``
G, Limit by Green.

  * ``B``
B, Limit by Blue.

  """

  limit_method: str = ...

  """

  * ``SIMPLE``
Simple, Simple Limit Algorithm.

  * ``AVERAGE``
Average, Average Limit Algorithm.

  """

  ratio: float = ...

  """

  Scale limit by value

  """

  unspill_blue: float = ...

  """

  Blue spillmap scale

  """

  unspill_green: float = ...

  """

  Green spillmap scale

  """

  unspill_red: float = ...

  """

  Red spillmap scale

  """

  use_unspill: bool = ...

  """

  Compensate all channels (differently) by hand

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeCombHSVA(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeCombRGBA(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeCombYCCA(bpy_struct, NodeInternal, Node, CompositorNode):

  mode: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeCombYUVA(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeComposite(bpy_struct, NodeInternal, Node, CompositorNode):

  use_alpha: bool = ...

  """

  Colors are treated alpha premultiplied, or colors output straight (alpha gets set to 1)

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeCornerPin(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeCrop(bpy_struct, NodeInternal, Node, CompositorNode):

  max_x: int = ...

  max_y: int = ...

  min_x: int = ...

  min_y: int = ...

  rel_max_x: float = ...

  rel_max_y: float = ...

  rel_min_x: float = ...

  rel_min_y: float = ...

  relative: bool = ...

  """

  Use relative values to crop image

  """

  use_crop_size: bool = ...

  """

  Whether to crop the size of the input image

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeCryptomatte(bpy_struct, NodeInternal, Node, CompositorNode):

  add: typing.Tuple[float, float, float] = ...

  """

  Add object or material to matte, by picking a color from the Pick output

  """

  matte_id: str = ...

  """

  List of object and material crypto IDs to include in matte

  """

  remove: typing.Tuple[float, float, float] = ...

  """

  Remove object or material from matte, by picking a color from the Pick output

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeCurveRGB(bpy_struct, NodeInternal, Node, CompositorNode):

  mapping: CurveMapping = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeCurveVec(bpy_struct, NodeInternal, Node, CompositorNode):

  mapping: CurveMapping = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeCustomGroup(bpy_struct, NodeInternal, Node, CompositorNode):

  """

  Custom Compositor Group Node for Python nodes

  """

  interface: PropertyGroup = ...

  """

  Interface socket data

  """

  node_tree: NodeTree = ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeDBlur(bpy_struct, NodeInternal, Node, CompositorNode):

  angle: float = ...

  center_x: float = ...

  center_y: float = ...

  distance: float = ...

  iterations: int = ...

  spin: float = ...

  use_wrap: bool = ...

  zoom: float = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeDefocus(bpy_struct, NodeInternal, Node, CompositorNode):

  angle: float = ...

  """

  Bokeh shape rotation offset

  """

  blur_max: float = ...

  """

  Blur limit, maximum CoC radius

  """

  bokeh: str = ...

  """

  * ``OCTAGON``
Octagonal, 8 sides.

  * ``HEPTAGON``
Heptagonal, 7 sides.

  * ``HEXAGON``
Hexagonal, 6 sides.

  * ``PENTAGON``
Pentagonal, 5 sides.

  * ``SQUARE``
Square, 4 sides.

  * ``TRIANGLE``
Triangular, 3 sides.

  * ``CIRCLE``
Circular.

  """

  f_stop: float = ...

  """

  Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius

  """

  scene: Scene = ...

  """

  Scene from which to select the active camera (render scene if undefined)

  """

  threshold: float = ...

  """

  CoC radius threshold, prevents background bleed on in-focus midground, 0=off

  """

  use_gamma_correction: bool = ...

  """

  Enable gamma correction before and after main process

  """

  use_preview: bool = ...

  """

  Enable low quality mode, useful for preview

  """

  use_zbuffer: bool = ...

  """

  Disable when using an image as input instead of actual z-buffer (auto enabled if node not image based, eg. time node)

  """

  z_scale: float = ...

  """

  Scale the Z input when not using a z-buffer, controls maximum blur designated by the color white or input value 1

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeDenoise(bpy_struct, NodeInternal, Node, CompositorNode):

  use_hdr: bool = ...

  """

  Process HDR images

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeDespeckle(bpy_struct, NodeInternal, Node, CompositorNode):

  threshold: float = ...

  """

  Threshold for detecting pixels to despeckle

  """

  threshold_neighbor: float = ...

  """

  Threshold for the number of neighbor pixels that must match

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeDiffMatte(bpy_struct, NodeInternal, Node, CompositorNode):

  falloff: float = ...

  """

  Color distances below this additional threshold are partially keyed

  """

  tolerance: float = ...

  """

  Color distances below this threshold are keyed

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeDilateErode(bpy_struct, NodeInternal, Node, CompositorNode):

  distance: int = ...

  """

  Distance to grow/shrink (number of iterations)

  """

  edge: float = ...

  """

  Edge to inset

  """

  falloff: str = ...

  """

  Falloff type the feather

  * ``SMOOTH``
Smooth, Smooth falloff.

  * ``SPHERE``
Sphere, Spherical falloff.

  * ``ROOT``
Root, Root falloff.

  * ``INVERSE_SQUARE``
Inverse Square, Inverse Square falloff.

  * ``SHARP``
Sharp, Sharp falloff.

  * ``LINEAR``
Linear, Linear falloff.

  """

  mode: str = ...

  """

  Growing/shrinking mode

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeDisplace(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeDistanceMatte(bpy_struct, NodeInternal, Node, CompositorNode):

  channel: str = ...

  """

  * ``RGB``
RGB, RGB color space.

  * ``YCC``
YCC, YCbCr Suppression.

  """

  falloff: float = ...

  """

  Color distances below this additional threshold are partially keyed

  """

  tolerance: float = ...

  """

  Color distances below this threshold are keyed

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeDoubleEdgeMask(bpy_struct, NodeInternal, Node, CompositorNode):

  edge_mode: str = ...

  """

  * ``BLEED_OUT``
Bleed Out, Allow mask pixels to bleed along edges.

  * ``KEEP_IN``
Keep In, Restrict mask pixels from touching edges.

  """

  inner_mode: str = ...

  """

  * ``ALL``
All, All pixels on inner mask edge are considered during mask calculation.

  * ``ADJACENT_ONLY``
Adjacent Only, Only inner mask pixels adjacent to outer mask pixels are considered during mask calculation.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeEllipseMask(bpy_struct, NodeInternal, Node, CompositorNode):

  height: float = ...

  """

  Height of the ellipse

  """

  mask_type: str = ...

  rotation: float = ...

  """

  Rotation angle of the ellipse

  """

  width: float = ...

  """

  Width of the ellipse

  """

  x: float = ...

  """

  X position of the middle of the ellipse

  """

  y: float = ...

  """

  Y position of the middle of the ellipse

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeFilter(bpy_struct, NodeInternal, Node, CompositorNode):

  filter_type: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeFlip(bpy_struct, NodeInternal, Node, CompositorNode):

  axis: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeGamma(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeGlare(bpy_struct, NodeInternal, Node, CompositorNode):

  angle_offset: float = ...

  """

  Streak angle offset

  """

  color_modulation: float = ...

  """

  Amount of Color Modulation, modulates colors of streaks and ghosts for a spectral dispersion effect

  """

  fade: float = ...

  """

  Streak fade-out factor

  """

  glare_type: str = ...

  iterations: int = ...

  mix: float = ...

  """

  -1 is original image only, 0 is exact 50/50 mix, 1 is processed image only

  """

  quality: str = ...

  """

  If not set to high quality, the effect will be applied to a low-res copy of the source image

  """

  size: int = ...

  """

  Glow/glare size (not actual size; relative to initial size of bright area of pixels)

  """

  streaks: int = ...

  """

  Total number of streaks

  """

  threshold: float = ...

  """

  The glare filter will only be applied to pixels brighter than this value

  """

  use_rotate_45: bool = ...

  """

  Simple star filter: add 45 degree rotation offset

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeGroup(bpy_struct, NodeInternal, Node, CompositorNode):

  interface: PropertyGroup = ...

  """

  Interface socket data

  """

  node_tree: NodeTree = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeHueCorrect(bpy_struct, NodeInternal, Node, CompositorNode):

  mapping: CurveMapping = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeHueSat(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeIDMask(bpy_struct, NodeInternal, Node, CompositorNode):

  index: int = ...

  """

  Pass index number to convert to alpha

  """

  use_antialiasing: bool = ...

  """

  Apply an anti-aliasing filter to the mask

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeImage(bpy_struct, NodeInternal, Node, CompositorNode):

  frame_duration: int = ...

  """

  Number of images of a movie to use

  """

  frame_offset: int = ...

  """

  Offset the number of the frame to use in the animation

  """

  frame_start: int = ...

  """

  Global starting frame of the movie/sequence, assuming first picture has a #1

  """

  has_layers: bool = ...

  """

  True if this image has any named layer

  """

  has_views: bool = ...

  """

  True if this image has multiple views

  """

  image: Image = ...

  layer: str = ...

  use_auto_refresh: bool = ...

  """

  Always refresh image on frame changes

  """

  use_cyclic: bool = ...

  """

  Cycle the images in the movie

  """

  use_straight_alpha_output: bool = ...

  """

  Put Node output buffer to straight alpha instead of premultiplied

  """

  view: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeInpaint(bpy_struct, NodeInternal, Node, CompositorNode):

  distance: int = ...

  """

  Distance to inpaint (number of iterations)

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeInvert(bpy_struct, NodeInternal, Node, CompositorNode):

  invert_alpha: bool = ...

  invert_rgb: bool = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeKeying(bpy_struct, NodeInternal, Node, CompositorNode):

  blur_post: int = ...

  """

  Matte blur size which applies after clipping and dilate/eroding

  """

  blur_pre: int = ...

  """

  Chroma pre-blur size which applies before running keyer

  """

  clip_black: float = ...

  """

  Value of non-scaled matte pixel which considers as fully background pixel

  """

  clip_white: float = ...

  """

  Value of non-scaled matte pixel which considers as fully foreground pixel

  """

  despill_balance: float = ...

  """

  Balance between non-key colors used to detect amount of key color to be removed

  """

  despill_factor: float = ...

  """

  Factor of despilling screen color from image

  """

  dilate_distance: int = ...

  """

  Matte dilate/erode side

  """

  edge_kernel_radius: int = ...

  """

  Radius of kernel used to detect whether pixel belongs to edge

  """

  edge_kernel_tolerance: float = ...

  """

  Tolerance to pixels inside kernel which are treating as belonging to the same plane

  """

  feather_distance: int = ...

  """

  Distance to grow/shrink the feather

  """

  feather_falloff: str = ...

  """

  Falloff type the feather

  * ``SMOOTH``
Smooth, Smooth falloff.

  * ``SPHERE``
Sphere, Spherical falloff.

  * ``ROOT``
Root, Root falloff.

  * ``INVERSE_SQUARE``
Inverse Square, Inverse Square falloff.

  * ``SHARP``
Sharp, Sharp falloff.

  * ``LINEAR``
Linear, Linear falloff.

  """

  screen_balance: float = ...

  """

  Balance between two non-primary channels primary channel is comparing against

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeKeyingScreen(bpy_struct, NodeInternal, Node, CompositorNode):

  clip: MovieClip = ...

  tracking_object: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeLensdist(bpy_struct, NodeInternal, Node, CompositorNode):

  use_fit: bool = ...

  """

  For positive distortion factor only: scale image such that black areas are not visible

  """

  use_jitter: bool = ...

  """

  Enable/disable jittering (faster, but also noisier)

  """

  use_projector: bool = ...

  """

  Enable/disable projector mode (the effect is applied in horizontal direction only)

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeLevels(bpy_struct, NodeInternal, Node, CompositorNode):

  channel: str = ...

  """

  * ``COMBINED_RGB``
C, Combined RGB.

  * ``RED``
R, Red Channel.

  * ``GREEN``
G, Green Channel.

  * ``BLUE``
B, Blue Channel.

  * ``LUMINANCE``
L, Luminance Channel.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeLumaMatte(bpy_struct, NodeInternal, Node, CompositorNode):

  limit_max: float = ...

  """

  Values higher than this setting are 100% opaque

  """

  limit_min: float = ...

  """

  Values lower than this setting are 100% keyed

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeMapRange(bpy_struct, NodeInternal, Node, CompositorNode):

  use_clamp: bool = ...

  """

  Clamp result of the node to 0..1 range

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeMapUV(bpy_struct, NodeInternal, Node, CompositorNode):

  alpha: int = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeMapValue(bpy_struct, NodeInternal, Node, CompositorNode):

  max: typing.Tuple[float] = ...

  min: typing.Tuple[float] = ...

  offset: typing.Tuple[float] = ...

  size: typing.Tuple[float] = ...

  use_max: bool = ...

  use_min: bool = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeMask(bpy_struct, NodeInternal, Node, CompositorNode):

  mask: Mask = ...

  motion_blur_samples: int = ...

  """

  Number of motion blur samples

  """

  motion_blur_shutter: float = ...

  """

  Exposure for motion blur as a factor of FPS

  """

  size_source: str = ...

  """

  Where to get the mask size from for aspect/size information

  * ``SCENE``
Scene Size.

  * ``FIXED``
Fixed, Use pixel size for the buffer.

  * ``FIXED_SCENE``
Fixed/Scene, Pixel size scaled by scene percentage.

  """

  size_x: int = ...

  size_y: int = ...

  use_feather: bool = ...

  """

  Use feather information from the mask

  """

  use_motion_blur: bool = ...

  """

  Use multi-sampled motion blur of the mask

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeMath(bpy_struct, NodeInternal, Node, CompositorNode):

  operation: str = ...

  """

  * ``ADD``
Add, A + B.

  * ``SUBTRACT``
Subtract, A - B.

  * ``MULTIPLY``
Multiply, A * B.

  * ``DIVIDE``
Divide, A / B.

  * ``MULTIPLY_ADD``
Multiply Add, A * B + C.

  * ``POWER``
Power, A power B.

  * ``LOGARITHM``
Logarithm, Logarithm A base B.

  * ``SQRT``
Square Root, Square root of A.

  * ``INVERSE_SQRT``
Inverse Square Root, 1 / Square root of A.

  * ``ABSOLUTE``
Absolute, Magnitude of A.

  * ``EXPONENT``
Exponent, exp(A).

  * ``MINIMUM``
Minimum, The minimum from A and B.

  * ``MAXIMUM``
Maximum, The maximum from A and B.

  * ``LESS_THAN``
Less Than, 1 if A < B else 0.

  * ``GREATER_THAN``
Greater Than, 1 if A > B else 0.

  * ``SIGN``
Sign, Returns the sign of A.

  * ``COMPARE``
Compare, 1 if (A == B) within tolerance C else 0.

  * ``SMOOTH_MIN``
Smooth Minimum, The minimum from A and B with smoothing C.

  * ``SMOOTH_MAX``
Smooth Maximum, The maximum from A and B with smoothing C.

  * ``ROUND``
Round, Round A to the nearest integer. Round upward if the fraction part is 0.5.

  * ``FLOOR``
Floor, The largest integer smaller than or equal A.

  * ``CEIL``
Ceil, The smallest integer greater than or equal A.

  * ``TRUNC``
Truncate, The integer part of A, removing fractional digits.

  * ``FRACT``
Fraction, The fraction part of A.

  * ``MODULO``
Modulo, Modulo using fmod(A,B).

  * ``WRAP``
Wrap, Wrap value to range, wrap(A,B).

  * ``SNAP``
Snap, Snap to increment, snap(A,B).

  * ``PINGPONG``
Ping-pong, Wraps a value and reverses every other cycle (A,B).

  * ``SINE``
Sine, sin(A).

  * ``COSINE``
Cosine, cos(A).

  * ``TANGENT``
Tangent, tan(A).

  * ``ARCSINE``
Arcsine, arcsin(A).

  * ``ARCCOSINE``
Arccosine, arccos(A).

  * ``ARCTANGENT``
Arctangent, arctan(A).

  * ``ARCTAN2``
Arctan2, The signed angle arctan(A / B).

  * ``SINH``
Hyperbolic Sine, sinh(A).

  * ``COSH``
Hyperbolic Cosine, cosh(A).

  * ``TANH``
Hyperbolic Tangent, tanh(A).

  * ``RADIANS``
To Radians, Convert from degrees to radians.

  * ``DEGREES``
To Degrees, Convert from radians to degrees.

  """

  use_clamp: bool = ...

  """

  Clamp result of the node to 0..1 range

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeMixRGB(bpy_struct, NodeInternal, Node, CompositorNode):

  blend_type: str = ...

  use_alpha: bool = ...

  """

  Include alpha of second input in this operation

  """

  use_clamp: bool = ...

  """

  Clamp result of the node to 0..1 range

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeMovieClip(bpy_struct, NodeInternal, Node, CompositorNode):

  clip: MovieClip = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeMovieDistortion(bpy_struct, NodeInternal, Node, CompositorNode):

  clip: MovieClip = ...

  distortion_type: str = ...

  """

  Distortion to use to filter image

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeNormal(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeNormalize(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeOutputFile(bpy_struct, NodeInternal, Node, CompositorNode):

  active_input_index: int = ...

  """

  Active input index in details view list

  """

  base_path: str = ...

  """

  Base output path for the image

  """

  file_slots: typing.Union[CompositorNodeOutputFileFileSlots, typing.Sequence[NodeOutputFileSlotFile], typing.Mapping[str, NodeOutputFileSlotFile], bpy_prop_collection] = ...

  format: ImageFormatSettings = ...

  layer_slots: typing.Union[CompositorNodeOutputFileLayerSlots, typing.Sequence[NodeOutputFileSlotLayer], typing.Mapping[str, NodeOutputFileSlotLayer], bpy_prop_collection] = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodePixelate(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodePlaneTrackDeform(bpy_struct, NodeInternal, Node, CompositorNode):

  clip: MovieClip = ...

  motion_blur_samples: int = ...

  """

  Number of motion blur samples

  """

  motion_blur_shutter: float = ...

  """

  Exposure for motion blur as a factor of FPS

  """

  plane_track_name: str = ...

  tracking_object: str = ...

  use_motion_blur: bool = ...

  """

  Use multi-sampled motion blur of the mask

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodePremulKey(bpy_struct, NodeInternal, Node, CompositorNode):

  mapping: str = ...

  """

  Conversion between premultiplied alpha and key alpha

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeRGB(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeRGBToBW(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeRLayers(bpy_struct, NodeInternal, Node, CompositorNode):

  layer: str = ...

  scene: Scene = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeRotate(bpy_struct, NodeInternal, Node, CompositorNode):

  filter_type: str = ...

  """

  Method to use to filter rotation

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeScale(bpy_struct, NodeInternal, Node, CompositorNode):

  frame_method: str = ...

  """

  How the image fits in the camera frame

  """

  offset_x: float = ...

  """

  Offset image horizontally (factor of image size)

  """

  offset_y: float = ...

  """

  Offset image vertically (factor of image size)

  """

  space: str = ...

  """

  Coordinate space to scale relative to

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeSepHSVA(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeSepRGBA(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeSepYCCA(bpy_struct, NodeInternal, Node, CompositorNode):

  mode: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeSepYUVA(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeSetAlpha(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeSplitViewer(bpy_struct, NodeInternal, Node, CompositorNode):

  axis: str = ...

  factor: int = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeStabilize(bpy_struct, NodeInternal, Node, CompositorNode):

  clip: MovieClip = ...

  filter_type: str = ...

  """

  Method to use to filter stabilization

  """

  invert: bool = ...

  """

  Invert stabilization to re-introduce motion to the frame

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeSunBeams(bpy_struct, NodeInternal, Node, CompositorNode):

  ray_length: float = ...

  """

  Length of rays as a factor of the image size

  """

  source: typing.Tuple[float, float] = ...

  """

  Source point of rays as a factor of the image width & height

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeSwitch(bpy_struct, NodeInternal, Node, CompositorNode):

  check: bool = ...

  """

  Off: first socket, On: second socket

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeSwitchView(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeTexture(bpy_struct, NodeInternal, Node, CompositorNode):

  node_output: int = ...

  """

  For node-based textures, which output node to use

  """

  texture: Texture = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeTime(bpy_struct, NodeInternal, Node, CompositorNode):

  curve: CurveMapping = ...

  frame_end: int = ...

  frame_start: int = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeTonemap(bpy_struct, NodeInternal, Node, CompositorNode):

  adaptation: float = ...

  """

  If 0, global; if 1, based on pixel intensity

  """

  contrast: float = ...

  """

  Set to 0 to use estimate from input image

  """

  correction: float = ...

  """

  If 0, same for all channels; if 1, each independent

  """

  gamma: float = ...

  """

  If not used, set to 1

  """

  intensity: float = ...

  """

  If less than zero, darkens image; otherwise, makes it brighter

  """

  key: float = ...

  """

  The value the average luminance is mapped to

  """

  offset: float = ...

  """

  Normally always 1, but can be used as an extra control to alter the brightness curve

  """

  tonemap_type: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeTrackPos(bpy_struct, NodeInternal, Node, CompositorNode):

  clip: MovieClip = ...

  frame_relative: int = ...

  """

  Frame to be used for relative position

  """

  position: str = ...

  """

  Which marker position to use for output

  * ``ABSOLUTE``
Absolute, Output absolute position of a marker.

  * ``RELATIVE_START``
Relative Start, Output position of a marker relative to first marker of a track.

  * ``RELATIVE_FRAME``
Relative Frame, Output position of a marker relative to marker at given frame number.

  * ``ABSOLUTE_FRAME``
Absolute Frame, Output absolute position of a marker at given frame number.

  """

  track_name: str = ...

  tracking_object: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeTransform(bpy_struct, NodeInternal, Node, CompositorNode):

  filter_type: str = ...

  """

  Method to use to filter transform

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeTranslate(bpy_struct, NodeInternal, Node, CompositorNode):

  use_relative: bool = ...

  """

  Use relative (fraction of input image size) values to define translation

  """

  wrap_axis: str = ...

  """

  Wrap image on a specific axis

  * ``NONE``
None, No wrapping on X and Y.

  * ``XAXIS``
X Axis, Wrap all pixels on the X axis.

  * ``YAXIS``
Y Axis, Wrap all pixels on the Y axis.

  * ``BOTH``
Both Axes, Wrap all pixels on both axes.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeValToRGB(bpy_struct, NodeInternal, Node, CompositorNode):

  color_ramp: ColorRamp = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeValue(bpy_struct, NodeInternal, Node, CompositorNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeVecBlur(bpy_struct, NodeInternal, Node, CompositorNode):

  factor: float = ...

  """

  Scaling factor for motion vectors (actually, 'shutter speed', in frames)

  """

  samples: int = ...

  speed_max: int = ...

  """

  Maximum speed, or zero for none

  """

  speed_min: int = ...

  """

  Minimum speed for a pixel to be blurred (used to separate background from foreground)

  """

  use_curved: bool = ...

  """

  Interpolate between frames in a Bezier curve, rather than linearly

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeViewer(bpy_struct, NodeInternal, Node, CompositorNode):

  center_x: float = ...

  center_y: float = ...

  tile_order: str = ...

  """

  Tile order

  * ``CENTEROUT``
Center, Expand from center.

  * ``RANDOM``
Random, Random tiles.

  * ``BOTTOMUP``
Bottom up, Expand from bottom.

  * ``RULE_OF_THIRDS``
Rule of thirds, Expand from 9 places.

  """

  use_alpha: bool = ...

  """

  Colors are treated alpha premultiplied, or colors output straight (alpha gets set to 1)

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class CompositorNodeZcombine(bpy_struct, NodeInternal, Node, CompositorNode):

  use_alpha: bool = ...

  """

  Take Alpha channel into account when doing the Z operation

  """

  use_antialias_z: bool = ...

  """

  Anti-alias the z-buffer to try to avoid artifacts, mostly useful for Blender renders

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def update(self) -> None:

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FunctionNodeBooleanMath(bpy_struct, NodeInternal, FunctionNode, Node):

  operation: str = ...

  """

  * ``AND``
And, Outputs true only when both inputs are true.

  * ``OR``
Or, Outputs or when at least one of the inputs is true.

  * ``NOT``
Not, Outputs the opposite of the input.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FunctionNodeCombineStrings(bpy_struct, NodeInternal, FunctionNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FunctionNodeFloatCompare(bpy_struct, NodeInternal, FunctionNode, Node):

  operation: str = ...

  """

  * ``LESS_THAN``
A < B, True when the first input is smaller than second input.

  * ``LESS_EQUAL``
A <= B, True when the first input is smaller than the second input or equal.

  * ``GREATER_THAN``
A > B, True when the first input is greater than the second input.

  * ``GREATER_EQUAL``
A >= B, True when the first input is greater than the second input or equal.

  * ``EQUAL``
A = B, True when both inputs are approximately equal.

  * ``NOT_EQUAL``
A != B, True when both inputs are not approximately equal.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FunctionNodeGroupInstanceID(bpy_struct, NodeInternal, FunctionNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FunctionNodeObjectTransforms(bpy_struct, NodeInternal, FunctionNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FunctionNodeRandomFloat(bpy_struct, NodeInternal, FunctionNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class FunctionNodeSwitch(bpy_struct, NodeInternal, FunctionNode, Node):

  data_type: str = ...

  """

  Data type for inputs and outputs

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeAddShader(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeAmbientOcclusion(bpy_struct, NodeInternal, ShaderNode, Node):

  inside: bool = ...

  """

  Trace rays towards the inside of the object

  """

  only_local: bool = ...

  """

  Only consider the object itself when computing AO

  """

  samples: int = ...

  """

  Number of rays to trace per shader evaluation

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeAttribute(bpy_struct, NodeInternal, ShaderNode, Node):

  attribute_name: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBackground(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBevel(bpy_struct, NodeInternal, ShaderNode, Node):

  samples: int = ...

  """

  Number of rays to trace per shader evaluation

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBlackbody(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBrightContrast(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfAnisotropic(bpy_struct, NodeInternal, ShaderNode, Node):

  distribution: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfDiffuse(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfGlass(bpy_struct, NodeInternal, ShaderNode, Node):

  distribution: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfGlossy(bpy_struct, NodeInternal, ShaderNode, Node):

  distribution: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfHair(bpy_struct, NodeInternal, ShaderNode, Node):

  component: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfHairPrincipled(bpy_struct, NodeInternal, ShaderNode, Node):

  parametrization: str = ...

  """

  Select the shader's color parametrization

  * ``ABSORPTION``
Absorption coefficient, Directly set the absorption coefficient sigma_a (this is not the most intuitive way to color hair).

  * ``MELANIN``
Melanin concentration, Define the melanin concentrations below to get the most realistic-looking hair(you can get the concentrations for different types of hair online).

  * ``COLOR``
Direct coloring, Choose the color of your preference, and the shader will approximate the absorption coefficient to render lookalike hair.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfPrincipled(bpy_struct, NodeInternal, ShaderNode, Node):

  distribution: str = ...

  subsurface_method: str = ...

  """

  Method for rendering subsurface scattering

  * ``BURLEY``
Christensen-Burley, Approximation to physically based volume scattering.

  * ``RANDOM_WALK``
Random Walk, Volumetric approximation to physically based volume scattering.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfRefraction(bpy_struct, NodeInternal, ShaderNode, Node):

  distribution: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfToon(bpy_struct, NodeInternal, ShaderNode, Node):

  component: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfTranslucent(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfTransparent(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBsdfVelvet(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeBump(bpy_struct, NodeInternal, ShaderNode, Node):

  invert: bool = ...

  """

  Invert the bump mapping direction to push into the surface instead of out

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeCameraData(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeClamp(bpy_struct, NodeInternal, ShaderNode, Node):

  clamp_type: str = ...

  """

  * ``MINMAX``
Min Max, Clamp values using Min and Max values.

  * ``RANGE``
Range, Clamp values between Min and Max range.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeCombineHSV(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeCombineRGB(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeCombineXYZ(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeCustomGroup(bpy_struct, NodeInternal, ShaderNode, Node):

  """

  Custom Shader Group Node for Python nodes

  """

  interface: PropertyGroup = ...

  """

  Interface socket data

  """

  node_tree: NodeTree = ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeDisplacement(bpy_struct, NodeInternal, ShaderNode, Node):

  space: str = ...

  """

  Space of the input height

  * ``OBJECT``
Object Space, Displacement is in object space, affected by object scale.

  * ``WORLD``
World Space, Displacement is in world space, not affected by object scale.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeEeveeSpecular(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeEmission(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeFresnel(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeGamma(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeGroup(bpy_struct, NodeInternal, ShaderNode, Node):

  interface: PropertyGroup = ...

  """

  Interface socket data

  """

  node_tree: NodeTree = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeHairInfo(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeHoldout(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeHueSaturation(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeInvert(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeLayerWeight(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeLightFalloff(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeLightPath(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeMapRange(bpy_struct, NodeInternal, ShaderNode, Node):

  clamp: bool = ...

  """

  Clamp the result to the target range [To Min, To Max]

  """

  interpolation_type: str = ...

  """

  * ``LINEAR``
Linear, Linear interpolation between From Min and From Max values.

  * ``STEPPED``
Stepped Linear, Stepped linear interpolation between From Min and From Max values.

  * ``SMOOTHSTEP``
Smooth Step, Smooth Hermite edge interpolation between From Min and From Max values.

  * ``SMOOTHERSTEP``
Smoother Step, Smoother Hermite edge interpolation between From Min and From Max values.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeMapping(bpy_struct, NodeInternal, ShaderNode, Node):

  vector_type: str = ...

  """

  Type of vector that the mapping transforms

  * ``POINT``
Point, Transform a point.

  * ``TEXTURE``
Texture, Transform a texture by inverse mapping the texture coordinate.

  * ``VECTOR``
Vector, Transform a direction vector. Location is ignored.

  * ``NORMAL``
Normal, Transform a unit normal vector. Location is ignored.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeMath(bpy_struct, NodeInternal, ShaderNode, Node):

  operation: str = ...

  """

  * ``ADD``
Add, A + B.

  * ``SUBTRACT``
Subtract, A - B.

  * ``MULTIPLY``
Multiply, A * B.

  * ``DIVIDE``
Divide, A / B.

  * ``MULTIPLY_ADD``
Multiply Add, A * B + C.

  * ``POWER``
Power, A power B.

  * ``LOGARITHM``
Logarithm, Logarithm A base B.

  * ``SQRT``
Square Root, Square root of A.

  * ``INVERSE_SQRT``
Inverse Square Root, 1 / Square root of A.

  * ``ABSOLUTE``
Absolute, Magnitude of A.

  * ``EXPONENT``
Exponent, exp(A).

  * ``MINIMUM``
Minimum, The minimum from A and B.

  * ``MAXIMUM``
Maximum, The maximum from A and B.

  * ``LESS_THAN``
Less Than, 1 if A < B else 0.

  * ``GREATER_THAN``
Greater Than, 1 if A > B else 0.

  * ``SIGN``
Sign, Returns the sign of A.

  * ``COMPARE``
Compare, 1 if (A == B) within tolerance C else 0.

  * ``SMOOTH_MIN``
Smooth Minimum, The minimum from A and B with smoothing C.

  * ``SMOOTH_MAX``
Smooth Maximum, The maximum from A and B with smoothing C.

  * ``ROUND``
Round, Round A to the nearest integer. Round upward if the fraction part is 0.5.

  * ``FLOOR``
Floor, The largest integer smaller than or equal A.

  * ``CEIL``
Ceil, The smallest integer greater than or equal A.

  * ``TRUNC``
Truncate, The integer part of A, removing fractional digits.

  * ``FRACT``
Fraction, The fraction part of A.

  * ``MODULO``
Modulo, Modulo using fmod(A,B).

  * ``WRAP``
Wrap, Wrap value to range, wrap(A,B).

  * ``SNAP``
Snap, Snap to increment, snap(A,B).

  * ``PINGPONG``
Ping-pong, Wraps a value and reverses every other cycle (A,B).

  * ``SINE``
Sine, sin(A).

  * ``COSINE``
Cosine, cos(A).

  * ``TANGENT``
Tangent, tan(A).

  * ``ARCSINE``
Arcsine, arcsin(A).

  * ``ARCCOSINE``
Arccosine, arccos(A).

  * ``ARCTANGENT``
Arctangent, arctan(A).

  * ``ARCTAN2``
Arctan2, The signed angle arctan(A / B).

  * ``SINH``
Hyperbolic Sine, sinh(A).

  * ``COSH``
Hyperbolic Cosine, cosh(A).

  * ``TANH``
Hyperbolic Tangent, tanh(A).

  * ``RADIANS``
To Radians, Convert from degrees to radians.

  * ``DEGREES``
To Degrees, Convert from radians to degrees.

  """

  use_clamp: bool = ...

  """

  Clamp result of the node to 0..1 range

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeMixRGB(bpy_struct, NodeInternal, ShaderNode, Node):

  blend_type: str = ...

  use_alpha: bool = ...

  """

  Include alpha of second input in this operation

  """

  use_clamp: bool = ...

  """

  Clamp result of the node to 0..1 range

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeMixShader(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeNewGeometry(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeNormal(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeNormalMap(bpy_struct, NodeInternal, ShaderNode, Node):

  space: str = ...

  """

  Space of the input normal

  * ``TANGENT``
Tangent Space, Tangent space normal mapping.

  * ``OBJECT``
Object Space, Object space normal mapping.

  * ``WORLD``
World Space, World space normal mapping.

  * ``BLENDER_OBJECT``
Blender Object Space, Object space normal mapping, compatible with Blender render baking.

  * ``BLENDER_WORLD``
Blender World Space, World space normal mapping, compatible with Blender render baking.

  """

  uv_map: str = ...

  """

  UV Map for tangent space maps

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeObjectInfo(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeOutputAOV(bpy_struct, NodeInternal, ShaderNode, Node):

  name: str = ...

  """

  Name of the AOV that this output writes to

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeOutputLight(bpy_struct, NodeInternal, ShaderNode, Node):

  is_active_output: bool = ...

  """

  True if this node is used as the active output

  """

  target: str = ...

  """

  Which renderer and viewport shading types to use the shaders for

  * ``ALL``
All, Use shaders for all renderers and viewports, unless there exists a more specific output.

  * ``EEVEE``
Eevee, Use shaders for Eevee renderer.

  * ``CYCLES``
Cycles, Use shaders for Cycles renderer.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeOutputLineStyle(bpy_struct, NodeInternal, ShaderNode, Node):

  blend_type: str = ...

  is_active_output: bool = ...

  """

  True if this node is used as the active output

  """

  target: str = ...

  """

  Which renderer and viewport shading types to use the shaders for

  * ``ALL``
All, Use shaders for all renderers and viewports, unless there exists a more specific output.

  * ``EEVEE``
Eevee, Use shaders for Eevee renderer.

  * ``CYCLES``
Cycles, Use shaders for Cycles renderer.

  """

  use_alpha: bool = ...

  """

  Include alpha of second input in this operation

  """

  use_clamp: bool = ...

  """

  Clamp result of the node to 0..1 range

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeOutputMaterial(bpy_struct, NodeInternal, ShaderNode, Node):

  is_active_output: bool = ...

  """

  True if this node is used as the active output

  """

  target: str = ...

  """

  Which renderer and viewport shading types to use the shaders for

  * ``ALL``
All, Use shaders for all renderers and viewports, unless there exists a more specific output.

  * ``EEVEE``
Eevee, Use shaders for Eevee renderer.

  * ``CYCLES``
Cycles, Use shaders for Cycles renderer.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeOutputWorld(bpy_struct, NodeInternal, ShaderNode, Node):

  is_active_output: bool = ...

  """

  True if this node is used as the active output

  """

  target: str = ...

  """

  Which renderer and viewport shading types to use the shaders for

  * ``ALL``
All, Use shaders for all renderers and viewports, unless there exists a more specific output.

  * ``EEVEE``
Eevee, Use shaders for Eevee renderer.

  * ``CYCLES``
Cycles, Use shaders for Cycles renderer.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeParticleInfo(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeRGB(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeRGBCurve(bpy_struct, NodeInternal, ShaderNode, Node):

  mapping: CurveMapping = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeRGBToBW(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeScript(bpy_struct, NodeInternal, ShaderNode, Node):

  bytecode: str = ...

  """

  Compile bytecode for shader script node

  """

  bytecode_hash: str = ...

  """

  Hash of compile bytecode, for quick equality checking

  """

  filepath: str = ...

  """

  Shader script path

  """

  mode: str = ...

  """

  * ``INTERNAL``
Internal, Use internal text data-block.

  * ``EXTERNAL``
External, Use external .osl or .oso file.

  """

  script: Text = ...

  """

  Internal shader script to define the shader

  """

  use_auto_update: bool = ...

  """

  Automatically update the shader when the .osl file changes (external scripts only)

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeSeparateHSV(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeSeparateRGB(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeSeparateXYZ(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeShaderToRGB(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeSqueeze(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeSubsurfaceScattering(bpy_struct, NodeInternal, ShaderNode, Node):

  falloff: str = ...

  """

  Function to determine how much light nearby points contribute based on their distance to the shading point

  * ``CUBIC``
Cubic, Simple cubic falloff function.

  * ``GAUSSIAN``
Gaussian, Normal distribution, multiple can be combined to fit more complex profiles.

  * ``BURLEY``
Christensen-Burley, Approximation to physically based volume scattering.

  * ``RANDOM_WALK``
Random Walk, Volumetric approximation to physically based volume scattering.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTangent(bpy_struct, NodeInternal, ShaderNode, Node):

  axis: str = ...

  """

  Axis for radial tangents

  * ``X``
X, X axis.

  * ``Y``
Y, Y axis.

  * ``Z``
Z, Z axis.

  """

  direction_type: str = ...

  """

  Method to use for the tangent

  * ``RADIAL``
Radial, Radial tangent around the X, Y or Z axis.

  * ``UV_MAP``
UV Map, Tangent from UV map.

  """

  uv_map: str = ...

  """

  UV Map for tangent generated from UV

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexBrick(bpy_struct, NodeInternal, ShaderNode, Node):

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  offset: float = ...

  offset_frequency: int = ...

  squash: float = ...

  squash_frequency: int = ...

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexChecker(bpy_struct, NodeInternal, ShaderNode, Node):

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexCoord(bpy_struct, NodeInternal, ShaderNode, Node):

  from_instancer: bool = ...

  """

  Use the parent of the dupli object if possible

  """

  object: Object = ...

  """

  Use coordinates from this object (for object texture coordinates output)

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexEnvironment(bpy_struct, NodeInternal, ShaderNode, Node):

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  image: Image = ...

  image_user: ImageUser = ...

  """

  Parameters defining which layer, pass and frame of the image is displayed

  """

  interpolation: str = ...

  """

  Texture interpolation

  * ``Linear``
Linear, Linear interpolation.

  * ``Closest``
Closest, No interpolation (sample closest texel).

  * ``Cubic``
Cubic, Cubic interpolation.

  * ``Smart``
Smart, Bicubic when magnifying, else bilinear (OSL only).

  """

  projection: str = ...

  """

  Projection of the input image

  * ``EQUIRECTANGULAR``
Equirectangular, Equirectangular or latitude-longitude projection.

  * ``MIRROR_BALL``
Mirror Ball, Projection from an orthographic photo of a mirror ball.

  """

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexGradient(bpy_struct, NodeInternal, ShaderNode, Node):

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  gradient_type: str = ...

  """

  Style of the color blending

  * ``LINEAR``
Linear, Create a linear progression.

  * ``QUADRATIC``
Quadratic, Create a quadratic progression.

  * ``EASING``
Easing, Create a progression easing from one step to the next.

  * ``DIAGONAL``
Diagonal, Create a diagonal progression.

  * ``SPHERICAL``
Spherical, Create a spherical progression.

  * ``QUADRATIC_SPHERE``
Quadratic sphere, Create a quadratic progression in the shape of a sphere.

  * ``RADIAL``
Radial, Create a radial progression.

  """

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexIES(bpy_struct, NodeInternal, ShaderNode, Node):

  filepath: str = ...

  """

  IES light path

  """

  ies: Text = ...

  """

  Internal IES file

  """

  mode: str = ...

  """

  Whether the IES file is loaded from disk or from a Text datablock

  * ``INTERNAL``
Internal, Use internal text datablock.

  * ``EXTERNAL``
External, Use external .ies file.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexImage(bpy_struct, NodeInternal, ShaderNode, Node):

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  extension: str = ...

  """

  How the image is extrapolated past its original bounds

  * ``REPEAT``
Repeat, Cause the image to repeat horizontally and vertically.

  * ``EXTEND``
Extend, Extend by repeating edge pixels of the image.

  * ``CLIP``
Clip, Clip to image size and set exterior pixels as transparent.

  """

  image: Image = ...

  image_user: ImageUser = ...

  """

  Parameters defining which layer, pass and frame of the image is displayed

  """

  interpolation: str = ...

  """

  Texture interpolation

  * ``Linear``
Linear, Linear interpolation.

  * ``Closest``
Closest, No interpolation (sample closest texel).

  * ``Cubic``
Cubic, Cubic interpolation.

  * ``Smart``
Smart, Bicubic when magnifying, else bilinear (OSL only).

  """

  projection: str = ...

  """

  Method to project 2D image on object with a 3D texture vector

  * ``FLAT``
Flat, Image is projected flat using the X and Y coordinates of the texture vector.

  * ``BOX``
Box, Image is projected using different components for each side of the object space bounding box.

  * ``SPHERE``
Sphere, Image is projected spherically using the Z axis as central.

  * ``TUBE``
Tube, Image is projected from the tube using the Z axis as central.

  """

  projection_blend: float = ...

  """

  For box projection, amount of blend to use between sides

  """

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexMagic(bpy_struct, NodeInternal, ShaderNode, Node):

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  turbulence_depth: int = ...

  """

  Level of detail in the added turbulent noise

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexMusgrave(bpy_struct, NodeInternal, ShaderNode, Node):

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  musgrave_dimensions: str = ...

  """

  * ``1D``
1D, Use the scalar value W as input.

  * ``2D``
2D, Use the 2D vector (x, y) as input. The z component is ignored.

  * ``3D``
3D, Use the 3D vector Vector as input.

  * ``4D``
4D, Use the 4D vector (x, y, z, w) as input.

  """

  musgrave_type: str = ...

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexNoise(bpy_struct, NodeInternal, ShaderNode, Node):

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  noise_dimensions: str = ...

  """

  The dimensions of the space to evaluate the noise in

  * ``1D``
1D, Use the scalar value W as input.

  * ``2D``
2D, Use the 2D vector (x, y) as input. The z component is ignored.

  * ``3D``
3D, Use the 3D vector Vector as input.

  * ``4D``
4D, Use the 4D vector (x, y, z, w) as input.

  """

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexPointDensity(bpy_struct, NodeInternal, ShaderNode, Node):

  interpolation: str = ...

  """

  Texture interpolation

  * ``Closest``
Closest, No interpolation (sample closest texel).

  * ``Linear``
Linear, Linear interpolation.

  * ``Cubic``
Cubic, Cubic interpolation.

  """

  object: Object = ...

  """

  Object to take point data from

  """

  particle_color_source: str = ...

  """

  Data to derive color results from

  * ``PARTICLE_AGE``
Particle Age, Lifetime mapped as 0.0 - 1.0 intensity.

  * ``PARTICLE_SPEED``
Particle Speed, Particle speed (absolute magnitude of velocity) mapped as 0.0-1.0 intensity.

  * ``PARTICLE_VELOCITY``
Particle Velocity, XYZ velocity mapped to RGB colors.

  """

  particle_system: ParticleSystem = ...

  """

  Particle System to render as points

  """

  point_source: str = ...

  """

  Point data to use as renderable point density

  * ``PARTICLE_SYSTEM``
Particle System, Generate point density from a particle system.

  * ``OBJECT``
Object Vertices, Generate point density from an object's vertices.

  """

  radius: float = ...

  """

  Radius from the shaded sample to look for points within

  """

  resolution: int = ...

  """

  Resolution used by the texture holding the point density

  """

  space: str = ...

  """

  Coordinate system to calculate voxels in

  """

  vertex_attribute_name: str = ...

  """

  Vertex attribute to use for color

  """

  vertex_color_source: str = ...

  """

  Data to derive color results from

  * ``VERTEX_COLOR``
Vertex Color, Vertex color layer.

  * ``VERTEX_WEIGHT``
Vertex Weight, Vertex group weight.

  * ``VERTEX_NORMAL``
Vertex Normal, XYZ normal vector mapped to RGB colors.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  def cache_point_density(self, depsgraph: Depsgraph = None) -> None:

    """

    Cache point density data for later calculation

    """

    ...

  def calc_point_density(self, depsgraph: Depsgraph = None) -> typing.Tuple[float]:

    """

    Calculate point density

    """

    ...

  def calc_point_density_minmax(self, depsgraph: Depsgraph = None) -> None:

    """

    Calculate point density

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexSky(bpy_struct, NodeInternal, ShaderNode, Node):

  air_density: float = ...

  """

  Density of air molecules

  """

  altitude: float = ...

  """

  Height from sea level

  """

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  dust_density: float = ...

  """

  Density of dust molecules and water droplets

  """

  ground_albedo: float = ...

  """

  Ground color that is subtly reflected in the sky

  """

  ozone_density: float = ...

  """

  Density of Ozone layer

  """

  sky_type: str = ...

  """

  Which sky model should be used

  * ``PREETHAM``
Preetham, Preetham 1999.

  * ``HOSEK_WILKIE``
Hosek / Wilkie, Hosek / Wilkie 2012.

  * ``NISHITA``
Nishita, Nishita 1993 improved.

  """

  sun_direction: typing.Tuple[float, float, float] = ...

  """

  Direction from where the sun is shining

  """

  sun_disc: bool = ...

  """

  Include the sun itself in the output

  """

  sun_elevation: float = ...

  """

  Sun angle from horizon

  """

  sun_intensity: float = ...

  """

  Strength of sun

  """

  sun_rotation: float = ...

  """

  Rotation of sun around zenith

  """

  sun_size: float = ...

  """

  Size of sun disc

  """

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  turbidity: float = ...

  """

  Atmospheric turbidity

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexVoronoi(bpy_struct, NodeInternal, ShaderNode, Node):

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  distance: str = ...

  """

  * ``EUCLIDEAN``
Euclidean, Euclidean distance.

  * ``MANHATTAN``
Manhattan, Manhattan distance.

  * ``CHEBYCHEV``
Chebychev, Chebychev distance.

  * ``MINKOWSKI``
Minkowski, Minkowski distance.

  """

  feature: str = ...

  """

  * ``F1``
F1, Computes the distance to the closest point as well as its position and color.

  * ``F2``
F2, Computes the distance to the second closest point as well as its position and color.

  * ``SMOOTH_F1``
Smooth F1, Smoothed version of F1. Weighted sum of neighbor voronoi cells.

  * ``DISTANCE_TO_EDGE``
Distance To Edge, Computes the distance to the edge of the voronoi cell.

  * ``N_SPHERE_RADIUS``
N-Sphere Radius, Computes the radius of the n-sphere inscribed in the voronoi cell.

  """

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  voronoi_dimensions: str = ...

  """

  * ``1D``
1D, Use the scalar value W as input.

  * ``2D``
2D, Use the 2D vector (x, y) as input. The z component is ignored.

  * ``3D``
3D, Use the 3D vector Vector as input.

  * ``4D``
4D, Use the 4D vector (x, y, z, w) as input.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexWave(bpy_struct, NodeInternal, ShaderNode, Node):

  bands_direction: str = ...

  """

  * ``X``
X, Bands across X axis.

  * ``Y``
Y, Bands across Y axis.

  * ``Z``
Z, Bands across Z axis.

  * ``DIAGONAL``
Diagonal, Bands across diagonal axis.

  """

  color_mapping: ColorMapping = ...

  """

  Color mapping settings

  """

  rings_direction: str = ...

  """

  * ``X``
X, Rings along X axis.

  * ``Y``
Y, Rings along Y axis.

  * ``Z``
Z, Rings along Z axis.

  * ``SPHERICAL``
Spherical, Rings along spherical distance.

  """

  texture_mapping: TexMapping = ...

  """

  Texture coordinate mapping settings

  """

  wave_profile: str = ...

  """

  * ``SIN``
Sine, Use a standard sine profile.

  * ``SAW``
Saw, Use a sawtooth profile.

  * ``TRI``
Triangle, Use a triangle profile.

  """

  wave_type: str = ...

  """

  * ``BANDS``
Bands, Use standard wave texture in bands.

  * ``RINGS``
Rings, Use wave texture in rings.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeTexWhiteNoise(bpy_struct, NodeInternal, ShaderNode, Node):

  noise_dimensions: str = ...

  """

  The dimensions of the space to evaluate the noise in

  * ``1D``
1D, Use the scalar value W as input.

  * ``2D``
2D, Use the 2D vector (x, y) as input. The z component is ignored.

  * ``3D``
3D, Use the 3D vector Vector as input.

  * ``4D``
4D, Use the 4D vector (x, y, z, w) as input.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeUVAlongStroke(bpy_struct, NodeInternal, ShaderNode, Node):

  use_tips: bool = ...

  """

  Lower half of the texture is for tips of the stroke

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeUVMap(bpy_struct, NodeInternal, ShaderNode, Node):

  from_instancer: bool = ...

  """

  Use the parent of the dupli object if possible

  """

  uv_map: str = ...

  """

  UV coordinates to be used for mapping

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeValToRGB(bpy_struct, NodeInternal, ShaderNode, Node):

  color_ramp: ColorRamp = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeValue(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeVectorCurve(bpy_struct, NodeInternal, ShaderNode, Node):

  mapping: CurveMapping = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeVectorDisplacement(bpy_struct, NodeInternal, ShaderNode, Node):

  space: str = ...

  """

  Space of the input height

  * ``TANGENT``
Tangent Space, Tangent space vector displacement mapping.

  * ``OBJECT``
Object Space, Object space vector displacement mapping.

  * ``WORLD``
World Space, World space vector displacement mapping.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeVectorMath(bpy_struct, NodeInternal, ShaderNode, Node):

  operation: str = ...

  """

  * ``ADD``
Add, A + B.

  * ``SUBTRACT``
Subtract, A - B.

  * ``MULTIPLY``
Multiply, Entry-wise multiply.

  * ``DIVIDE``
Divide, Entry-wise divide.

  * ``CROSS_PRODUCT``
Cross Product, A cross B.

  * ``PROJECT``
Project, Project A onto B.

  * ``REFLECT``
Reflect, Reflect A around the normal B. B doesn't need to be normalized.

  * ``DOT_PRODUCT``
Dot Product, A dot B.

  * ``DISTANCE``
Distance, Distance between A and B.

  * ``LENGTH``
Length, Length of A.

  * ``SCALE``
Scale, A multiplied by Scale.

  * ``NORMALIZE``
Normalize, Normalize A.

  * ``ABSOLUTE``
Absolute, Entry-wise absolute.

  * ``MINIMUM``
Minimum, Entry-wise minimum.

  * ``MAXIMUM``
Maximum, Entry-wise maximum.

  * ``FLOOR``
Floor, Entry-wise floor.

  * ``CEIL``
Ceil, Entry-wise ceil.

  * ``FRACTION``
Fraction, The fraction part of A entry-wise.

  * ``MODULO``
Modulo, Entry-wise modulo using fmod(A,B).

  * ``WRAP``
Wrap, Entry-wise wrap(A,B).

  * ``SNAP``
Snap, Round A to the largest integer multiple of B less than or equal A.

  * ``SINE``
Sine, Entry-wise sin(A).

  * ``COSINE``
Cosine, Entry-wise cos(A).

  * ``TANGENT``
Tangent, Entry-wise tan(A).

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeVectorRotate(bpy_struct, NodeInternal, ShaderNode, Node):

  invert: bool = ...

  """

  Invert angle

  """

  rotation_type: str = ...

  """

  Type of rotation

  * ``AXIS_ANGLE``
Axis Angle, Rotate a point using axis angle.

  * ``X_AXIS``
X Axis, Rotate a point using X axis.

  * ``Y_AXIS``
Y Axis, Rotate a point using Y axis.

  * ``Z_AXIS``
Z Axis, Rotate a point using Z axis.

  * ``EULER_XYZ``
Euler, Rotate a point using XYZ order.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeVectorTransform(bpy_struct, NodeInternal, ShaderNode, Node):

  convert_from: str = ...

  """

  Space to convert from

  """

  convert_to: str = ...

  """

  Space to convert to

  """

  vector_type: str = ...

  """

  * ``POINT``
Point, Transform a point.

  * ``VECTOR``
Vector, Transform a direction vector.

  * ``NORMAL``
Normal, Transform a normal vector with unit length.

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeVertexColor(bpy_struct, NodeInternal, ShaderNode, Node):

  layer_name: str = ...

  """

  Vertex Color

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeVolumeAbsorption(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeVolumeInfo(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeVolumePrincipled(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeVolumeScatter(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeWavelength(bpy_struct, NodeInternal, ShaderNode, Node):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class ShaderNodeWireframe(bpy_struct, NodeInternal, ShaderNode, Node):

  use_pixel_size: bool = ...

  """

  Use screen pixel size instead of world units

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class SimulationNodeGroup(bpy_struct, NodeInternal, Node, SimulationNode):

  interface: PropertyGroup = ...

  """

  Interface socket data

  """

  node_tree: NodeTree = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeAt(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeBricks(bpy_struct, NodeInternal, Node, TextureNode):

  offset: float = ...

  offset_frequency: int = ...

  """

  Offset every N rows

  """

  squash: float = ...

  squash_frequency: int = ...

  """

  Squash every N rows

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeChecker(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeCompose(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeCoordinates(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeCurveRGB(bpy_struct, NodeInternal, Node, TextureNode):

  mapping: CurveMapping = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeCurveTime(bpy_struct, NodeInternal, Node, TextureNode):

  curve: CurveMapping = ...

  frame_end: int = ...

  frame_start: int = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeDecompose(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeDistance(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeGroup(bpy_struct, NodeInternal, Node, TextureNode):

  interface: PropertyGroup = ...

  """

  Interface socket data

  """

  node_tree: NodeTree = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeHueSaturation(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeImage(bpy_struct, NodeInternal, Node, TextureNode):

  image: Image = ...

  image_user: ImageUser = ...

  """

  Parameters defining the image duration, offset and related settings

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeInvert(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeMath(bpy_struct, NodeInternal, Node, TextureNode):

  operation: str = ...

  """

  * ``ADD``
Add, A + B.

  * ``SUBTRACT``
Subtract, A - B.

  * ``MULTIPLY``
Multiply, A * B.

  * ``DIVIDE``
Divide, A / B.

  * ``MULTIPLY_ADD``
Multiply Add, A * B + C.

  * ``POWER``
Power, A power B.

  * ``LOGARITHM``
Logarithm, Logarithm A base B.

  * ``SQRT``
Square Root, Square root of A.

  * ``INVERSE_SQRT``
Inverse Square Root, 1 / Square root of A.

  * ``ABSOLUTE``
Absolute, Magnitude of A.

  * ``EXPONENT``
Exponent, exp(A).

  * ``MINIMUM``
Minimum, The minimum from A and B.

  * ``MAXIMUM``
Maximum, The maximum from A and B.

  * ``LESS_THAN``
Less Than, 1 if A < B else 0.

  * ``GREATER_THAN``
Greater Than, 1 if A > B else 0.

  * ``SIGN``
Sign, Returns the sign of A.

  * ``COMPARE``
Compare, 1 if (A == B) within tolerance C else 0.

  * ``SMOOTH_MIN``
Smooth Minimum, The minimum from A and B with smoothing C.

  * ``SMOOTH_MAX``
Smooth Maximum, The maximum from A and B with smoothing C.

  * ``ROUND``
Round, Round A to the nearest integer. Round upward if the fraction part is 0.5.

  * ``FLOOR``
Floor, The largest integer smaller than or equal A.

  * ``CEIL``
Ceil, The smallest integer greater than or equal A.

  * ``TRUNC``
Truncate, The integer part of A, removing fractional digits.

  * ``FRACT``
Fraction, The fraction part of A.

  * ``MODULO``
Modulo, Modulo using fmod(A,B).

  * ``WRAP``
Wrap, Wrap value to range, wrap(A,B).

  * ``SNAP``
Snap, Snap to increment, snap(A,B).

  * ``PINGPONG``
Ping-pong, Wraps a value and reverses every other cycle (A,B).

  * ``SINE``
Sine, sin(A).

  * ``COSINE``
Cosine, cos(A).

  * ``TANGENT``
Tangent, tan(A).

  * ``ARCSINE``
Arcsine, arcsin(A).

  * ``ARCCOSINE``
Arccosine, arccos(A).

  * ``ARCTANGENT``
Arctangent, arctan(A).

  * ``ARCTAN2``
Arctan2, The signed angle arctan(A / B).

  * ``SINH``
Hyperbolic Sine, sinh(A).

  * ``COSH``
Hyperbolic Cosine, cosh(A).

  * ``TANH``
Hyperbolic Tangent, tanh(A).

  * ``RADIANS``
To Radians, Convert from degrees to radians.

  * ``DEGREES``
To Degrees, Convert from radians to degrees.

  """

  use_clamp: bool = ...

  """

  Clamp result of the node to 0..1 range

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeMixRGB(bpy_struct, NodeInternal, Node, TextureNode):

  blend_type: str = ...

  use_alpha: bool = ...

  """

  Include alpha of second input in this operation

  """

  use_clamp: bool = ...

  """

  Clamp result of the node to 0..1 range

  """

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeOutput(bpy_struct, NodeInternal, Node, TextureNode):

  filepath: str = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeRGBToBW(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeRotate(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeScale(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexBlend(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexClouds(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexDistNoise(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexMagic(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexMarble(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexMusgrave(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexNoise(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexStucci(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexVoronoi(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexWood(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTexture(bpy_struct, NodeInternal, Node, TextureNode):

  node_output: int = ...

  """

  For node-based textures, which output node to use

  """

  texture: Texture = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeTranslate(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeValToNor(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeValToRGB(bpy_struct, NodeInternal, Node, TextureNode):

  color_ramp: ColorRamp = ...

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...

class TextureNodeViewer(bpy_struct, NodeInternal, Node, TextureNode):

  @classmethod

  def is_registered_node_type(cls) -> bool:

    """

    True if a registered node type

    """

    ...

  @classmethod

  def input_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Input socket template

    """

    ...

  @classmethod

  def output_template(cls, index: int) -> NodeInternalSocketTemplate:

    """

    Output socket template

    """

    ...

  @classmethod

  def bl_rna_get_subclass(cls, id: str, default: typing.Any = None) -> Struct:

    ...

  @classmethod

  def bl_rna_get_subclass_py(cls, id: str, default: typing.Any = None) -> typing.Type:

    ...
