unmodified property names ready for editing (all props excluding bools)

1 files changed, 3190 insertions, 0 deletions

diff --git a/source/blender/makesrna/rna_cleanup/rna_properties.txt b/source/blender/makesrna/rna_cleanup/rna_properties.txt
new file mode 100644
index 00000000000..4ea22e422b0
--- /dev/null
+++ b/source/blender/makesrna/rna_cleanup/rna_properties.txt
@@ -0,0 +1,3190 @@
+Action.fcurves -> fcurves:    collection, (read-only)    The individual F-Curves that make up the Action
+Action.groups -> groups:    collection, (read-only)    Convenient groupings of F-Curves
+Action.pose_markers -> pose_markers:    collection, (read-only)    Markers specific to this Action, for labeling poses
+ActionActuator.action -> action:    pointer    
+ActionActuator.blendin -> blendin:    int    Number of frames of motion blending
+ActionActuator.frame_end -> frame_end:    int    
+ActionActuator.frame_property -> frame_property:    string    Assign the action's current frame number to this property
+ActionActuator.frame_start -> frame_start:    int    
+ActionActuator.mode -> mode:    enum    Action playback type
+ActionActuator.priority -> priority:    int    Execution priority - lower numbers will override actions with higher numbers. With 2 or more actions at once, the overriding channels must be lower in the stack
+ActionActuator.property -> property:    string    Use this property to define the Action position
+ActionConstraint.action -> action:    pointer    
+ActionConstraint.frame_end -> frame_end:    int    Last frame of the Action to use
+ActionConstraint.frame_start -> frame_start:    int    First frame of the Action to use
+ActionConstraint.maximum -> maximum:    float    Maximum value for target channel range
+ActionConstraint.minimum -> minimum:    float    Minimum value for target channel range
+ActionConstraint.subtarget -> subtarget:    string    
+ActionConstraint.target -> target:    pointer    Target Object
+ActionConstraint.transform_channel -> transform_channel:    enum    Transformation channel from the target that is used to key the Action
+ActionGroup.channels -> channels:    collection, (read-only)    F-Curves in this group
+ActionGroup.custom_color -> custom_color:    int    Index of custom color set
+ActionGroup.name -> name:    string    
+Actuator.name -> name:    string    
+Actuator.type -> type:    enum    
+ActuatorSensor.actuator -> actuator:    string    Actuator name, actuator active state modifications will be detected
+Addon.module -> module:    string    Module name
+AnimData.action -> action:    pointer    Active Action for this datablock
+AnimData.action_blending -> action_blending:    enum    Method used for combining Active Action's result with result of NLA stack
+AnimData.action_extrapolation -> action_extrapolation:    enum    Action to take for gaps past the Active Action's range (when evaluating with NLA)
+AnimData.action_influence -> action_influence:    float    Amount the Active Action contributes to the result of the NLA stack
+AnimData.drivers -> drivers:    collection, (read-only)    The Drivers/Expressions for this datablock
+AnimData.nla_tracks -> nla_tracks:    collection, (read-only)    NLA Tracks (i.e. Animation Layers)
+AnimViz.motion_paths -> motion_paths:    pointer, (read-only)    Motion Path settings for visualisation
+AnimViz.onion_skinning -> onion_skinning:    pointer, (read-only)    Onion Skinning (ghosting) settings for visualisation
+AnimVizMotionPaths.after_current -> after_current:    int    Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method)
+AnimVizMotionPaths.bake_location -> bake_location:    enum    When calculating Bone Paths, use Head or Tips
+AnimVizMotionPaths.before_current -> before_current:    int    Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method)
+AnimVizMotionPaths.frame_end -> frame_end:    int    End frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method)
+AnimVizMotionPaths.frame_start -> frame_start:    int    Starting frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method)
+AnimVizMotionPaths.frame_step -> frame_step:    int    Number of frames between paths shown (not for 'On Keyframes' Onion-skinning method)
+AnimVizMotionPaths.type -> type:    enum    Type of range to show for Motion Paths
+AnimVizOnionSkinning.after_current -> after_current:    int    Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method)
+AnimVizOnionSkinning.before_current -> before_current:    int    Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method)
+AnimVizOnionSkinning.frame_end -> frame_end:    int    End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)
+AnimVizOnionSkinning.frame_start -> frame_start:    int    Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)
+AnimVizOnionSkinning.frame_step -> frame_step:    int    Number of frames between ghosts shown (not for 'On Keyframes' Onion-skinning method)
+AnimVizOnionSkinning.type -> type:    enum    Method used for determining what ghosts get drawn
+Area.active_space -> active_space:    pointer, (read-only)    Space currently being displayed in this area
+Area.regions -> regions:    collection, (read-only)    Regions this area is subdivided in
+Area.spaces -> spaces:    collection, (read-only)    Spaces contained in this area, the first space is active
+Area.type -> type:    enum    Space type
+AreaLamp.gamma -> gamma:    float    Light gamma correction value
+AreaLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:    float    Threshold for Adaptive Sampling (Raytraced shadows)
+AreaLamp.shadow_color -> shadow_color:    float    Color of shadows cast by the lamp
+AreaLamp.shadow_method -> shadow_method:    enum    Method to compute lamp shadow with
+AreaLamp.shadow_ray_samples_x -> shadow_ray_samples_x:    int    Amount of samples taken extra (samples x samples)
+AreaLamp.shadow_ray_samples_y -> shadow_ray_samples_y:    int    Amount of samples taken extra (samples x samples)
+AreaLamp.shadow_ray_sampling_method -> shadow_ray_sampling_method:    enum    Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower
+AreaLamp.shadow_soft_size -> shadow_soft_size:    float    Light size for ray shadow sampling (Raytraced shadows)
+AreaLamp.shape -> shape:    enum    Shape of the area lamp
+AreaLamp.size -> size:    float    Size of the area of the area Lamp, X direction size for Rectangle shapes
+AreaLamp.size_y -> size_y:    float    Size of the area of the area Lamp in the Y direction for Rectangle shapes
+Armature.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+Armature.bones -> bones:    collection, (read-only)    
+Armature.drawtype -> drawtype:    enum    
+Armature.edit_bones -> edit_bones:    collection, (read-only)    
+Armature.ghost_frame_end -> ghost_frame_end:    int    End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)
+Armature.ghost_frame_start -> ghost_frame_start:    int    Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)
+Armature.ghost_size -> ghost_size:    int    Frame step for Ghosts (not for 'On Keyframes' Onion-skinning method)
+Armature.ghost_step -> ghost_step:    int    Number of frame steps on either side of current frame to show as ghosts (only for 'Around Current Frame' Onion-skinning method)
+Armature.ghost_type -> ghost_type:    enum    Method of Onion-skinning for active Action
+Armature.pose_position -> pose_position:    enum    Show armature in binding pose or final posed state
+ArmatureActuator.bone -> bone:    string    Bone on which the constraint is defined
+ArmatureActuator.constraint -> constraint:    string    Name of the constraint you want to control
+ArmatureActuator.mode -> mode:    enum    
+ArmatureActuator.secondary_target -> secondary_target:    pointer    Set weight of this constraint
+ArmatureActuator.target -> target:    pointer    Set this object as the target of the constraint
+ArmatureActuator.weight -> weight:    float    Set weight of this constraint
+ArmatureBones.active -> active:    pointer    Armatures active bone
+ArmatureEditBones.active -> active:    pointer    Armatures active edit bone
+ArmatureModifier.object -> object:    pointer    Armature object to deform with
+ArmatureModifier.vertex_group -> vertex_group:    string    Vertex group name
+ArmatureSensor.bone -> bone:    string    Identify the bone to check value from
+ArmatureSensor.constraint -> constraint:    string    Identify the bone constraint to check value from
+ArmatureSensor.test_type -> test_type:    enum    Type of value and test
+ArmatureSensor.value -> value:    float    Specify value to be used in comparison
+ArrayModifier.constant_offset_displacement -> constant_offset_displacement:    float    
+ArrayModifier.count -> count:    int    Number of duplicates to make
+ArrayModifier.curve -> curve:    pointer    Curve object to fit array length to
+ArrayModifier.end_cap -> end_cap:    pointer    Mesh object to use as an end cap
+ArrayModifier.fit_type -> fit_type:    enum    Array length calculation method
+ArrayModifier.length -> length:    float    Length to fit array within
+ArrayModifier.merge_distance -> merge_distance:    float    Limit below which to merge vertices
+ArrayModifier.offset_object -> offset_object:    pointer    
+ArrayModifier.relative_offset_displacement -> relative_offset_displacement:    float    
+ArrayModifier.start_cap -> start_cap:    pointer    Mesh object to use as a start cap
+BackgroundImage.image -> image:    pointer    Image displayed and edited in this space
+BackgroundImage.image_user -> image_user:    pointer, (read-only)    Parameters defining which layer, pass and frame of the image is displayed
+BackgroundImage.offset_x -> offset_x:    float    Offsets image horizontally from the world origin
+BackgroundImage.offset_y -> offset_y:    float    Offsets image vertically from the world origin
+BackgroundImage.size -> size:    float    Scaling factor for the background image
+BackgroundImage.transparency -> transparency:    float    Amount to blend the image against the background color
+BackgroundImage.view_axis -> view_axis:    enum    The axis to display the image on
+BevelModifier.angle -> angle:    float    Angle above which to bevel edges
+BevelModifier.edge_weight_method -> edge_weight_method:    enum    What edge weight to use for weighting a vertex
+BevelModifier.limit_method -> limit_method:    enum    
+BevelModifier.width -> width:    float    Bevel value/amount
+BezierSplinePoint.co -> co:    float    Coordinates of the control point
+BezierSplinePoint.handle1 -> handle1:    float    Coordinates of the first handle
+BezierSplinePoint.handle1_type -> handle1_type:    enum    Handle types
+BezierSplinePoint.handle2 -> handle2:    float    Coordinates of the second handle
+BezierSplinePoint.handle2_type -> handle2_type:    enum    Handle types
+BezierSplinePoint.radius -> radius:    float, (read-only)    Radius for bevelling
+BezierSplinePoint.tilt -> tilt:    float    Tilt in 3D View
+BezierSplinePoint.weight -> weight:    float    Softbody goal weight
+BlendTexture.flip_axis -> flip_axis:    enum    Flips the texture's X and Y axis
+BlendTexture.progression -> progression:    enum    Sets the style of the color blending
+BlenderRNA.structs -> structs:    collection, (read-only)    
+BoidRule.name -> name:    string    Boid rule name
+BoidRule.type -> type:    enum, (read-only)    
+BoidRuleAverageSpeed.level -> level:    float    How much velocity's z-component is kept constant
+BoidRuleAverageSpeed.speed -> speed:    float    Percentage of maximum speed
+BoidRuleAverageSpeed.wander -> wander:    float    How fast velocity's direction is randomized
+BoidRuleAvoid.fear_factor -> fear_factor:    float    Avoid object if danger from it is above this threshold
+BoidRuleAvoid.object -> object:    pointer    Object to avoid
+BoidRuleAvoidCollision.look_ahead -> look_ahead:    float    Time to look ahead in seconds
+BoidRuleFight.distance -> distance:    float    Attack boids at max this distance
+BoidRuleFight.flee_distance -> flee_distance:    float    Flee to this distance
+BoidRuleFollowLeader.distance -> distance:    float    Distance behind leader to follow
+BoidRuleFollowLeader.object -> object:    pointer    Follow this object instead of a boid
+BoidRuleFollowLeader.queue_size -> queue_size:    int    How many boids in a line
+BoidRuleGoal.object -> object:    pointer    Goal object
+BoidSettings.accuracy -> accuracy:    float    Accuracy of attack
+BoidSettings.active_boid_state -> active_boid_state:    pointer, (read-only)    
+BoidSettings.active_boid_state_index -> active_boid_state_index:    int    
+BoidSettings.aggression -> aggression:    float    Boid will fight this times stronger enemy
+BoidSettings.air_max_acc -> air_max_acc:    float    Maximum acceleration in air (relative to maximum speed)
+BoidSettings.air_max_ave -> air_max_ave:    float    Maximum angular velocity in air (relative to 180 degrees)
+BoidSettings.air_max_speed -> air_max_speed:    float    Maximum speed in air
+BoidSettings.air_min_speed -> air_min_speed:    float    Minimum speed in air (relative to maximum speed)
+BoidSettings.air_personal_space -> air_personal_space:    float    Radius of boids personal space in air (% of particle size)
+BoidSettings.banking -> banking:    float    Amount of rotation around velocity vector on turns
+BoidSettings.health -> health:    float    Initial boid health when born
+BoidSettings.height -> height:    float    Boid height relative to particle size
+BoidSettings.land_jump_speed -> land_jump_speed:    float    Maximum speed for jumping
+BoidSettings.land_max_acc -> land_max_acc:    float    Maximum acceleration on land (relative to maximum speed)
+BoidSettings.land_max_ave -> land_max_ave:    float    Maximum angular velocity on land (relative to 180 degrees)
+BoidSettings.land_max_speed -> land_max_speed:    float    Maximum speed on land
+BoidSettings.land_personal_space -> land_personal_space:    float    Radius of boids personal space on land (% of particle size)
+BoidSettings.land_stick_force -> land_stick_force:    float    How strong a force must be to start effecting a boid on land
+BoidSettings.landing_smoothness -> landing_smoothness:    float    How smoothly the boids land
+BoidSettings.range -> range:    float    The maximum distance from which a boid can attack
+BoidSettings.states -> states:    collection, (read-only)    
+BoidSettings.strength -> strength:    float    Maximum caused damage on attack per second
+BoidState.active_boid_rule -> active_boid_rule:    pointer, (read-only)    
+BoidState.active_boid_rule_index -> active_boid_rule_index:    int    
+BoidState.falloff -> falloff:    float    
+BoidState.name -> name:    string    Boid state name
+BoidState.rule_fuzziness -> rule_fuzziness:    float    
+BoidState.rules -> rules:    collection, (read-only)    
+BoidState.ruleset_type -> ruleset_type:    enum    How the rules in the list are evaluated
+BoidState.volume -> volume:    float    
+Bone.bbone_in -> bbone_in:    float    Length of first Bezier Handle (for B-Bones only)
+Bone.bbone_out -> bbone_out:    float    Length of second Bezier Handle (for B-Bones only)
+Bone.bbone_segments -> bbone_segments:    int    Number of subdivisions of bone (for B-Bones only)
+Bone.children -> children:    collection, (read-only)    Bones which are children of this bone
+Bone.envelope_distance -> envelope_distance:    float    Bone deformation distance (for Envelope deform only)
+Bone.envelope_weight -> envelope_weight:    float    Bone deformation weight (for Envelope deform only)
+Bone.head -> head:    float    Location of head end of the bone relative to its parent
+Bone.head_local -> head_local:    float    Location of head end of the bone relative to armature
+Bone.head_radius -> head_radius:    float    Radius of head of bone (for Envelope deform only)
+Bone.matrix -> matrix:    float    3x3 bone matrix
+Bone.matrix_local -> matrix_local:    float    4x4 bone matrix relative to armature
+Bone.name -> name:    string    
+Bone.parent -> parent:    pointer, (read-only)    Parent bone (in same Armature)
+Bone.tail -> tail:    float    Location of tail end of the bone
+Bone.tail_local -> tail_local:    float    Location of tail end of the bone relative to armature
+Bone.tail_radius -> tail_radius:    float    Radius of tail of bone (for Envelope deform only)
+BoneGroup.color_set -> color_set:    enum    Custom color set to use
+BoneGroup.colors -> colors:    pointer, (read-only)    Copy of the colors associated with the group's color set
+BoneGroup.name -> name:    string    
+BooleanModifier.object -> object:    pointer    Mesh object to use for Boolean operation
+BooleanModifier.operation -> operation:    enum    
+BooleanProperty.array_length -> array_length:    int, (read-only)    Maximum length of the array, 0 means unlimited
+Brush.blend -> blend:    enum    Brush blending mode
+Brush.clone_alpha -> clone_alpha:    float    Opacity of clone image display
+Brush.clone_image -> clone_image:    pointer    Image for clone tool
+Brush.clone_offset -> clone_offset:    float    
+Brush.color -> color:    float    
+Brush.curve -> curve:    pointer, (read-only)    Editable falloff curve
+Brush.direction -> direction:    enum    Mapping type to use for this image in the game engine
+Brush.imagepaint_tool -> imagepaint_tool:    enum    
+Brush.jitter -> jitter:    float    Jitter the position of the brush while painting
+Brush.rate -> rate:    float    Interval between paints for Airbrush
+Brush.sculpt_tool -> sculpt_tool:    enum    
+Brush.size -> size:    int    Diameter of the brush
+Brush.smooth_stroke_factor -> smooth_stroke_factor:    float    Higher values give a smoother stroke
+Brush.smooth_stroke_radius -> smooth_stroke_radius:    int    Minimum distance from last point before stroke continues
+Brush.spacing -> spacing:    float    Spacing between brush stamps
+Brush.strength -> strength:    float    The amount of pressure on the brush
+Brush.texture -> texture:    pointer    
+Brush.texture_slot -> texture_slot:    pointer, (read-only)    
+Brush.vertexpaint_tool -> vertexpaint_tool:    enum    
+BrushTextureSlot.angle -> angle:    float    Defines brush texture rotation
+BrushTextureSlot.map_mode -> map_mode:    enum    
+BuildModifier.frame_start -> frame_start:    float    Specify the start frame of the effect
+BuildModifier.length -> length:    float    Specify the total time the build effect requires
+BuildModifier.seed -> seed:    int    Specify the seed for random if used
+Camera.angle -> angle:    float    Perspective Camera lens field of view in degrees
+Camera.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+Camera.clip_end -> clip_end:    float    Camera far clipping distance
+Camera.clip_start -> clip_start:    float    Camera near clipping distance
+Camera.dof_distance -> dof_distance:    float    Distance to the focus point for depth of field
+Camera.dof_object -> dof_object:    pointer    Use this object to define the depth of field focal point
+Camera.draw_size -> draw_size:    float    Apparent size of the Camera object in the 3D View
+Camera.lens -> lens:    float    Perspective Camera lens value in millimeters
+Camera.lens_unit -> lens_unit:    enum    Unit to edit lens in for the user interface
+Camera.ortho_scale -> ortho_scale:    float    Orthographic Camera scale (similar to zoom)
+Camera.passepartout_alpha -> passepartout_alpha:    float    Opacity (alpha) of the darkened overlay in Camera view
+Camera.shift_x -> shift_x:    float    Perspective Camera horizontal shift
+Camera.shift_y -> shift_y:    float    Perspective Camera vertical shift
+Camera.type -> type:    enum    Camera types
+CameraActuator.axis -> axis:    enum    Specify the axis the Camera will try to get behind
+CameraActuator.height -> height:    float    
+CameraActuator.max -> max:    float    
+CameraActuator.min -> min:    float    
+CameraActuator.object -> object:    pointer    Look at this Object
+CastModifier.cast_type -> cast_type:    enum    
+CastModifier.factor -> factor:    float    
+CastModifier.object -> object:    pointer    Control object: if available, its location determines the center of the effect
+CastModifier.radius -> radius:    float    Only deform vertices within this distance from the center of the effect (leave as 0 for infinite.)
+CastModifier.size -> size:    float    Size of projection shape (leave as 0 for auto.)
+CastModifier.vertex_group -> vertex_group:    string    Vertex group name
+ChildOfConstraint.subtarget -> subtarget:    string    
+ChildOfConstraint.target -> target:    pointer    Target Object
+ClampToConstraint.main_axis -> main_axis:    enum    Main axis of movement
+ClampToConstraint.target -> target:    pointer    Target Object
+ClothCollisionSettings.collision_quality -> collision_quality:    int    How many collision iterations should be done. (higher is better quality but slower)
+ClothCollisionSettings.friction -> friction:    float    Friction force if a collision happened. (higher = less movement)
+ClothCollisionSettings.group -> group:    pointer    Limit colliders to this Group
+ClothCollisionSettings.min_distance -> min_distance:    float    Minimum distance between collision objects before collision response takes in
+ClothCollisionSettings.self_collision_quality -> self_collision_quality:    int    How many self collision iterations should be done. (higher is better quality but slower)
+ClothCollisionSettings.self_friction -> self_friction:    float    Friction/damping with self contact
+ClothCollisionSettings.self_min_distance -> self_min_distance:    float    0.5 means no distance at all, 1.0 is maximum distance
+ClothModifier.collision_settings -> collision_settings:    pointer, (read-only)    
+ClothModifier.point_cache -> point_cache:    pointer, (read-only)    
+ClothModifier.settings -> settings:    pointer, (read-only)    
+ClothSettings.air_damping -> air_damping:    float    Air has normally some thickness which slows falling things down
+ClothSettings.bending_stiffness -> bending_stiffness:    float    Wrinkle coefficient. (higher = less smaller but more big wrinkles)
+ClothSettings.bending_stiffness_max -> bending_stiffness_max:    float    Maximum bending stiffness value
+ClothSettings.bending_vertex_group -> bending_vertex_group:    string    Vertex group for fine control over bending stiffness
+ClothSettings.collider_friction -> collider_friction:    float    
+ClothSettings.effector_weights -> effector_weights:    pointer, (read-only)    
+ClothSettings.goal_default -> goal_default:    float    Default Goal (vertex target position) value, when no Vertex Group used
+ClothSettings.goal_friction -> goal_friction:    float    Goal (vertex target position) friction
+ClothSettings.goal_max -> goal_max:    float    Goal maximum, vertex group weights are scaled to match this range
+ClothSettings.goal_min -> goal_min:    float    Goal minimum, vertex group weights are scaled to match this range
+ClothSettings.goal_spring -> goal_spring:    float    Goal (vertex target position) spring stiffness
+ClothSettings.gravity -> gravity:    float    Gravity or external force vector
+ClothSettings.internal_friction -> internal_friction:    float    
+ClothSettings.mass -> mass:    float    Mass of cloth material
+ClothSettings.mass_vertex_group -> mass_vertex_group:    string    Vertex Group for pinning of vertices
+ClothSettings.pin_stiffness -> pin_stiffness:    float    Pin (vertex target position) spring stiffness
+ClothSettings.pre_roll -> pre_roll:    int    Simulation starts on this frame
+ClothSettings.quality -> quality:    int    Quality of the simulation in steps per frame. (higher is better quality but slower)
+ClothSettings.rest_shape_key -> rest_shape_key:    pointer    Shape key to use the rest spring lengths from
+ClothSettings.spring_damping -> spring_damping:    float    Damping of cloth velocity. (higher = more smooth, less jiggling)
+ClothSettings.structural_stiffness -> structural_stiffness:    float    Overall stiffness of structure
+ClothSettings.structural_stiffness_max -> structural_stiffness_max:    float    Maximum structural stiffness value
+ClothSettings.structural_stiffness_vertex_group -> structural_stiffness_vertex_group:    string    Vertex group for fine control over structural stiffness
+CloudsTexture.nabla -> nabla:    float    Size of derivative offset used for calculating normal
+CloudsTexture.noise_basis -> noise_basis:    enum    Sets the noise basis used for turbulence
+CloudsTexture.noise_depth -> noise_depth:    int    Sets the depth of the cloud calculation
+CloudsTexture.noise_size -> noise_size:    float    Sets scaling for noise input
+CloudsTexture.noise_type -> noise_type:    enum    
+CloudsTexture.stype -> stype:    enum    
+CollectionProperty.fixed_type -> fixed_type:    pointer, (read-only)    Fixed pointer type, empty if variable type
+CollisionModifier.settings -> settings:    pointer, (read-only)    
+CollisionSensor.material -> material:    string    Only look for Objects with this material
+CollisionSensor.property -> property:    string    Only look for Objects with this property
+CollisionSettings.absorption -> absorption:    float    How much of effector force gets lost during collision with this object (in percent)
+CollisionSettings.damping -> damping:    float    Amount of damping during collision
+CollisionSettings.damping_factor -> damping_factor:    float    Amount of damping during particle collision
+CollisionSettings.friction_factor -> friction_factor:    float    Amount of friction during particle collision
+CollisionSettings.inner_thickness -> inner_thickness:    float    Inner face thickness
+CollisionSettings.outer_thickness -> outer_thickness:    float    Outer face thickness
+CollisionSettings.permeability -> permeability:    float    Chance that the particle will pass through the mesh
+CollisionSettings.random_damping -> random_damping:    float    Random variation of damping
+CollisionSettings.random_friction -> random_friction:    float    Random variation of friction
+CollisionSettings.stickness -> stickness:    float    Amount of stickness to surface collision
+ColorRamp.elements -> elements:    collection, (read-only)    
+ColorRamp.interpolation -> interpolation:    enum    
+ColorRampElement.color -> color:    float    
+ColorRampElement.position -> position:    float    
+ColorSequence.color -> color:    float    
+CompositorNode.type -> type:    enum, (read-only)    
+CompositorNodeAlphaOver.premul -> premul:    float    Mix Factor
+CompositorNodeBilateralblur.iterations -> iterations:    int    
+CompositorNodeBilateralblur.sigma_color -> sigma_color:    float    
+CompositorNodeBilateralblur.sigma_space -> sigma_space:    float    
+CompositorNodeBlur.factor -> factor:    float    
+CompositorNodeBlur.factor_x -> factor_x:    float    
+CompositorNodeBlur.factor_y -> factor_y:    float    
+CompositorNodeBlur.filter_type -> filter_type:    enum    
+CompositorNodeBlur.sizex -> sizex:    int    
+CompositorNodeBlur.sizey -> sizey:    int    
+CompositorNodeChannelMatte.algorithm -> algorithm:    enum    Algorithm to use to limit channel
+CompositorNodeChannelMatte.channel -> channel:    enum    Channel used to determine matte
+CompositorNodeChannelMatte.color_space -> color_space:    enum    
+CompositorNodeChannelMatte.high -> high:    float    Values higher than this setting are 100% opaque
+CompositorNodeChannelMatte.limit_channel -> limit_channel:    enum    Limit by this channels value
+CompositorNodeChannelMatte.low -> low:    float    Values lower than this setting are 100% keyed
+CompositorNodeChromaMatte.acceptance -> acceptance:    float    Tolerance for a color to be considered a keying color
+CompositorNodeChromaMatte.cutoff -> cutoff:    float    Tolerance below which colors will be considered as exact matches
+CompositorNodeChromaMatte.gain -> gain:    float    Alpha gain
+CompositorNodeChromaMatte.lift -> lift:    float    Alpha lift
+CompositorNodeChromaMatte.shadow_adjust -> shadow_adjust:    float    Adjusts the brightness of any shadows captured
+CompositorNodeColorBalance.correction_formula -> correction_formula:    enum    
+CompositorNodeColorBalance.gain -> gain:    float    Correction for Highlights
+CompositorNodeColorBalance.gamma -> gamma:    float    Correction for Midtones
+CompositorNodeColorBalance.lift -> lift:    float    Correction for Shadows
+CompositorNodeColorBalance.offset -> offset:    float    Correction for Shadows
+CompositorNodeColorBalance.power -> power:    float    Correction for Midtones
+CompositorNodeColorBalance.slope -> slope:    float    Correction for Highlights
+CompositorNodeColorMatte.h -> h:    float    Hue tolerance for colors to be considered a keying color
+CompositorNodeColorMatte.s -> s:    float    Saturation Tolerance for the color
+CompositorNodeColorMatte.v -> v:    float    Value Tolerance for the color
+CompositorNodeColorSpill.algorithm -> algorithm:    enum    
+CompositorNodeColorSpill.channel -> channel:    enum    
+CompositorNodeColorSpill.limit_channel -> limit_channel:    enum    
+CompositorNodeColorSpill.ratio -> ratio:    float    Scale limit by value
+CompositorNodeColorSpill.unspill_blue -> unspill_blue:    float    Blue spillmap scale
+CompositorNodeColorSpill.unspill_green -> unspill_green:    float    Green spillmap scale
+CompositorNodeColorSpill.unspill_red -> unspill_red:    float    Red spillmap scale
+CompositorNodeCrop.x1 -> x1:    int    
+CompositorNodeCrop.x2 -> x2:    int    
+CompositorNodeCrop.y1 -> y1:    int    
+CompositorNodeCrop.y2 -> y2:    int    
+CompositorNodeCurveRGB.mapping -> mapping:    pointer, (read-only)    
+CompositorNodeCurveVec.mapping -> mapping:    pointer, (read-only)    
+CompositorNodeDBlur.angle -> angle:    float    
+CompositorNodeDBlur.center_x -> center_x:    float    
+CompositorNodeDBlur.center_y -> center_y:    float    
+CompositorNodeDBlur.distance -> distance:    float    
+CompositorNodeDBlur.iterations -> iterations:    int    
+CompositorNodeDBlur.spin -> spin:    float    
+CompositorNodeDBlur.zoom -> zoom:    float    
+CompositorNodeDefocus.angle -> angle:    int    Bokeh shape rotation offset in degrees
+CompositorNodeDefocus.bokeh -> bokeh:    enum    
+CompositorNodeDefocus.f_stop -> f_stop:    float    Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius
+CompositorNodeDefocus.max_blur -> max_blur:    float    blur limit, maximum CoC radius, 0=no limit
+CompositorNodeDefocus.samples -> samples:    int    Number of samples (16=grainy, higher=less noise)
+CompositorNodeDefocus.threshold -> threshold:    float    CoC radius threshold, prevents background bleed on in-focus midground, 0=off
+CompositorNodeDefocus.z_scale -> z_scale:    float    Scales the Z input when not using a zbuffer, controls maximum blur designated by the color white or input value 1
+CompositorNodeDiffMatte.falloff -> falloff:    float    Color distances below this additional threshold are partially keyed
+CompositorNodeDiffMatte.tolerance -> tolerance:    float    Color distances below this threshold are keyed
+CompositorNodeDilateErode.distance -> distance:    int    Distance to grow/shrink (number of iterations)
+CompositorNodeDistanceMatte.falloff -> falloff:    float    Color distances below this additional threshold are partially keyed
+CompositorNodeDistanceMatte.tolerance -> tolerance:    float    Color distances below this threshold are keyed
+CompositorNodeFilter.filter_type -> filter_type:    enum    
+CompositorNodeFlip.axis -> axis:    enum    
+CompositorNodeGlare.angle_offset -> angle_offset:    float    Streak angle offset in degrees
+CompositorNodeGlare.color_modulation -> color_modulation:    float    Amount of Color Modulation, modulates colors of streaks and ghosts for a spectral dispersion effect
+CompositorNodeGlare.fade -> fade:    float    Streak fade-out factor
+CompositorNodeGlare.glare_type -> glare_type:    enum    
+CompositorNodeGlare.iterations -> iterations:    int    
+CompositorNodeGlare.mix -> mix:    float    -1 is original image only, 0 is exact 50/50 mix, 1 is processed image only
+CompositorNodeGlare.quality -> quality:    enum    If not set to high quality, the effect will be applied to a low-res copy of the source image
+CompositorNodeGlare.size -> size:    int    Glow/glare size (not actual size; relative to initial size of bright area of pixels)
+CompositorNodeGlare.streaks -> streaks:    int    Total number of streaks
+CompositorNodeGlare.threshold -> threshold:    float    The glare filter will only be applied to pixels brighter than this value
+CompositorNodeHueCorrect.mapping -> mapping:    pointer, (read-only)    
+CompositorNodeHueSat.hue -> hue:    float    
+CompositorNodeHueSat.sat -> sat:    float    
+CompositorNodeHueSat.val -> val:    float    
+CompositorNodeIDMask.index -> index:    int    Pass index number to convert to alpha
+CompositorNodeImage.frames -> frames:    int    Number of images used in animation
+CompositorNodeImage.image -> image:    pointer    
+CompositorNodeImage.layer -> layer:    enum    
+CompositorNodeImage.offset -> offset:    int    Offsets the number of the frame to use in the animation
+CompositorNodeImage.start -> start:    int    
+CompositorNodeLevels.channel -> channel:    enum    
+CompositorNodeLumaMatte.high -> high:    float    Values higher than this setting are 100% opaque
+CompositorNodeLumaMatte.low -> low:    float    Values lower than this setting are 100% keyed
+CompositorNodeMapUV.alpha -> alpha:    int    
+CompositorNodeMapValue.max -> max:    float    
+CompositorNodeMapValue.min -> min:    float    
+CompositorNodeMapValue.offset -> offset:    float    
+CompositorNodeMapValue.size -> size:    float    
+CompositorNodeMath.operation -> operation:    enum    
+CompositorNodeMixRGB.blend_type -> blend_type:    enum    
+CompositorNodeOutputFile.exr_codec -> exr_codec:    enum    
+CompositorNodeOutputFile.filepath -> filepath:    string    Output path for the image, same functionality as render output.
+CompositorNodeOutputFile.frame_end -> frame_end:    int    
+CompositorNodeOutputFile.frame_start -> frame_start:    int    
+CompositorNodeOutputFile.image_type -> image_type:    enum    
+CompositorNodeOutputFile.quality -> quality:    int    
+CompositorNodePremulKey.mapping -> mapping:    enum    Conversion between premultiplied alpha and key alpha
+CompositorNodeRLayers.layer -> layer:    enum    
+CompositorNodeRLayers.scene -> scene:    pointer    
+CompositorNodeRotate.filter -> filter:    enum    Method to use to filter rotation
+CompositorNodeScale.space -> space:    enum    Coordinate space to scale relative to
+CompositorNodeSplitViewer.axis -> axis:    enum    
+CompositorNodeSplitViewer.factor -> factor:    int    
+CompositorNodeTexture.node_output -> node_output:    int    For node-based textures, which output node to use
+CompositorNodeTexture.texture -> texture:    pointer    
+CompositorNodeTime.curve -> curve:    pointer, (read-only)    
+CompositorNodeTime.end -> end:    int    
+CompositorNodeTime.start -> start:    int    
+CompositorNodeTonemap.adaptation -> adaptation:    float    If 0, global; if 1, based on pixel intensity
+CompositorNodeTonemap.contrast -> contrast:    float    Set to 0 to use estimate from input image
+CompositorNodeTonemap.correction -> correction:    float    If 0, same for all channels; if 1, each independent
+CompositorNodeTonemap.gamma -> gamma:    float    If not used, set to 1
+CompositorNodeTonemap.intensity -> intensity:    float    If less than zero, darkens image; otherwise, makes it brighter
+CompositorNodeTonemap.key -> key:    float    The value the average luminance is mapped to
+CompositorNodeTonemap.offset -> offset:    float    Normally always 1, but can be used as an extra control to alter the brightness curve
+CompositorNodeTonemap.tonemap_type -> tonemap_type:    enum    
+CompositorNodeValToRGB.color_ramp -> color_ramp:    pointer, (read-only)    
+CompositorNodeVecBlur.factor -> factor:    float    Scaling factor for motion vectors; actually 'shutter speed' in frames
+CompositorNodeVecBlur.max_speed -> max_speed:    int    Maximum speed, or zero for none
+CompositorNodeVecBlur.min_speed -> min_speed:    int    Minimum speed for a pixel to be blurred; used to separate background from foreground
+CompositorNodeVecBlur.samples -> samples:    int    
+ConsoleLine.current_character -> current_character:    int    
+ConsoleLine.line -> line:    string    Text in the line
+Constraint.influence -> influence:    float    Amount of influence constraint will have on the final solution
+Constraint.lin_error -> lin_error:    float, (read-only)    Amount of residual error in Blender space unit for constraints that work on position
+Constraint.name -> name:    string    Constraint name
+Constraint.owner_space -> owner_space:    enum    Space that owner is evaluated in
+Constraint.rot_error -> rot_error:    float, (read-only)    Amount of residual error in radiant for constraints that work on orientation
+Constraint.target_space -> target_space:    enum    Space that target is evaluated in
+Constraint.type -> type:    enum, (read-only)    
+ConstraintActuator.damping -> damping:    int    Damping factor: time constant (in frame) of low pass filter
+ConstraintActuator.damping_rotation -> damping_rotation:    int    Use a different damping for orientation
+ConstraintActuator.direction -> direction:    enum    Set the direction of the ray
+ConstraintActuator.direction_axis -> direction_axis:    enum    Select the axis to be aligned along the reference direction
+ConstraintActuator.distance -> distance:    float    Set the maximum length of ray
+ConstraintActuator.fh_damping -> fh_damping:    float    Damping factor of the Fh spring force
+ConstraintActuator.fh_height -> fh_height:    float    Height of the Fh area
+ConstraintActuator.limit -> limit:    enum    
+ConstraintActuator.limit_max -> limit_max:    float    
+ConstraintActuator.limit_min -> limit_min:    float    
+ConstraintActuator.material -> material:    string    Ray detects only Objects with this material
+ConstraintActuator.max_angle -> max_angle:    float    Maximum angle (in degree) allowed with target direction. No correction is done if angle with target direction is between min and max
+ConstraintActuator.max_rotation -> max_rotation:    float    Reference Direction
+ConstraintActuator.min_angle -> min_angle:    float    Minimum angle (in degree) to maintain with target direction. No correction is done if angle with target direction is between min and max
+ConstraintActuator.mode -> mode:    enum    The type of the constraint
+ConstraintActuator.property -> property:    string    Ray detect only Objects with this property
+ConstraintActuator.range -> range:    float    Set the maximum length of ray
+ConstraintActuator.spring -> spring:    float    Spring force within the Fh area
+ConstraintActuator.time -> time:    int    Maximum activation time in frame, 0 for unlimited
+ConstraintTarget.subtarget -> subtarget:    string    
+ConstraintTarget.target -> target:    pointer    Target Object
+Context.area -> area:    pointer, (read-only)    
+Context.main -> main:    pointer, (read-only)    
+Context.manager -> manager:    pointer, (read-only)    
+Context.mode -> mode:    enum, (read-only)    
+Context.region -> region:    pointer, (read-only)    
+Context.scene -> scene:    pointer, (read-only)    
+Context.screen -> screen:    pointer, (read-only)    
+Context.space_data -> space_data:    pointer, (read-only)    
+Context.tool_settings -> tool_settings:    pointer, (read-only)    
+Context.user_preferences -> user_preferences:    pointer, (read-only)    
+Context.window -> window:    pointer, (read-only)    
+ControlFluidSettings.attraction_radius -> attraction_radius:    float    Specifies the force field radius around the control object
+ControlFluidSettings.attraction_strength -> attraction_strength:    float    Force strength for directional attraction towards the control object
+ControlFluidSettings.end_time -> end_time:    float    Specifies time when the control particles are deactivated
+ControlFluidSettings.quality -> quality:    float    Specifies the quality which is used for object sampling. (higher = better but slower)
+ControlFluidSettings.start_time -> start_time:    float    Specifies time when the control particles are activated
+ControlFluidSettings.velocity_radius -> velocity_radius:    float    Specifies the force field radius around the control object
+ControlFluidSettings.velocity_strength -> velocity_strength:    float    Force strength of how much of the control object's velocity is influencing the fluid velocity
+Controller.name -> name:    string    
+Controller.state_number -> state_number:    int    Set Controller state index (1 to 30)
+Controller.type -> type:    enum    
+CopyLocationConstraint.head_tail -> head_tail:    float    Target along length of bone: Head=0, Tail=1
+CopyLocationConstraint.subtarget -> subtarget:    string    
+CopyLocationConstraint.target -> target:    pointer    Target Object
+CopyRotationConstraint.subtarget -> subtarget:    string    
+CopyRotationConstraint.target -> target:    pointer    Target Object
+CopyScaleConstraint.subtarget -> subtarget:    string    
+CopyScaleConstraint.target -> target:    pointer    Target Object
+CopyTransformsConstraint.head_tail -> head_tail:    float    Target along length of bone: Head=0, Tail=1
+CopyTransformsConstraint.subtarget -> subtarget:    string    
+CopyTransformsConstraint.target -> target:    pointer    Target Object
+Curve.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+Curve.bevel_depth -> bevel_depth:    float    Bevel depth when not using a bevel object
+Curve.bevel_object -> bevel_object:    pointer    Curve object name that defines the bevel shape
+Curve.bevel_resolution -> bevel_resolution:    int    Bevel resolution when depth is non-zero and no specific bevel object has been defined
+Curve.dimensions -> dimensions:    enum    Select 2D or 3D curve type
+Curve.eval_time -> 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
+Curve.extrude -> extrude:    float    Amount of curve extrusion when not using a bevel object
+Curve.materials -> materials:    collection, (read-only)    
+Curve.path_length -> path_length:    int    The number of frames that are needed to traverse the path, defining the maximum value for the 'Evaluation Time' setting
+Curve.render_resolution_u -> render_resolution_u:    int    Surface resolution in U direction used while rendering. Zero skips this property
+Curve.render_resolution_v -> render_resolution_v:    int    Surface resolution in V direction used while rendering. Zero skips this property
+Curve.resolution_u -> resolution_u:    int    Surface resolution in U direction
+Curve.resolution_v -> resolution_v:    int    Surface resolution in V direction
+Curve.shape_keys -> shape_keys:    pointer, (read-only)    
+Curve.splines -> splines:    collection, (read-only)    Collection of splines in this curve data object
+Curve.taper_object -> taper_object:    pointer    Curve object name that defines the taper (width)
+Curve.texspace_loc -> texspace_loc:    float    Texture space location
+Curve.texspace_size -> texspace_size:    float    Texture space size
+Curve.twist_mode -> twist_mode:    enum    The type of tilt calculation for 3D Curves
+Curve.twist_smooth -> twist_smooth:    float    Smoothing iteration for tangents
+Curve.width -> width:    float    Scale the original width (1.0) based on given factor
+CurveMap.extend -> extend:    enum, (read-only)    Extrapolate the curve or extend it horizontally
+CurveMap.points -> points:    collection, (read-only)    
+CurveMapPoint.handle_type -> handle_type:    enum, (read-only)    Curve interpolation at this point: bezier or vector
+CurveMapPoint.location -> location:    float, (read-only)    X/Y coordinates of the curve point
+CurveMapping.black_level -> black_level:    float    For RGB curves, the color that black is mapped to
+CurveMapping.clip_max_x -> clip_max_x:    float    
+CurveMapping.clip_max_y -> clip_max_y:    float    
+CurveMapping.clip_min_x -> clip_min_x:    float    
+CurveMapping.clip_min_y -> clip_min_y:    float    
+CurveMapping.curves -> curves:    collection, (read-only)    
+CurveMapping.white_level -> white_level:    float    For RGB curves, the color that white is mapped to
+CurveModifier.deform_axis -> deform_axis:    enum    The axis that the curve deforms along
+CurveModifier.object -> object:    pointer    Curve object to deform with
+CurveModifier.vertex_group -> vertex_group:    string    Vertex group name
+CurveSplines.active -> active:    pointer    Active curve spline
+DampedTrackConstraint.subtarget -> subtarget:    string    
+DampedTrackConstraint.target -> target:    pointer    Target Object
+DampedTrackConstraint.track -> track:    enum    Axis that points to the target object
+DecimateModifier.face_count -> face_count:    int, (read-only)    The current number of faces in the decimated mesh
+DecimateModifier.ratio -> ratio:    float    Defines the ratio of triangles to reduce to
+DelaySensor.delay -> delay:    int    Delay in number of logic tics before the positive trigger (default 60 per second)
+DelaySensor.duration -> duration:    int    If >0, delay in number of logic tics before the negative trigger following the positive trigger
+DisplaceModifier.direction -> direction:    enum    
+DisplaceModifier.midlevel -> midlevel:    float    Material value that gives no displacement
+DisplaceModifier.strength -> strength:    float    
+DisplaceModifier.texture -> texture:    pointer    
+DisplaceModifier.texture_coordinate_object -> texture_coordinate_object:    pointer    
+DisplaceModifier.texture_coordinates -> texture_coordinates:    enum    
+DisplaceModifier.uv_layer -> uv_layer:    string    UV layer name
+DisplaceModifier.vertex_group -> vertex_group:    string    Vertex group name
+DistortedNoiseTexture.distortion -> distortion:    float    
+DistortedNoiseTexture.nabla -> nabla:    float    Size of derivative offset used for calculating normal
+DistortedNoiseTexture.noise_basis -> noise_basis:    enum    Sets the noise basis used for turbulence
+DistortedNoiseTexture.noise_distortion -> noise_distortion:    enum    Sets the noise basis for the distortion
+DistortedNoiseTexture.noise_size -> noise_size:    float    Sets scaling for noise input
+DomainFluidSettings.compressibility -> compressibility:    float    Allowed compressibility due to gravitational force for standing fluid. (directly affects simulation step size)
+DomainFluidSettings.end_time -> end_time:    float    Simulation time of the last blender frame
+DomainFluidSettings.generate_particles -> generate_particles:    float    Amount of particles to generate (0=off, 1=normal, >1=more)
+DomainFluidSettings.gravity -> gravity:    float    Gravity in X, Y and Z direction
+DomainFluidSettings.grid_levels -> grid_levels:    int    Number of coarsened grids to use (-1 for automatic)
+DomainFluidSettings.memory_estimate -> memory_estimate:    string, (read-only)    Estimated amount of memory needed for baking the domain
+DomainFluidSettings.partial_slip_factor -> partial_slip_factor:    float    Amount of mixing between no- and free-slip, 0 is no slip and 1 is free slip
+DomainFluidSettings.path -> path:    string    Directory (and/or filename prefix) to store baked fluid simulation files in
+DomainFluidSettings.preview_resolution -> preview_resolution:    int    Preview resolution in X,Y and Z direction
+DomainFluidSettings.real_world_size -> real_world_size:    float    Size of the simulation domain in metres
+DomainFluidSettings.render_display_mode -> render_display_mode:    enum    How to display the mesh for rendering
+DomainFluidSettings.resolution -> resolution:    int    Domain resolution in X,Y and Z direction
+DomainFluidSettings.slip_type -> slip_type:    enum    
+DomainFluidSettings.start_time -> start_time:    float    Simulation time of the first blender frame
+DomainFluidSettings.surface_smoothing -> surface_smoothing:    float    Amount of surface smoothing. A value of 0 is off, 1 is normal smoothing and more than 1 is extra smoothing
+DomainFluidSettings.surface_subdivisions -> surface_subdivisions:    int    Number of isosurface subdivisions. This is necessary for the inclusion of particles into the surface generation. Warning - can lead to longer computation times!
+DomainFluidSettings.tracer_particles -> tracer_particles:    int    Number of tracer particles to generate
+DomainFluidSettings.viewport_display_mode -> viewport_display_mode:    enum    How to display the mesh in the viewport
+DomainFluidSettings.viscosity_base -> viscosity_base:    float    Viscosity setting: value that is multiplied by 10 to the power of (exponent*-1)
+DomainFluidSettings.viscosity_exponent -> viscosity_exponent:    int    Negative exponent for the viscosity value (to simplify entering small values e.g. 5*10^-6.)
+DomainFluidSettings.viscosity_preset -> viscosity_preset:    enum    Set viscosity of the fluid to a preset value, or use manual input
+DopeSheet.filtering_group -> filtering_group:    pointer    Group that included Object should be a member of
+DopeSheet.source -> source:    pointer, (read-only)    ID-Block representing source data, currently ID_SCE (for Dopesheet), and ID_SC (for Grease Pencil)
+Driver.expression -> expression:    string    Expression to use for Scripted Expression
+Driver.type -> type:    enum    Driver type
+Driver.variables -> variables:    collection, (read-only)    Properties acting as inputs for this driver
+DriverTarget.bone_target -> bone_target:    string    Name of PoseBone to use as target
+DriverTarget.data_path -> data_path:    string    RNA Path (from ID-block) to property used
+DriverTarget.id -> id:    pointer    ID-block that the specific property used can be found from (id_type property must be set first)
+DriverTarget.id_type -> id_type:    enum    Type of ID-block that can be used
+DriverTarget.transform_type -> transform_type:    enum    Driver variable type
+DriverVariable.name -> name:    string    Name to use in scripted expressions/functions. (No spaces or dots are allowed. Also, must not start with a symbol or digit)
+DriverVariable.targets -> targets:    collection, (read-only)    Sources of input data for evaluating this variable
+DriverVariable.type -> type:    enum    Driver variable type
+DupliObject.matrix -> matrix:    float    Object duplicate transformation matrix
+DupliObject.object -> object:    pointer, (read-only)    Object being duplicated
+DupliObject.object_matrix -> object_matrix:    float    Duplicated object transformation matrix
+EdgeSplitModifier.split_angle -> split_angle:    float    Angle above which to split edges
+EditBone.bbone_in -> bbone_in:    float    Length of first Bezier Handle (for B-Bones only)
+EditBone.bbone_out -> bbone_out:    float    Length of second Bezier Handle (for B-Bones only)
+EditBone.bbone_segments -> bbone_segments:    int    Number of subdivisions of bone (for B-Bones only)
+EditBone.envelope_distance -> envelope_distance:    float    Bone deformation distance (for Envelope deform only)
+EditBone.envelope_weight -> envelope_weight:    float    Bone deformation weight (for Envelope deform only)
+EditBone.head -> head:    float    Location of head end of the bone
+EditBone.head_radius -> head_radius:    float    Radius of head of bone (for Envelope deform only)
+EditBone.matrix -> matrix:    float, (read-only)    Read-only matrix calculated from the roll (armature space)
+EditBone.name -> name:    string    
+EditBone.parent -> parent:    pointer    Parent edit bone (in same Armature)
+EditBone.roll -> roll:    float    Bone rotation around head-tail axis
+EditBone.tail -> tail:    float    Location of tail end of the bone
+EditBone.tail_radius -> tail_radius:    float    Radius of tail of bone (for Envelope deform only)
+EditObjectActuator.angular_velocity -> angular_velocity:    float    Angular velocity upon creation
+EditObjectActuator.dynamic_operation -> dynamic_operation:    enum    
+EditObjectActuator.linear_velocity -> linear_velocity:    float    Velocity upon creation
+EditObjectActuator.mass -> mass:    float    The mass of the object
+EditObjectActuator.mesh -> mesh:    pointer    Replace the existing, when left blank 'Phys' will remake the existing physics mesh
+EditObjectActuator.mode -> mode:    enum    The mode of the actuator
+EditObjectActuator.object -> object:    pointer    Add this Object and all its children (cant be on an visible layer)
+EditObjectActuator.time -> time:    int    Duration the new Object lives or the track takes
+EditObjectActuator.track_object -> track_object:    pointer    Track to this Object
+EffectSequence.color_balance -> color_balance:    pointer, (read-only)    
+EffectSequence.crop -> crop:    pointer, (read-only)    
+EffectSequence.multiply_colors -> multiply_colors:    float    
+EffectSequence.proxy -> proxy:    pointer, (read-only)    
+EffectSequence.strobe -> strobe:    float    Only display every nth frame
+EffectSequence.transform -> transform:    pointer, (read-only)    
+EffectorWeights.all -> all:    float    All effector's weight
+EffectorWeights.boid -> boid:    float    Boid effector weight
+EffectorWeights.charge -> charge:    float    Charge effector weight
+EffectorWeights.curveguide -> curveguide:    float    Curve guide effector weight
+EffectorWeights.drag -> drag:    float    Drag effector weight
+EffectorWeights.force -> force:    float    Force effector weight
+EffectorWeights.gravity -> gravity:    float    Global gravity weight
+EffectorWeights.group -> group:    pointer    Limit effectors to this Group
+EffectorWeights.harmonic -> harmonic:    float    Harmonic effector weight
+EffectorWeights.lennardjones -> lennardjones:    float    Lennard-Jones effector weight
+EffectorWeights.magnetic -> magnetic:    float    Magnetic effector weight
+EffectorWeights.texture -> texture:    float    Texture effector weight
+EffectorWeights.turbulence -> turbulence:    float    Turbulence effector weight
+EffectorWeights.vortex -> vortex:    float    Vortex effector weight
+EffectorWeights.wind -> wind:    float    Wind effector weight
+EnumProperty.default -> default:    enum, (read-only)    Default value for this enum
+EnumProperty.items -> items:    collection, (read-only)    Possible values for the property
+EnumPropertyItem.description -> description:    string, (read-only)    Description of the item's purpose
+EnumPropertyItem.identifier -> identifier:    string, (read-only)    Unique name used in the code and scripting
+EnumPropertyItem.name -> name:    string, (read-only)    Human readable name
+EnumPropertyItem.value -> value:    int, (read-only)    Value of the item
+EnvironmentMap.clip_end -> clip_end:    float    Objects further than this are not visible to map
+EnvironmentMap.clip_start -> clip_start:    float    Objects nearer than this are not visible to map
+EnvironmentMap.depth -> depth:    int    Number of times a map will be rendered recursively (mirror effects.)
+EnvironmentMap.mapping -> mapping:    enum    
+EnvironmentMap.resolution -> resolution:    int    Pixel resolution of the rendered environment map
+EnvironmentMap.source -> source:    enum    
+EnvironmentMap.viewpoint_object -> viewpoint_object:    pointer    Object to use as the environment map's viewpoint location
+EnvironmentMap.zoom -> zoom:    float    
+EnvironmentMapTexture.environment_map -> environment_map:    pointer, (read-only)    Gets the environment map associated with this texture
+EnvironmentMapTexture.filter -> filter:    enum    Texture filter to use for sampling image
+EnvironmentMapTexture.filter_eccentricity -> filter_eccentricity:    int    Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower
+EnvironmentMapTexture.filter_probes -> filter_probes:    int    Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower
+EnvironmentMapTexture.filter_size -> filter_size:    float    Multiplies the filter size used by MIP Map and Interpolation
+EnvironmentMapTexture.image -> image:    pointer    Source image file to read the environment map from
+EnvironmentMapTexture.image_user -> image_user:    pointer, (read-only)    Parameters defining which layer, pass and frame of the image is displayed
+Event.ascii -> ascii:    string, (read-only)    Single ASCII character for this event
+Event.mouse_prev_x -> mouse_prev_x:    int, (read-only)    The window relative vertical location of the mouse
+Event.mouse_prev_y -> mouse_prev_y:    int, (read-only)    The window relative horizontal location of the mouse
+Event.mouse_region_x -> mouse_region_x:    int, (read-only)    The region relative vertical location of the mouse
+Event.mouse_region_y -> mouse_region_y:    int, (read-only)    The region relative horizontal location of the mouse
+Event.mouse_x -> mouse_x:    int, (read-only)    The window relative vertical location of the mouse
+Event.mouse_y -> mouse_y:    int, (read-only)    The window relative horizontal location of the mouse
+Event.type -> type:    enum, (read-only)    
+Event.value -> value:    enum, (read-only)    The type of event, only applies to some
+ExplodeModifier.protect -> protect:    float    Clean vertex group edges
+ExplodeModifier.vertex_group -> vertex_group:    string    
+ExpressionController.expression -> expression:    string    
+FCurve.array_index -> array_index:    int    Index to the specific property affected by F-Curve if applicable
+FCurve.color -> color:    float    Color of the F-Curve in the Graph Editor
+FCurve.color_mode -> color_mode:    enum    Method used to determine color of F-Curve in Graph Editor
+FCurve.data_path -> data_path:    string    RNA Path to property affected by F-Curve
+FCurve.driver -> driver:    pointer, (read-only)    Channel Driver (only set for Driver F-Curves)
+FCurve.extrapolation -> extrapolation:    enum    
+FCurve.group -> group:    pointer    Action Group that this F-Curve belongs to
+FCurve.keyframe_points -> keyframe_points:    collection, (read-only)    User-editable keyframes
+FCurve.modifiers -> modifiers:    collection, (read-only)    Modifiers affecting the shape of the F-Curve
+FCurve.sampled_points -> sampled_points:    collection, (read-only)    Sampled animation data
+FCurveModifiers.active -> active:    pointer    Active F-Curve Modifier
+FCurveSample.co -> co:    float    Point coordinates
+FModifier.type -> type:    enum, (read-only)    F-Curve Modifier Type
+FModifierCycles.after_cycles -> after_cycles:    float    Maximum number of cycles to allow after last keyframe. (0 = infinite)
+FModifierCycles.after_mode -> after_mode:    enum    Cycling mode to use after last keyframe
+FModifierCycles.before_cycles -> before_cycles:    float    Maximum number of cycles to allow before first keyframe. (0 = infinite)
+FModifierCycles.before_mode -> before_mode:    enum    Cycling mode to use before first keyframe
+FModifierEnvelope.control_points -> control_points:    collection, (read-only)    Control points defining the shape of the envelope
+FModifierEnvelope.default_maximum -> default_maximum:    float    Upper distance from Reference Value for 1:1 default influence
+FModifierEnvelope.default_minimum -> default_minimum:    float    Lower distance from Reference Value for 1:1 default influence
+FModifierEnvelope.reference_value -> reference_value:    float    Value that envelope's influence is centered around / based on
+FModifierEnvelopeControlPoint.frame -> frame:    float    Frame this control-point occurs on
+FModifierEnvelopeControlPoint.maximum -> maximum:    float    Upper bound of envelope at this control-point
+FModifierEnvelopeControlPoint.minimum -> minimum:    float    Lower bound of envelope at this control-point
+FModifierFunctionGenerator.amplitude -> amplitude:    float    Scale factor determining the maximum/minimum values
+FModifierFunctionGenerator.function_type -> function_type:    enum    Type of built-in function to use
+FModifierFunctionGenerator.phase_multiplier -> phase_multiplier:    float    Scale factor determining the 'speed' of the function
+FModifierFunctionGenerator.phase_offset -> phase_offset:    float    Constant factor to offset time by for function
+FModifierFunctionGenerator.value_offset -> value_offset:    float    Constant factor to offset values by
+FModifierGenerator.coefficients -> coefficients:    float    Coefficients for 'x' (starting from lowest power of x^0)
+FModifierGenerator.mode -> mode:    enum    Type of generator to use
+FModifierGenerator.poly_order -> poly_order:    int    The highest power of 'x' for this polynomial. (number of coefficients - 1)
+FModifierLimits.maximum_x -> maximum_x:    float    Highest X value to allow
+FModifierLimits.maximum_y -> maximum_y:    float    Highest Y value to allow
+FModifierLimits.minimum_x -> minimum_x:    float    Lowest X value to allow
+FModifierLimits.minimum_y -> minimum_y:    float    Lowest Y value to allow
+FModifierNoise.depth -> depth:    int    Amount of fine level detail present in the noise
+FModifierNoise.modification -> modification:    enum    Method of modifying the existing F-Curve
+FModifierNoise.phase -> phase:    float    A random seed for the noise effect
+FModifierNoise.size -> size:    float    Scaling (in time) of the noise
+FModifierNoise.strength -> strength:    float    Amplitude of the noise - the amount that it modifies the underlying curve
+FModifierStepped.frame_end -> frame_end:    float    Frame that modifier's influence ends (if applicable)
+FModifierStepped.frame_start -> frame_start:    float    Frame that modifier's influence starts (if applicable)
+FModifierStepped.offset -> offset:    float    Reference number of frames before frames get held. Use to get hold for '1-3' vs '5-7' holding patterns
+FModifierStepped.step_size -> step_size:    float    Number of frames to hold each value
+FcurveActuator.frame_end -> frame_end:    int    
+FcurveActuator.frame_property -> frame_property:    string    Assign the action's current frame number to this property
+FcurveActuator.frame_start -> frame_start:    int    
+FcurveActuator.play_type -> play_type:    enum    Specify the way you want to play the animation
+FcurveActuator.property -> property:    string    Use this property to define the F-Curve position
+FieldSettings.falloff_power -> falloff_power:    float    Falloff power (real gravitational falloff = 2)
+FieldSettings.falloff_type -> falloff_type:    enum    Fall-off shape
+FieldSettings.flow -> flow:    float    Convert effector force into air flow velocity
+FieldSettings.guide_clump_amount -> guide_clump_amount:    float    Amount of clumping
+FieldSettings.guide_clump_shape -> guide_clump_shape:    float    Shape of clumping
+FieldSettings.guide_free -> guide_free:    float    Guide-free time from particle life's end
+FieldSettings.guide_kink_amplitude -> guide_kink_amplitude:    float    The amplitude of the offset
+FieldSettings.guide_kink_axis -> guide_kink_axis:    enum    Which axis to use for offset
+FieldSettings.guide_kink_frequency -> guide_kink_frequency:    float    The frequency of the offset (1/total length)
+FieldSettings.guide_kink_shape -> guide_kink_shape:    float    Adjust the offset to the beginning/end
+FieldSettings.guide_kink_type -> guide_kink_type:    enum    Type of periodic offset on the curve
+FieldSettings.guide_minimum -> guide_minimum:    float    The distance from which particles are affected fully
+FieldSettings.harmonic_damping -> harmonic_damping:    float    Damping of the harmonic force
+FieldSettings.inflow -> inflow:    float    Inwards component of the vortex force
+FieldSettings.linear_drag -> linear_drag:    float    Drag component proportional to velocity
+FieldSettings.maximum_distance -> maximum_distance:    float    Maximum distance for the field to work
+FieldSettings.minimum_distance -> minimum_distance:    float    Minimum distance for the field's fall-off
+FieldSettings.noise -> noise:    float    Noise of the force
+FieldSettings.quadratic_drag -> quadratic_drag:    float    Drag component proportional to the square of velocity
+FieldSettings.radial_falloff -> radial_falloff:    float    Radial falloff power (real gravitational falloff = 2)
+FieldSettings.radial_maximum -> radial_maximum:    float    Maximum radial distance for the field to work
+FieldSettings.radial_minimum -> radial_minimum:    float    Minimum radial distance for the field's fall-off
+FieldSettings.rest_length -> rest_length:    float    Rest length of the harmonic force
+FieldSettings.seed -> seed:    int    Seed of the noise
+FieldSettings.shape -> shape:    enum    Which direction is used to calculate the effector force
+FieldSettings.size -> size:    float    Size of the noise
+FieldSettings.strength -> strength:    float    Strength of force field
+FieldSettings.texture -> texture:    pointer    Texture to use as force
+FieldSettings.texture_mode -> texture_mode:    enum    How the texture effect is calculated (RGB & Curl need a RGB texture else Gradient will be used instead)
+FieldSettings.texture_nabla -> texture_nabla:    float    Defines size of derivative offset used for calculating gradient and curl
+FieldSettings.type -> type:    enum    Type of field
+FieldSettings.z_direction -> z_direction:    enum    Effect in full or only positive/negative Z direction
+FileSelectParams.directory -> directory:    string    Directory displayed in the file browser
+FileSelectParams.display -> display:    enum    Display mode for the file list
+FileSelectParams.file -> file:    string    Active file in the file browser
+FileSelectParams.sort -> sort:    enum    
+FileSelectParams.title -> title:    string, (read-only)    Title for the file browser
+Filter2DActuator.filter_pass -> filter_pass:    int    Set filter order
+Filter2DActuator.glsl_shader -> glsl_shader:    pointer    
+Filter2DActuator.mode -> mode:    enum    
+Filter2DActuator.motion_blur_value -> motion_blur_value:    float    Set motion blur value
+FloatProperty.array_length -> array_length:    int, (read-only)    Maximum length of the array, 0 means unlimited
+FloatProperty.default -> default:    float, (read-only)    Default value for this number
+FloatProperty.default_array -> default_array:    float, (read-only)    Default value for this array
+FloatProperty.hard_max -> hard_max:    float, (read-only)    Maximum value used by buttons
+FloatProperty.hard_min -> hard_min:    float, (read-only)    Minimum value used by buttons
+FloatProperty.precision -> precision:    int, (read-only)    Number of digits after the dot used by buttons
+FloatProperty.soft_max -> soft_max:    float, (read-only)    Maximum value used by buttons
+FloatProperty.soft_min -> soft_min:    float, (read-only)    Minimum value used by buttons
+FloatProperty.step -> step:    float, (read-only)    Step size used by number buttons, for floats 1/100th of the step size
+FloorConstraint.floor_location -> floor_location:    enum    Location of target that object will not pass through
+FloorConstraint.offset -> offset:    float    Offset of floor from object origin
+FloorConstraint.subtarget -> subtarget:    string    
+FloorConstraint.target -> target:    pointer    Target Object
+FluidFluidSettings.initial_velocity -> initial_velocity:    float    Initial velocity of fluid
+FluidFluidSettings.volume_initialization -> volume_initialization:    enum    Volume initialization type
+FluidSettings.type -> type:    enum    Type of participation in the fluid simulation
+FluidSimulationModifier.settings -> settings:    pointer, (read-only)    Settings for how this object is used in the fluid simulation
+FollowPathConstraint.forward -> forward:    enum    Axis that points forward along the path
+FollowPathConstraint.offset -> offset:    int    Offset from the position corresponding to the time frame
+FollowPathConstraint.offset_factor -> offset_factor:    float    Percentage value defining target position along length of bone
+FollowPathConstraint.target -> target:    pointer    Target Object
+FollowPathConstraint.up -> up:    enum    Axis that points upward
+Function.description -> description:    string, (read-only)    Description of the Function's purpose
+Function.identifier -> identifier:    string, (read-only)    Unique name used in the code and scripting
+Function.parameters -> parameters:    collection, (read-only)    Parameters for the function
+GPencilFrame.frame_number -> frame_number:    int    The frame on which this sketch appears
+GPencilFrame.strokes -> strokes:    collection, (read-only)    Freehand curves defining the sketch on this frame
+GPencilLayer.active_frame -> active_frame:    pointer, (read-only)    Frame currently being displayed for this layer
+GPencilLayer.color -> color:    float    Color for all strokes in this layer
+GPencilLayer.frames -> frames:    collection, (read-only)    Sketches for this layer on different frames
+GPencilLayer.info -> info:    string    Layer name
+GPencilLayer.line_thickness -> line_thickness:    int    Thickness of strokes (in pixels)
+GPencilLayer.max_ghost_range -> max_ghost_range:    int    Maximum number of frames on either side of the active frame to show (0 = show the 'first' available sketch on either side)
+GPencilLayer.opacity -> opacity:    float    Layer Opacity
+GPencilStroke.points -> points:    collection, (read-only)    Stroke data points
+GPencilStrokePoint.co -> co:    float    
+GPencilStrokePoint.pressure -> pressure:    float    Pressure of tablet at point when drawing it
+GameActuator.filename -> filename:    string    Load this blend file, use the "//" prefix for a path relative to the current blend file
+GameActuator.mode -> mode:    enum    
+GameFloatProperty.value -> value:    float    Property value
+GameIntProperty.value -> value:    int    Property value
+GameObjectSettings.actuators -> actuators:    collection, (read-only)    Game engine actuators to act on events
+GameObjectSettings.collision_bounds -> collision_bounds:    enum    Selects the collision type
+GameObjectSettings.collision_margin -> collision_margin:    float    Extra margin around object for collision detection, small amount required for stability
+GameObjectSettings.controllers -> controllers:    collection, (read-only)    Game engine controllers to process events, connecting sensor to actuators
+GameObjectSettings.damping -> damping:    float    General movement damping
+GameObjectSettings.form_factor -> form_factor:    float    Form factor scales the inertia tensor
+GameObjectSettings.friction_coefficients -> friction_coefficients:    float    Relative friction coefficient in the in the X, Y and Z directions, when anisotropic friction is enabled
+GameObjectSettings.mass -> mass:    float    Mass of the object
+GameObjectSettings.maximum_velocity -> maximum_velocity:    float    Clamp velocity to this maximum speed
+GameObjectSettings.minimum_velocity -> minimum_velocity:    float    Clamp velocity to this minimum speed (except when totally still)
+GameObjectSettings.physics_type -> physics_type:    enum    Selects the type of physical representation
+GameObjectSettings.properties -> properties:    collection, (read-only)    Game engine properties
+GameObjectSettings.radius -> radius:    float    Radius of bounding sphere and material physics
+GameObjectSettings.rotation_damping -> rotation_damping:    float    General rotation damping
+GameObjectSettings.sensors -> sensors:    collection, (read-only)    Game engine sensor to detect events
+GameObjectSettings.soft_body -> soft_body:    pointer, (read-only)    Settings for Bullet soft body simulation
+GameProperty.name -> name:    string    Available as GameObject attributes in the game engine's python API
+GameProperty.type -> type:    enum    
+GameSoftBodySettings.cluster_iterations -> cluster_iterations:    int    Specify the number of cluster iterations
+GameSoftBodySettings.dynamic_friction -> dynamic_friction:    float    Dynamic Friction
+GameSoftBodySettings.linstiff -> linstiff:    float    Linear stiffness of the soft body links
+GameSoftBodySettings.margin -> margin:    float    Collision margin for soft body. Small value makes the algorithm unstable
+GameSoftBodySettings.position_iterations -> position_iterations:    int    Position solver iterations
+GameSoftBodySettings.threshold -> threshold:    float    Shape matching threshold
+GameSoftBodySettings.welding -> welding:    float    Welding threshold: distance between nearby vertices to be considered equal => set to 0.0 to disable welding test and speed up scene loading (ok if the mesh has no duplicates)
+GameStringProperty.value -> value:    string    Property value
+GameTimerProperty.value -> value:    float    Property value
+GlowSequence.blur_distance -> blur_distance:    float    Radius of glow effect
+GlowSequence.boost_factor -> boost_factor:    float    Brightness multiplier
+GlowSequence.clamp -> clamp:    float    rightness limit of intensity
+GlowSequence.quality -> quality:    int    Accuracy of the blur effect
+GlowSequence.threshold -> threshold:    float    Minimum intensity to trigger a glow
+GreasePencil.draw_mode -> draw_mode:    enum    
+GreasePencil.layers -> layers:    collection, (read-only)    
+Group.dupli_offset -> dupli_offset:    float    Offset from the origin to use when instancing as DupliGroup
+Group.objects -> objects:    collection, (read-only)    A collection of this groups objects
+Header.bl_idname -> bl_idname:    string    
+Header.bl_space_type -> bl_space_type:    enum    
+Header.layout -> layout:    pointer, (read-only)    
+Histogram.mode -> mode:    enum    Channels to display when drawing the histogram
+HookModifier.falloff -> falloff:    float    If not zero, the distance from the hook where influence ends
+HookModifier.force -> force:    float    Relative force of the hook
+HookModifier.object -> object:    pointer    Parent Object for hook, also recalculates and clears offset
+HookModifier.subtarget -> subtarget:    string    Name of Parent Bone for hook (if applicable), also recalculates and clears offset
+HookModifier.vertex_group -> vertex_group:    string    Vertex group name
+ID.library -> library:    pointer, (read-only)    Library file the datablock is linked from
+ID.name -> name:    string    Unique datablock ID name
+ID.users -> users:    int, (read-only)    Number of times this datablock is referenced
+IDProperty.collection -> collection:    collection, (read-only)    
+IDProperty.double -> double:    float    
+IDProperty.double_array -> double_array:    float    
+IDProperty.float -> float:    float    
+IDProperty.float_array -> float_array:    float    
+IDProperty.group -> group:    pointer, (read-only)    
+IDProperty.int -> int:    int    
+IDProperty.int_array -> int_array:    int    
+IDProperty.string -> string:    string    
+IDPropertyGroup.name -> name:    string    Unique name used in the code and scripting
+IKParam.ik_solver -> ik_solver:    enum, (read-only)    IK solver for which these parameters are defined, 0 for Legacy, 1 for iTaSC
+Image.animation_end -> animation_end:    int    End frame of an animated texture
+Image.animation_speed -> animation_speed:    int    Speed of the animation in frames per second
+Image.animation_start -> animation_start:    int    Start frame of an animated texture
+Image.bindcode -> bindcode:    int, (read-only)    OpenGL bindcode
+Image.depth -> depth:    int, (read-only)    Image bit depth
+Image.display_aspect -> display_aspect:    float    Display Aspect for this image, does not affect rendering
+Image.field_order -> field_order:    enum    Order of video fields. Select which lines are displayed first
+Image.file_format -> file_format:    enum    Format used for re-saving this file
+Image.filepath -> filepath:    string    Image/Movie file name
+Image.filepath_raw -> filepath_raw:    string    Image/Movie file name (without data refreshing)
+Image.generated_height -> generated_height:    int    Generated image height
+Image.generated_type -> generated_type:    enum    Generated image type
+Image.generated_width -> generated_width:    int    Generated image width
+Image.mapping -> mapping:    enum    Mapping type to use for this image in the game engine
+Image.packed_file -> packed_file:    pointer, (read-only)    
+Image.size -> size:    int, (read-only)    Width and height in pixels, zero when image data cant be loaded
+Image.source -> source:    enum    Where the image comes from
+Image.tiles_x -> tiles_x:    int    Degree of repetition in the X direction
+Image.tiles_y -> tiles_y:    int    Degree of repetition in the Y direction
+Image.type -> type:    enum, (read-only)    How to generate the image
+ImagePaint.normal_angle -> normal_angle:    int    Paint most on faces pointing towards the view according to this angle
+ImagePaint.screen_grab_size -> screen_grab_size:    int    Size to capture the image for re-projecting
+ImagePaint.seam_bleed -> seam_bleed:    int    Extend paint beyond the faces UVs to reduce seams (in pixels, slower)
+ImageSequence.animation_end_offset -> animation_end_offset:    int    Animation end offset (trim end)
+ImageSequence.animation_start_offset -> animation_start_offset:    int    Animation start offset (trim start)
+ImageSequence.color_balance -> color_balance:    pointer, (read-only)    
+ImageSequence.crop -> crop:    pointer, (read-only)    
+ImageSequence.directory -> directory:    string    
+ImageSequence.elements -> elements:    collection, (read-only)    
+ImageSequence.multiply_colors -> multiply_colors:    float    
+ImageSequence.proxy -> proxy:    pointer, (read-only)    
+ImageSequence.strobe -> strobe:    float    Only display every nth frame
+ImageSequence.transform -> transform:    pointer, (read-only)    
+ImageTexture.checker_distance -> checker_distance:    float    Sets distance between checker tiles
+ImageTexture.crop_max_x -> crop_max_x:    float    Sets maximum X value to crop the image
+ImageTexture.crop_max_y -> crop_max_y:    float    Sets maximum Y value to crop the image
+ImageTexture.crop_min_x -> crop_min_x:    float    Sets minimum X value to crop the image
+ImageTexture.crop_min_y -> crop_min_y:    float    Sets minimum Y value to crop the image
+ImageTexture.extension -> extension:    enum    Sets how the image is extrapolated past its original bounds
+ImageTexture.filter -> filter:    enum    Texture filter to use for sampling image
+ImageTexture.filter_eccentricity -> filter_eccentricity:    int    Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower
+ImageTexture.filter_probes -> filter_probes:    int    Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower
+ImageTexture.filter_size -> filter_size:    float    Multiplies the filter size used by MIP Map and Interpolation
+ImageTexture.image -> image:    pointer    
+ImageTexture.image_user -> image_user:    pointer, (read-only)    Parameters defining which layer, pass and frame of the image is displayed
+ImageTexture.normal_space -> normal_space:    enum    Sets space of normal map image
+ImageTexture.repeat_x -> repeat_x:    int    Sets a repetition multiplier in the X direction
+ImageTexture.repeat_y -> repeat_y:    int    Sets a repetition multiplier in the Y direction
+ImageUser.fields_per_frame -> fields_per_frame:    int    The number of fields per rendered frame (2 fields is 1 image)
+ImageUser.frame_start -> frame_start:    int    Sets the global starting frame of the movie
+ImageUser.frames -> frames:    int    Sets the number of images of a movie to use
+ImageUser.multilayer_layer -> multilayer_layer:    int, (read-only)    Layer in multilayer image
+ImageUser.multilayer_pass -> multilayer_pass:    int, (read-only)    Pass in multilayer image
+ImageUser.offset -> offset:    int    Offsets the number of the frame to use in the animation
+InflowFluidSettings.inflow_velocity -> inflow_velocity:    float    Initial velocity of fluid
+InflowFluidSettings.volume_initialization -> volume_initialization:    enum    Volume initialization type
+IntProperty.array_length -> array_length:    int, (read-only)    Maximum length of the array, 0 means unlimited
+IntProperty.default -> default:    int, (read-only)    Default value for this number
+IntProperty.default_array -> default_array:    int, (read-only)    Default value for this array
+IntProperty.hard_max -> hard_max:    int, (read-only)    Maximum value used by buttons
+IntProperty.hard_min -> hard_min:    int, (read-only)    Minimum value used by buttons
+IntProperty.soft_max -> soft_max:    int, (read-only)    Maximum value used by buttons
+IntProperty.soft_min -> soft_min:    int, (read-only)    Minimum value used by buttons
+IntProperty.step -> step:    int, (read-only)    Step size used by number buttons, for floats 1/100th of the step size
+Itasc.dampeps -> dampeps:    float    Singular value under which damping is progressively applied. Higher values=more stability, less reactivity. Default=0.1
+Itasc.dampmax -> dampmax:    float    Maximum damping coefficient when singular value is nearly 0. Higher values=more stability, less reactivity. Default=0.5
+Itasc.feedback -> feedback:    float    Feedback coefficient for error correction. Average response time=1/feedback. Default=20
+Itasc.max_step -> max_step:    float    Higher bound for timestep in second in case of automatic substeps
+Itasc.max_velocity -> max_velocity:    float    Maximum joint velocity in rad/s. Default=50
+Itasc.min_step -> min_step:    float    Lower bound for timestep in second in case of automatic substeps
+Itasc.mode -> mode:    enum    
+Itasc.num_iter -> num_iter:    int    Maximum number of iterations for convergence in case of reiteration
+Itasc.num_step -> num_step:    int    Divides the frame interval into this many steps
+Itasc.precision -> precision:    float    Precision of convergence in case of reiteration
+Itasc.reiteration -> reiteration:    enum    Defines if the solver is allowed to reiterate (converges until precision is met) on none, first or all frames
+Itasc.solver -> solver:    enum    Solving method selection: Automatic damping or manual damping
+JoystickSensor.axis_direction -> axis_direction:    enum    The direction of the axis
+JoystickSensor.axis_number -> axis_number:    int    Specify which axis pair to use, 1 is usually the main direction input
+JoystickSensor.axis_threshold -> axis_threshold:    int    Specify the precision of the axis
+JoystickSensor.button_number -> button_number:    int    Specify which button to use
+JoystickSensor.event_type -> event_type:    enum    The type of event this joystick sensor is triggered on
+JoystickSensor.hat_direction -> hat_direction:    enum    Specify hat direction
+JoystickSensor.hat_number -> hat_number:    int    Specify which hat to use
+JoystickSensor.joystick_index -> joystick_index:    int    Specify which joystick to use
+JoystickSensor.single_axis_number -> single_axis_number:    int    Specify a single axis (verticle/horizontal/other) to detect
+Key.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+Key.keys -> keys:    collection, (read-only)    Shape keys
+Key.reference_key -> reference_key:    pointer, (read-only)    
+Key.slurph -> slurph:    int    Creates a delay in amount of frames in applying keypositions, first vertex goes first
+Key.user -> user:    pointer, (read-only)    Datablock using these shape keys
+KeyConfig.keymaps -> keymaps:    collection, (read-only)    Key maps configured as part of this configuration
+KeyConfig.name -> name:    string    Name of the key configuration
+KeyMap.items -> items:    collection, (read-only)    Items in the keymap, linking an operator to an input event
+KeyMap.name -> name:    string, (read-only)    Name of the key map
+KeyMap.region_type -> region_type:    enum, (read-only)    Optional region type keymap is associated with
+KeyMap.space_type -> space_type:    enum, (read-only)    Optional space type keymap is associated with
+KeyMapItem.id -> id:    int, (read-only)    ID of the item
+KeyMapItem.idname -> idname:    string    Identifier of operator to call on input event
+KeyMapItem.key_modifier -> key_modifier:    enum    Regular key pressed as a modifier
+KeyMapItem.map_type -> map_type:    enum    Type of event mapping
+KeyMapItem.name -> name:    string, (read-only)    Name of operator to call on input event
+KeyMapItem.properties -> properties:    pointer, (read-only)    Properties to set when the operator is called
+KeyMapItem.propvalue -> propvalue:    enum    The value this event translates to in a modal keymap
+KeyMapItem.type -> type:    enum    Type of event
+KeyMapItem.value -> value:    enum    
+KeyboardSensor.key -> key:    enum    
+KeyboardSensor.log -> log:    string    Property that receive the keystrokes in case a string is logged
+KeyboardSensor.modifier_key -> modifier_key:    enum    Modifier key code
+KeyboardSensor.second_modifier_key -> second_modifier_key:    enum    Modifier key code
+KeyboardSensor.target -> target:    string    Property that indicates whether to log keystrokes as a string
+Keyframe.co -> co:    float    Coordinates of the control point
+Keyframe.handle1 -> handle1:    float    Coordinates of the first handle
+Keyframe.handle1_type -> handle1_type:    enum    Handle types
+Keyframe.handle2 -> handle2:    float    Coordinates of the second handle
+Keyframe.handle2_type -> handle2_type:    enum    Handle types
+Keyframe.interpolation -> interpolation:    enum    Interpolation method to use for segment of the curve from this Keyframe until the next Keyframe
+Keyframe.type -> type:    enum    The type of keyframe
+KeyingSet.active_path -> active_path:    pointer    Active Keying Set used to insert/delete keyframes
+KeyingSet.active_path_index -> active_path_index:    int    Current Keying Set index
+KeyingSet.name -> name:    string    
+KeyingSet.paths -> paths:    collection, (read-only)    Keying Set Paths to define settings that get keyframed together
+KeyingSet.type_info -> type_info:    pointer, (read-only)    Callback function defines for built-in Keying Sets
+KeyingSetInfo.bl_idname -> bl_idname:    string    
+KeyingSetInfo.bl_label -> bl_label:    string    
+KeyingSetPath.array_index -> array_index:    int    Index to the specific setting if applicable
+KeyingSetPath.data_path -> data_path:    string    Path to property setting
+KeyingSetPath.group -> group:    string    Name of Action Group to assign setting(s) for this path to
+KeyingSetPath.grouping -> grouping:    enum    Method used to define which Group-name to use
+KeyingSetPath.id -> id:    pointer    ID-Block that keyframes for Keying Set should be added to (for Absolute Keying Sets only)
+KeyingSetPath.id_type -> id_type:    enum    Type of ID-block that can be used
+KinematicConstraint.axis_reference -> axis_reference:    enum    Constraint axis Lock options relative to Bone or Target reference
+KinematicConstraint.chain_length -> chain_length:    int    How many bones are included in the IK effect - 0 uses all bones
+KinematicConstraint.distance -> distance:    float    Radius of limiting sphere
+KinematicConstraint.ik_type -> ik_type:    enum    
+KinematicConstraint.iterations -> iterations:    int    Maximum number of solving iterations
+KinematicConstraint.limit_mode -> limit_mode:    enum    Distances in relation to sphere of influence to allow
+KinematicConstraint.orient_weight -> orient_weight:    float    For Tree-IK: Weight of orientation control for this target
+KinematicConstraint.pole_angle -> pole_angle:    float    Pole rotation offset
+KinematicConstraint.pole_subtarget -> pole_subtarget:    string    
+KinematicConstraint.pole_target -> pole_target:    pointer    Object for pole rotation
+KinematicConstraint.subtarget -> subtarget:    string    
+KinematicConstraint.target -> target:    pointer    Target Object
+KinematicConstraint.weight -> weight:    float    For Tree-IK: Weight of position control for this target
+Lamp.active_texture -> active_texture:    pointer    Active texture slot being displayed
+Lamp.active_texture_index -> active_texture_index:    int    Index of active texture slot
+Lamp.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+Lamp.color -> color:    float    Light color
+Lamp.distance -> distance:    float    Falloff distance - the light is at half the original intensity at this point
+Lamp.energy -> energy:    float    Amount of light that the lamp emits
+Lamp.texture_slots -> texture_slots:    collection, (read-only)    Texture slots defining the mapping and influence of textures
+Lamp.type -> type:    enum    Type of Lamp
+LampSkySettings.atmosphere_distance_factor -> atmosphere_distance_factor:    float    Multiplier to convert blender units to physical distance
+LampSkySettings.atmosphere_extinction -> atmosphere_extinction:    float    Extinction scattering contribution factor
+LampSkySettings.atmosphere_inscattering -> atmosphere_inscattering:    float    Scatter contribution factor
+LampSkySettings.atmosphere_turbidity -> atmosphere_turbidity:    float    Sky turbidity
+LampSkySettings.backscattered_light -> backscattered_light:    float    Backscattered light
+LampSkySettings.horizon_brightness -> horizon_brightness:    float    Horizon brightness
+LampSkySettings.sky_blend -> sky_blend:    float    Blend factor with sky
+LampSkySettings.sky_blend_type -> sky_blend_type:    enum    Blend mode for combining sun sky with world sky
+LampSkySettings.sky_color_space -> sky_color_space:    enum    Color space to use for internal XYZ->RGB color conversion
+LampSkySettings.sky_exposure -> sky_exposure:    float    Strength of sky shading exponential exposure correction
+LampSkySettings.spread -> spread:    float    Horizon Spread
+LampSkySettings.sun_brightness -> sun_brightness:    float    Sun brightness
+LampSkySettings.sun_intensity -> sun_intensity:    float    Sun intensity
+LampSkySettings.sun_size -> sun_size:    float    Sun size
+LampTextureSlot.color_factor -> color_factor:    float    Amount texture affects color values
+LampTextureSlot.object -> object:    pointer    Object to use for mapping with Object texture coordinates
+LampTextureSlot.shadow_factor -> shadow_factor:    float    Amount texture affects shadow
+LampTextureSlot.texture_coordinates -> texture_coordinates:    enum    
+Lattice.interpolation_type_u -> interpolation_type_u:    enum    
+Lattice.interpolation_type_v -> interpolation_type_v:    enum    
+Lattice.interpolation_type_w -> interpolation_type_w:    enum    
+Lattice.points -> points:    collection, (read-only)    Points of the lattice
+Lattice.points_u -> points_u:    int    Points in U direction
+Lattice.points_v -> points_v:    int    Points in V direction
+Lattice.points_w -> points_w:    int    Points in W direction
+Lattice.shape_keys -> shape_keys:    pointer, (read-only)    
+Lattice.vertex_group -> vertex_group:    string    Vertex group to apply the influence of the lattice
+LatticeModifier.object -> object:    pointer    Lattice object to deform with
+LatticeModifier.vertex_group -> vertex_group:    string    Vertex group name
+LatticePoint.co -> co:    float, (read-only)    
+LatticePoint.deformed_co -> deformed_co:    float    
+LatticePoint.groups -> groups:    collection, (read-only)    Weights for the vertex groups this point is member of
+Library.filepath -> filepath:    string    Path to the library .blend file
+Library.parent -> parent:    pointer, (read-only)    
+LimitDistanceConstraint.distance -> distance:    float    Radius of limiting sphere
+LimitDistanceConstraint.limit_mode -> limit_mode:    enum    Distances in relation to sphere of influence to allow
+LimitDistanceConstraint.subtarget -> subtarget:    string    
+LimitDistanceConstraint.target -> target:    pointer    Target Object
+LimitLocationConstraint.maximum_x -> maximum_x:    float    Highest X value to allow
+LimitLocationConstraint.maximum_y -> maximum_y:    float    Highest Y value to allow
+LimitLocationConstraint.maximum_z -> maximum_z:    float    Highest Z value to allow
+LimitLocationConstraint.minimum_x -> minimum_x:    float    Lowest X value to allow
+LimitLocationConstraint.minimum_y -> minimum_y:    float    Lowest Y value to allow
+LimitLocationConstraint.minimum_z -> minimum_z:    float    Lowest Z value to allow
+LimitRotationConstraint.maximum_x -> maximum_x:    float    Highest X value to allow
+LimitRotationConstraint.maximum_y -> maximum_y:    float    Highest Y value to allow
+LimitRotationConstraint.maximum_z -> maximum_z:    float    Highest Z value to allow
+LimitRotationConstraint.minimum_x -> minimum_x:    float    Lowest X value to allow
+LimitRotationConstraint.minimum_y -> minimum_y:    float    Lowest Y value to allow
+LimitRotationConstraint.minimum_z -> minimum_z:    float    Lowest Z value to allow
+LimitScaleConstraint.maximum_x -> maximum_x:    float    Highest X value to allow
+LimitScaleConstraint.maximum_y -> maximum_y:    float    Highest Y value to allow
+LimitScaleConstraint.maximum_z -> maximum_z:    float    Highest Z value to allow
+LimitScaleConstraint.minimum_x -> minimum_x:    float    Lowest X value to allow
+LimitScaleConstraint.minimum_y -> minimum_y:    float    Lowest Y value to allow
+LimitScaleConstraint.minimum_z -> minimum_z:    float    Lowest Z value to allow
+LockedTrackConstraint.locked -> locked:    enum    Axis that points upward
+LockedTrackConstraint.subtarget -> subtarget:    string    
+LockedTrackConstraint.target -> target:    pointer    Target Object
+LockedTrackConstraint.track -> track:    enum    Axis that points to the target object
+Macro.bl_description -> bl_description:    string    
+Macro.bl_idname -> bl_idname:    string    
+Macro.bl_label -> bl_label:    string    
+Macro.bl_options -> bl_options:    enum    Options for this operator type
+Macro.name -> name:    string, (read-only)    
+Macro.properties -> properties:    pointer, (read-only)    
+MagicTexture.noise_depth -> noise_depth:    int    Sets the depth of the cloud calculation
+MagicTexture.turbulence -> turbulence:    float    Sets the turbulence of the bandnoise and ringnoise types
+Main.actions -> actions:    collection, (read-only)    Action datablocks.
+Main.armatures -> armatures:    collection, (read-only)    Armature datablocks.
+Main.brushes -> brushes:    collection, (read-only)    Brush datablocks.
+Main.cameras -> cameras:    collection, (read-only)    Camera datablocks.
+Main.curves -> curves:    collection, (read-only)    Curve datablocks.
+Main.filepath -> filepath:    string, (read-only)    Path to the .blend file
+Main.fonts -> fonts:    collection, (read-only)    Vector font datablocks.
+Main.gpencil -> gpencil:    collection, (read-only)    Grease Pencil datablocks.
+Main.groups -> groups:    collection, (read-only)    Group datablocks.
+Main.images -> images:    collection, (read-only)    Image datablocks.
+Main.lamps -> lamps:    collection, (read-only)    Lamp datablocks.
+Main.lattices -> lattices:    collection, (read-only)    Lattice datablocks.
+Main.libraries -> libraries:    collection, (read-only)    Library datablocks.
+Main.materials -> materials:    collection, (read-only)    Material datablocks.
+Main.meshes -> meshes:    collection, (read-only)    Mesh datablocks.
+Main.metaballs -> metaballs:    collection, (read-only)    Metaball datablocks.
+Main.node_groups -> node_groups:    collection, (read-only)    Node group datablocks.
+Main.objects -> objects:    collection, (read-only)    Object datablocks.
+Main.particles -> particles:    collection, (read-only)    Particle datablocks.
+Main.scenes -> scenes:    collection, (read-only)    Scene datablocks.
+Main.screens -> screens:    collection, (read-only)    Screen datablocks.
+Main.scripts -> scripts:    collection, (read-only)    Script datablocks (DEPRECATED).
+Main.sounds -> sounds:    collection, (read-only)    Sound datablocks.
+Main.texts -> texts:    collection, (read-only)    Text datablocks.
+Main.textures -> textures:    collection, (read-only)    Texture datablocks.
+Main.window_managers -> window_managers:    collection, (read-only)    Window manager datablocks.
+Main.worlds -> worlds:    collection, (read-only)    World datablocks.
+MaintainVolumeConstraint.axis -> axis:    enum    The free scaling axis of the object
+MaintainVolumeConstraint.volume -> volume:    float    Volume of the bone at rest
+MarbleTexture.nabla -> nabla:    float    Size of derivative offset used for calculating normal
+MarbleTexture.noise_basis -> noise_basis:    enum    Sets the noise basis used for turbulence
+MarbleTexture.noise_depth -> noise_depth:    int    Sets the depth of the cloud calculation
+MarbleTexture.noise_size -> noise_size:    float    Sets scaling for noise input
+MarbleTexture.noise_type -> noise_type:    enum    
+MarbleTexture.noisebasis2 -> noisebasis2:    enum    
+MarbleTexture.stype -> stype:    enum    
+MarbleTexture.turbulence -> turbulence:    float    Sets the turbulence of the bandnoise and ringnoise types
+MaskModifier.armature -> armature:    pointer    Armature to use as source of bones to mask
+MaskModifier.mode -> mode:    enum    
+MaskModifier.vertex_group -> vertex_group:    string    Vertex group name
+Material.active_node_material -> active_node_material:    pointer    Active node material
+Material.active_texture -> active_texture:    pointer    Active texture slot being displayed
+Material.active_texture_index -> active_texture_index:    int    Index of active texture slot
+Material.alpha -> alpha:    float    Alpha transparency of the material
+Material.ambient -> ambient:    float    Amount of global ambient color the material receives
+Material.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+Material.darkness -> darkness:    float    Minnaert darkness
+Material.diffuse_color -> diffuse_color:    float    
+Material.diffuse_fresnel -> diffuse_fresnel:    float    Power of Fresnel
+Material.diffuse_fresnel_factor -> diffuse_fresnel_factor:    float    Blending factor of Fresnel
+Material.diffuse_intensity -> diffuse_intensity:    float    Amount of diffuse reflection
+Material.diffuse_ramp -> diffuse_ramp:    pointer, (read-only)    Color ramp used to affect diffuse shading
+Material.diffuse_ramp_blend -> diffuse_ramp_blend:    enum    
+Material.diffuse_ramp_factor -> diffuse_ramp_factor:    float    Blending factor (also uses alpha in Colorband)
+Material.diffuse_ramp_input -> diffuse_ramp_input:    enum    
+Material.diffuse_shader -> diffuse_shader:    enum    
+Material.diffuse_toon_size -> diffuse_toon_size:    float    Size of diffuse toon area
+Material.diffuse_toon_smooth -> diffuse_toon_smooth:    float    Smoothness of diffuse toon area
+Material.emit -> emit:    float    Amount of light to emit
+Material.halo -> halo:    pointer, (read-only)    Halo settings for the material
+Material.light_group -> light_group:    pointer    Limit lighting to lamps in this Group
+Material.mirror_color -> mirror_color:    float    Mirror color of the material
+Material.node_tree -> node_tree:    pointer, (read-only)    Node tree for node based materials
+Material.physics -> physics:    pointer, (read-only)    Game physics settings
+Material.preview_render_type -> preview_render_type:    enum    Type of preview render
+Material.raytrace_mirror -> raytrace_mirror:    pointer, (read-only)    Raytraced reflection settings for the material
+Material.raytrace_transparency -> raytrace_transparency:    pointer, (read-only)    Raytraced transparency settings for the material
+Material.roughness -> roughness:    float    Oren-Nayar Roughness
+Material.shadow_buffer_bias -> shadow_buffer_bias:    float    Factor to multiply shadow buffer bias with (0 is ignore.)
+Material.shadow_casting_alpha -> shadow_casting_alpha:    float    Shadow casting alpha, in use for Irregular and Deep shadow buffer
+Material.shadow_ray_bias -> shadow_ray_bias:    float    Shadow raytracing bias to prevent terminator problems on shadow boundary
+Material.specular_alpha -> specular_alpha:    float    Alpha transparency for specular areas
+Material.specular_color -> specular_color:    float    Specular color of the material
+Material.specular_hardness -> specular_hardness:    int    
+Material.specular_intensity -> specular_intensity:    float    
+Material.specular_ior -> specular_ior:    float    
+Material.specular_ramp -> specular_ramp:    pointer, (read-only)    Color ramp used to affect specular shading
+Material.specular_ramp_blend -> specular_ramp_blend:    enum    
+Material.specular_ramp_factor -> specular_ramp_factor:    float    Blending factor (also uses alpha in Colorband)
+Material.specular_ramp_input -> specular_ramp_input:    enum    
+Material.specular_shader -> specular_shader:    enum    
+Material.specular_slope -> specular_slope:    float    The standard deviation of surface slope
+Material.specular_toon_size -> specular_toon_size:    float    Size of specular toon area
+Material.specular_toon_smooth -> specular_toon_smooth:    float    Smoothness of specular toon area
+Material.strand -> strand:    pointer, (read-only)    Strand settings for the material
+Material.subsurface_scattering -> subsurface_scattering:    pointer, (read-only)    Subsurface scattering settings for the material
+Material.texture_slots -> texture_slots:    collection, (read-only)    Texture slots defining the mapping and influence of textures
+Material.translucency -> translucency:    float    Amount of diffuse shading on the back side
+Material.transparency_method -> transparency_method:    enum    Method to use for rendering transparency
+Material.type -> type:    enum    Material type defining how the object is rendered
+Material.volume -> volume:    pointer, (read-only)    Volume settings for the material
+Material.z_offset -> z_offset:    float    Gives faces an artificial offset in the Z buffer for Z transparency
+MaterialHalo.add -> add:    float    Sets the strength of the add effect
+MaterialHalo.flare_boost -> flare_boost:    float    Gives the flare extra strength
+MaterialHalo.flare_seed -> flare_seed:    int    Specifies an offset in the flare seed table
+MaterialHalo.flare_size -> flare_size:    float    Sets the factor by which the flare is larger than the halo
+MaterialHalo.flare_subsize -> flare_subsize:    float    Sets the dimension of the subflares, dots and circles
+MaterialHalo.flares_sub -> flares_sub:    int    Sets the number of subflares
+MaterialHalo.hardness -> hardness:    int    Sets the hardness of the halo
+MaterialHalo.line_number -> line_number:    int    Sets the number of star shaped lines rendered over the halo
+MaterialHalo.rings -> rings:    int    Sets the number of rings rendered over the halo
+MaterialHalo.seed -> seed:    int    Randomizes ring dimension and line location
+MaterialHalo.size -> size:    float    Sets the dimension of the halo
+MaterialHalo.star_tips -> star_tips:    int    Sets the number of points on the star shaped halo
+MaterialPhysics.damp -> damp:    float    Damping of the spring force, when inside the physics distance area
+MaterialPhysics.distance -> distance:    float    Distance of the physics area
+MaterialPhysics.elasticity -> elasticity:    float    Elasticity of collisions
+MaterialPhysics.force -> force:    float    Upward spring force, when inside the physics distance area
+MaterialPhysics.friction -> friction:    float    Coulomb friction coefficient, when inside the physics distance area
+MaterialRaytraceMirror.depth -> depth:    int    Maximum allowed number of light inter-reflections
+MaterialRaytraceMirror.distance -> distance:    float    Maximum distance of reflected rays. Reflections further than this range fade to sky color or material color
+MaterialRaytraceMirror.fade_to -> fade_to:    enum    The color that rays with no intersection within the Max Distance take. Material color can be best for indoor scenes, sky color for outdoor
+MaterialRaytraceMirror.fresnel -> fresnel:    float    Power of Fresnel for mirror reflection
+MaterialRaytraceMirror.fresnel_factor -> fresnel_factor:    float    Blending factor for Fresnel
+MaterialRaytraceMirror.gloss_anisotropic -> gloss_anisotropic:    float    The shape of the reflection, from 0.0 (circular) to 1.0 (fully stretched along the tangent
+MaterialRaytraceMirror.gloss_factor -> gloss_factor:    float    The shininess of the reflection. Values < 1.0 give diffuse, blurry reflections
+MaterialRaytraceMirror.gloss_samples -> gloss_samples:    int    Number of cone samples averaged for blurry reflections
+MaterialRaytraceMirror.gloss_threshold -> gloss_threshold:    float    Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped
+MaterialRaytraceMirror.reflect_factor -> reflect_factor:    float    Sets the amount mirror reflection for raytrace
+MaterialRaytraceTransparency.depth -> depth:    int    Maximum allowed number of light inter-refractions
+MaterialRaytraceTransparency.falloff -> falloff:    float    Falloff power for transmissivity filter effect (1.0 is linear)
+MaterialRaytraceTransparency.filter -> filter:    float    Amount to blend in the material's diffuse color in raytraced transparency (simulating absorption)
+MaterialRaytraceTransparency.fresnel -> fresnel:    float    Power of Fresnel for transparency (Ray or ZTransp)
+MaterialRaytraceTransparency.fresnel_factor -> fresnel_factor:    float    Blending factor for Fresnel
+MaterialRaytraceTransparency.gloss_factor -> gloss_factor:    float    The clarity of the refraction. Values < 1.0 give diffuse, blurry refractions
+MaterialRaytraceTransparency.gloss_samples -> gloss_samples:    int    Number of cone samples averaged for blurry refractions
+MaterialRaytraceTransparency.gloss_threshold -> gloss_threshold:    float    Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped
+MaterialRaytraceTransparency.ior -> ior:    float    Sets angular index of refraction for raytraced refraction
+MaterialRaytraceTransparency.limit -> limit:    float    Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)
+MaterialSlot.link -> link:    enum    Link material to object or the object's data
+MaterialSlot.material -> material:    pointer    Material datablock used by this material slot
+MaterialSlot.name -> name:    string, (read-only)    Material slot name
+MaterialStrand.blend_distance -> blend_distance:    float    Worldspace distance over which to blend in the surface normal
+MaterialStrand.min_size -> min_size:    float    Minimum size of strands in pixels
+MaterialStrand.root_size -> root_size:    float    Start size of strands in pixels or Blender units
+MaterialStrand.shape -> shape:    float    Positive values make strands rounder, negative makes strands spiky
+MaterialStrand.tip_size -> tip_size:    float    End size of strands in pixels or Blender units
+MaterialStrand.uv_layer -> uv_layer:    string    Name of UV layer to override
+MaterialStrand.width_fade -> width_fade:    float    Transparency along the width of the strand
+MaterialSubsurfaceScattering.back -> back:    float    Back scattering weight
+MaterialSubsurfaceScattering.color -> color:    float    Scattering color
+MaterialSubsurfaceScattering.color_factor -> color_factor:    float    Blend factor for SSS colors
+MaterialSubsurfaceScattering.error_tolerance -> error_tolerance:    float    Error tolerance (low values are slower and higher quality)
+MaterialSubsurfaceScattering.front -> front:    float    Front scattering weight
+MaterialSubsurfaceScattering.ior -> ior:    float    Index of refraction (higher values are denser)
+MaterialSubsurfaceScattering.radius -> radius:    float    Mean red/green/blue scattering path length
+MaterialSubsurfaceScattering.scale -> scale:    float    Object scale factor
+MaterialSubsurfaceScattering.texture_factor -> texture_factor:    float    Texture scatting blend factor
+MaterialTextureSlot.alpha_factor -> alpha_factor:    float    Amount texture affects alpha
+MaterialTextureSlot.ambient_factor -> ambient_factor:    float    Amount texture affects ambient
+MaterialTextureSlot.colordiff_factor -> colordiff_factor:    float    Amount texture affects diffuse color
+MaterialTextureSlot.coloremission_factor -> coloremission_factor:    float    Amount texture affects emission color
+MaterialTextureSlot.colorreflection_factor -> colorreflection_factor:    float    Amount texture affects color of out-scattered light
+MaterialTextureSlot.colorspec_factor -> colorspec_factor:    float    Amount texture affects specular color
+MaterialTextureSlot.colortransmission_factor -> colortransmission_factor:    float    Amount texture affects result color after light has been scattered/absorbed
+MaterialTextureSlot.density_factor -> density_factor:    float    Amount texture affects density
+MaterialTextureSlot.diffuse_factor -> diffuse_factor:    float    Amount texture affects diffuse reflectivity
+MaterialTextureSlot.displacement_factor -> displacement_factor:    float    Amount texture displaces the surface
+MaterialTextureSlot.emission_factor -> emission_factor:    float    Amount texture affects emission
+MaterialTextureSlot.emit_factor -> emit_factor:    float    Amount texture affects emission
+MaterialTextureSlot.hardness_factor -> hardness_factor:    float    Amount texture affects hardness
+MaterialTextureSlot.mapping -> mapping:    enum    
+MaterialTextureSlot.mirror_factor -> mirror_factor:    float    Amount texture affects mirror color
+MaterialTextureSlot.normal_factor -> normal_factor:    float    Amount texture affects normal values
+MaterialTextureSlot.normal_map_space -> normal_map_space:    enum    
+MaterialTextureSlot.object -> object:    pointer    Object to use for mapping with Object texture coordinates
+MaterialTextureSlot.raymir_factor -> raymir_factor:    float    Amount texture affects ray mirror
+MaterialTextureSlot.reflection_factor -> reflection_factor:    float    Amount texture affects brightness of out-scattered light
+MaterialTextureSlot.scattering_factor -> scattering_factor:    float    Amount texture affects scattering
+MaterialTextureSlot.specular_factor -> specular_factor:    float    Amount texture affects specular reflectivity
+MaterialTextureSlot.texture_coordinates -> texture_coordinates:    enum    
+MaterialTextureSlot.translucency_factor -> translucency_factor:    float    Amount texture affects translucency
+MaterialTextureSlot.uv_layer -> uv_layer:    string    UV layer to use for mapping with UV texture coordinates
+MaterialTextureSlot.warp_factor -> warp_factor:    float    Amount texture affects texture coordinates of next channels
+MaterialTextureSlot.x_mapping -> x_mapping:    enum    
+MaterialTextureSlot.y_mapping -> y_mapping:    enum    
+MaterialTextureSlot.z_mapping -> z_mapping:    enum    
+MaterialVolume.asymmetry -> asymmetry:    float    Back scattering (-1.0) to Forward scattering (1.0) and the range in between
+MaterialVolume.cache_resolution -> cache_resolution:    int    Resolution of the voxel grid, low resolutions are faster, high resolutions use more memory
+MaterialVolume.density -> density:    float    The base density of the volume
+MaterialVolume.density_scale -> density_scale:    float    Multiplier for the material's density
+MaterialVolume.depth_cutoff -> depth_cutoff:    float    Stop ray marching early if transmission drops below this luminance - higher values give speedups in dense volumes at the expense of accuracy
+MaterialVolume.emission -> emission:    float    Amount of light that gets emitted by the volume
+MaterialVolume.emission_color -> emission_color:    float    
+MaterialVolume.lighting_mode -> lighting_mode:    enum    Method of shading, attenuating, and scattering light through the volume
+MaterialVolume.ms_diffusion -> ms_diffusion:    float    Diffusion factor, the strength of the blurring effect
+MaterialVolume.ms_intensity -> ms_intensity:    float    Multiplier for multiple scattered light energy
+MaterialVolume.ms_spread -> ms_spread:    float    Proportional distance over which the light is diffused
+MaterialVolume.reflection -> reflection:    float    Multiplier to make out-scattered light brighter or darker (non-physically correct)
+MaterialVolume.reflection_color -> reflection_color:    float    Colour of light scattered out of the volume (does not affect transmission)
+MaterialVolume.scattering -> scattering:    float    Amount of light that gets scattered out by the volume - the more out-scattering, the shallower the light will penetrate
+MaterialVolume.step_calculation -> step_calculation:    enum    Method of calculating the steps through the volume
+MaterialVolume.step_size -> step_size:    float    Distance between subsequent volume depth samples
+MaterialVolume.transmission_color -> transmission_color:    float    Result color of the volume, after other light has been scattered/absorbed
+Menu.bl_idname -> bl_idname:    string    
+Menu.bl_label -> bl_label:    string    
+Menu.layout -> layout:    pointer, (read-only)    
+Mesh.active_uv_texture -> active_uv_texture:    pointer    Active UV texture
+Mesh.active_uv_texture_index -> active_uv_texture_index:    int    Active UV texture index
+Mesh.active_vertex_color -> active_vertex_color:    pointer    Active vertex color layer
+Mesh.active_vertex_color_index -> active_vertex_color_index:    int    Active vertex color index
+Mesh.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+Mesh.autosmooth_angle -> autosmooth_angle:    int    Defines maximum angle between face normals that 'Auto Smooth' will operate on
+Mesh.edges -> edges:    collection, (read-only)    Edges of the mesh
+Mesh.faces -> faces:    collection, (read-only)    Faces of the mesh
+Mesh.float_layers -> float_layers:    collection, (read-only)    
+Mesh.int_layers -> int_layers:    collection, (read-only)    
+Mesh.materials -> materials:    collection, (read-only)    
+Mesh.shape_keys -> shape_keys:    pointer, (read-only)    
+Mesh.sticky -> sticky:    collection, (read-only)    Sticky texture coordinates
+Mesh.string_layers -> string_layers:    collection, (read-only)    
+Mesh.texco_mesh -> texco_mesh:    pointer    Derive texture coordinates from another mesh
+Mesh.texspace_loc -> texspace_loc:    float    Texture space location
+Mesh.texspace_size -> texspace_size:    float    Texture space size
+Mesh.texture_mesh -> texture_mesh:    pointer    Use another mesh for texture indices (vertex indices must be aligned)
+Mesh.total_edge_sel -> total_edge_sel:    int, (read-only)    Selected edge count in editmode
+Mesh.total_face_sel -> total_face_sel:    int, (read-only)    Selected face count in editmode
+Mesh.total_vert_sel -> total_vert_sel:    int, (read-only)    Selected vertex count in editmode
+Mesh.uv_texture_clone -> uv_texture_clone:    pointer    UV texture to be used as cloning source
+Mesh.uv_texture_clone_index -> uv_texture_clone_index:    int    Clone UV texture index
+Mesh.uv_texture_stencil -> uv_texture_stencil:    pointer    UV texture to mask the painted area
+Mesh.uv_texture_stencil_index -> uv_texture_stencil_index:    int    Mask UV texture index
+Mesh.uv_textures -> uv_textures:    collection, (read-only)    
+Mesh.vertex_colors -> vertex_colors:    collection, (read-only)    
+Mesh.verts -> verts:    collection, (read-only)    Vertices of the mesh
+MeshColor.color1 -> color1:    float    
+MeshColor.color2 -> color2:    float    
+MeshColor.color3 -> color3:    float    
+MeshColor.color4 -> color4:    float    
+MeshColorLayer.data -> data:    collection, (read-only)    
+MeshColorLayer.name -> name:    string    
+MeshDeformModifier.object -> object:    pointer    Mesh object to deform with
+MeshDeformModifier.precision -> precision:    int    The grid size for binding
+MeshDeformModifier.vertex_group -> vertex_group:    string    Vertex group name
+MeshEdge.bevel_weight -> bevel_weight:    float    Weight used by the Bevel modifier
+MeshEdge.crease -> crease:    float    Weight used by the Subsurf modifier for creasing
+MeshEdge.index -> index:    int, (read-only)    Index number of the vertex
+MeshEdge.verts -> verts:    int    Vertex indices
+MeshFace.area -> area:    float, (read-only)    read only area of the face
+MeshFace.index -> index:    int, (read-only)    Index number of the vertex
+MeshFace.material_index -> material_index:    int    
+MeshFace.normal -> normal:    float, (read-only)    local space unit length normal vector for this face
+MeshFace.verts -> verts:    int    Vertex indices
+MeshFace.verts_raw -> verts_raw:    int    Fixed size vertex indices array
+MeshFaces.active -> active:    int    The active face for this mesh
+MeshFaces.active_tface -> active_tface:    pointer, (read-only)    Active Texture Face
+MeshFloatProperty.value -> value:    float    
+MeshFloatPropertyLayer.data -> data:    collection, (read-only)    
+MeshFloatPropertyLayer.name -> name:    string    
+MeshIntProperty.value -> value:    int    
+MeshIntPropertyLayer.data -> data:    collection, (read-only)    
+MeshIntPropertyLayer.name -> name:    string    
+MeshSticky.co -> co:    float    Sticky texture coordinate location
+MeshStringProperty.value -> value:    string    
+MeshStringPropertyLayer.data -> data:    collection, (read-only)    
+MeshStringPropertyLayer.name -> name:    string    
+MeshTextureFace.image -> image:    pointer    
+MeshTextureFace.transp -> transp:    enum    Transparency blending mode
+MeshTextureFace.uv -> uv:    float    
+MeshTextureFace.uv1 -> uv1:    float    
+MeshTextureFace.uv2 -> uv2:    float    
+MeshTextureFace.uv3 -> uv3:    float    
+MeshTextureFace.uv4 -> uv4:    float    
+MeshTextureFace.uv_raw -> uv_raw:    float    Fixed size UV coordinates array
+MeshTextureFaceLayer.data -> data:    collection, (read-only)    
+MeshTextureFaceLayer.name -> name:    string    
+MeshVertex.bevel_weight -> bevel_weight:    float    Weight used by the Bevel modifier 'Only Vertices' option
+MeshVertex.co -> co:    float    
+MeshVertex.groups -> groups:    collection, (read-only)    Weights for the vertex groups this vertex is member of
+MeshVertex.index -> index:    int, (read-only)    Index number of the vertex
+MeshVertex.normal -> normal:    float    Vertex Normal
+MessageActuator.body_message -> body_message:    string    Optional message body Text
+MessageActuator.body_property -> body_property:    string    The message body will be set by the Property Value
+MessageActuator.body_type -> body_type:    enum    Toggle message type: either Text or a PropertyName
+MessageActuator.subject -> subject:    string    Optional message subject. This is what can be filtered on
+MessageActuator.to_property -> to_property:    string    Optional send message to objects with this name only, or empty to broadcast
+MessageSensor.subject -> subject:    string    Optional subject filter: only accept messages with this subject, or empty for all
+MetaBall.active_element -> active_element:    pointer, (read-only)    Last selected element
+MetaBall.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+MetaBall.elements -> elements:    collection, (read-only)    Meta elements
+MetaBall.flag -> flag:    enum    Metaball edit update behavior
+MetaBall.materials -> materials:    collection, (read-only)    
+MetaBall.render_size -> render_size:    float    Polygonization resolution in rendering
+MetaBall.texspace_loc -> texspace_loc:    float    Texture space location
+MetaBall.texspace_size -> texspace_size:    float    Texture space size
+MetaBall.threshold -> threshold:    float    Influence of meta elements
+MetaBall.wire_size -> wire_size:    float    Polygonization resolution in the 3D viewport
+MetaElement.location -> location:    float    
+MetaElement.radius -> radius:    float    
+MetaElement.rotation -> rotation:    float    
+MetaElement.size_x -> size_x:    float    Size of element, use of components depends on element type
+MetaElement.size_y -> size_y:    float    Size of element, use of components depends on element type
+MetaElement.size_z -> size_z:    float    Size of element, use of components depends on element type
+MetaElement.stiffness -> stiffness:    float    Stiffness defines how much of the element to fill
+MetaElement.type -> type:    enum    Metaball types
+MetaSequence.animation_end_offset -> animation_end_offset:    int    Animation end offset (trim end)
+MetaSequence.animation_start_offset -> animation_start_offset:    int    Animation start offset (trim start)
+MetaSequence.color_balance -> color_balance:    pointer, (read-only)    
+MetaSequence.crop -> crop:    pointer, (read-only)    
+MetaSequence.multiply_colors -> multiply_colors:    float    
+MetaSequence.proxy -> proxy:    pointer, (read-only)    
+MetaSequence.sequences -> sequences:    collection, (read-only)    
+MetaSequence.strobe -> strobe:    float    Only display every nth frame
+MetaSequence.transform -> transform:    pointer, (read-only)    
+MirrorModifier.merge_limit -> merge_limit:    float    Distance from axis within which mirrored vertices are merged
+MirrorModifier.mirror_object -> mirror_object:    pointer    Object to use as mirror
+Modifier.name -> name:    string    Modifier name
+Modifier.type -> type:    enum, (read-only)    
+MotionPath.frame_end -> frame_end:    int, (read-only)    End frame of the stored range
+MotionPath.frame_start -> frame_start:    int, (read-only)    Starting frame of the stored range
+MotionPath.length -> length:    int, (read-only)    Number of frames cached
+MotionPath.points -> points:    collection, (read-only)    Cached positions per frame
+MotionPathVert.co -> co:    float    
+MouseSensor.mouse_event -> mouse_event:    enum    Specify the type of event this mouse sensor should trigger on
+MovieSequence.animation_end_offset -> animation_end_offset:    int    Animation end offset (trim end)
+MovieSequence.animation_start_offset -> animation_start_offset:    int    Animation start offset (trim start)
+MovieSequence.color_balance -> color_balance:    pointer, (read-only)    
+MovieSequence.crop -> crop:    pointer, (read-only)    
+MovieSequence.filepath -> filepath:    string    
+MovieSequence.mpeg_preseek -> mpeg_preseek:    int    For MPEG movies, preseek this many frames
+MovieSequence.multiply_colors -> multiply_colors:    float    
+MovieSequence.proxy -> proxy:    pointer, (read-only)    
+MovieSequence.strobe -> strobe:    float    Only display every nth frame
+MovieSequence.transform -> transform:    pointer, (read-only)    
+MulticamSequence.animation_end_offset -> animation_end_offset:    int    Animation end offset (trim end)
+MulticamSequence.animation_start_offset -> animation_start_offset:    int    Animation start offset (trim start)
+MulticamSequence.color_balance -> color_balance:    pointer, (read-only)    
+MulticamSequence.crop -> crop:    pointer, (read-only)    
+MulticamSequence.multicam_source -> multicam_source:    int    
+MulticamSequence.multiply_colors -> multiply_colors:    float    
+MulticamSequence.proxy -> proxy:    pointer, (read-only)    
+MulticamSequence.strobe -> strobe:    float    Only display every nth frame
+MulticamSequence.transform -> transform:    pointer, (read-only)    
+MultiresModifier.filepath -> filepath:    string    Path to external displacements file
+MultiresModifier.levels -> levels:    int    Number of subdivisions to use in the viewport
+MultiresModifier.render_levels -> render_levels:    int    
+MultiresModifier.sculpt_levels -> sculpt_levels:    int    Number of subdivisions to use in sculpt mode
+MultiresModifier.subdivision_type -> subdivision_type:    enum    Selects type of subdivision algorithm
+MultiresModifier.total_levels -> total_levels:    int, (read-only)    Number of subdivisions for which displacements are stored
+MusgraveTexture.gain -> gain:    float    The gain multiplier
+MusgraveTexture.highest_dimension -> highest_dimension:    float    Highest fractal dimension
+MusgraveTexture.lacunarity -> lacunarity:    float    Gap between successive frequencies
+MusgraveTexture.musgrave_type -> musgrave_type:    enum    
+MusgraveTexture.nabla -> nabla:    float    Size of derivative offset used for calculating normal
+MusgraveTexture.noise_basis -> noise_basis:    enum    Sets the noise basis used for turbulence
+MusgraveTexture.noise_intensity -> noise_intensity:    float    
+MusgraveTexture.noise_size -> noise_size:    float    Sets scaling for noise input
+MusgraveTexture.octaves -> octaves:    float    Number of frequencies used
+MusgraveTexture.offset -> offset:    float    The fractal offset
+NearSensor.distance -> distance:    float    Trigger distance
+NearSensor.property -> property:    string    Only look for objects with this property
+NearSensor.reset_distance -> reset_distance:    float    
+NetRenderJob.name -> name:    string    
+NetRenderSettings.active_blacklisted_slave_index -> active_blacklisted_slave_index:    int    
+NetRenderSettings.active_job_index -> active_job_index:    int    
+NetRenderSettings.active_slave_index -> active_slave_index:    int    
+NetRenderSettings.chunks -> chunks:    int    Number of frame to dispatch to each slave in one chunk
+NetRenderSettings.job_category -> job_category:    string    Category of the job
+NetRenderSettings.job_id -> job_id:    string    id of the last sent render job
+NetRenderSettings.job_name -> job_name:    string    Name of the job
+NetRenderSettings.jobs -> jobs:    collection, (read-only)    
+NetRenderSettings.mode -> mode:    enum    Mode of operation of this instance
+NetRenderSettings.path -> path:    string    Path for temporary files
+NetRenderSettings.priority -> priority:    int    Priority of the job
+NetRenderSettings.server_address -> server_address:    string    IP or name of the master render server
+NetRenderSettings.server_port -> server_port:    int    port of the master render server
+NetRenderSettings.slaves -> slaves:    collection, (read-only)    
+NetRenderSettings.slaves_blacklist -> slaves_blacklist:    collection, (read-only)    
+NetRenderSlave.name -> name:    string    
+NlaStrip.action -> action:    pointer    Action referenced by this strip
+NlaStrip.action_frame_end -> action_frame_end:    float    
+NlaStrip.action_frame_start -> action_frame_start:    float    
+NlaStrip.blend_in -> blend_in:    float    Number of frames at start of strip to fade in influence
+NlaStrip.blend_out -> blend_out:    float    
+NlaStrip.blending -> blending:    enum    Method used for combining strip's result with accumulated result
+NlaStrip.extrapolation -> extrapolation:    enum    Action to take for gaps past the strip extents
+NlaStrip.fcurves -> fcurves:    collection, (read-only)    F-Curves for controlling the strip's influence and timing
+NlaStrip.frame_end -> frame_end:    float    
+NlaStrip.frame_start -> frame_start:    float    
+NlaStrip.influence -> influence:    float    Amount the strip contributes to the current result
+NlaStrip.modifiers -> modifiers:    collection, (read-only)    Modifiers affecting all the F-Curves in the referenced Action
+NlaStrip.name -> name:    string    
+NlaStrip.repeat -> repeat:    float    Number of times to repeat the action range
+NlaStrip.scale -> scale:    float    Scaling factor for action
+NlaStrip.strip_time -> strip_time:    float    Frame of referenced Action to evaluate
+NlaStrip.strips -> strips:    collection, (read-only)    NLA Strips that this strip acts as a container for (if it is of type Meta)
+NlaStrip.type -> type:    enum, (read-only)    Type of NLA Strip
+NlaTrack.name -> name:    string    
+NlaTrack.strips -> strips:    collection, (read-only)    NLA Strips on this NLA-track
+Node.inputs -> inputs:    collection, (read-only)    
+Node.location -> location:    float    
+Node.name -> name:    string    Node name
+Node.outputs -> outputs:    collection, (read-only)    
+NodeGroup.nodetree -> nodetree:    pointer    
+NodeTree.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+NodeTree.grease_pencil -> grease_pencil:    pointer    Grease Pencil datablock
+NodeTree.nodes -> nodes:    collection, (read-only)    
+Object.active_material -> active_material:    pointer    Active material being displayed
+Object.active_material_index -> active_material_index:    int    Index of active material slot
+Object.active_particle_system -> active_particle_system:    pointer, (read-only)    Active particle system being displayed
+Object.active_particle_system_index -> active_particle_system_index:    int    Index of active particle system slot
+Object.active_shape_key -> active_shape_key:    pointer, (read-only)    Current shape key
+Object.active_shape_key_index -> active_shape_key_index:    int    Current shape key index
+Object.active_vertex_group -> active_vertex_group:    pointer, (read-only)    Vertex groups of the object
+Object.active_vertex_group_index -> active_vertex_group_index:    int    Active index in vertex group array
+Object.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+Object.animation_visualisation -> animation_visualisation:    pointer, (read-only)    Animation data for this datablock
+Object.bound_box -> bound_box:    float, (read-only)    Objects bound box in object-space coordinates
+Object.collision -> collision:    pointer, (read-only)    Settings for using the objects as a collider in physics simulation
+Object.color -> color:    float    Object color and alpha, used when faces have the ObColor mode enabled
+Object.constraints -> constraints:    collection, (read-only)    Constraints affecting the transformation of the object
+Object.data -> data:    pointer    Object data
+Object.delta_location -> delta_location:    float    Extra translation added to the location of the object
+Object.delta_rotation_euler -> delta_rotation_euler:    float    Extra rotation added to the rotation of the object (when using Euler rotations)
+Object.delta_rotation_quaternion -> delta_rotation_quaternion:    float    Extra rotation added to the rotation of the object (when using Quaternion rotations)
+Object.delta_scale -> delta_scale:    float    Extra scaling added to the scale of the object
+Object.dimensions -> dimensions:    float    Absolute bounding box dimensions of the object
+Object.draw_bounds_type -> draw_bounds_type:    enum    Object boundary display type
+Object.dupli_faces_scale -> dupli_faces_scale:    float    Scale the DupliFace objects
+Object.dupli_frames_end -> dupli_frames_end:    int    End frame for DupliFrames
+Object.dupli_frames_off -> dupli_frames_off:    int    Recurring frames to exclude from the Dupliframes
+Object.dupli_frames_on -> dupli_frames_on:    int    Number of frames to use between DupOff frames
+Object.dupli_frames_start -> dupli_frames_start:    int    Start frame for DupliFrames
+Object.dupli_group -> dupli_group:    pointer    Instance an existing group
+Object.dupli_list -> dupli_list:    collection, (read-only)    Object duplis
+Object.dupli_type -> dupli_type:    enum    If not None, object duplication method to use
+Object.empty_draw_size -> empty_draw_size:    float    Size of display for empties in the viewport
+Object.empty_draw_type -> empty_draw_type:    enum    Viewport display style for empties
+Object.field -> field:    pointer, (read-only)    Settings for using the objects as a field in physics simulation
+Object.game -> game:    pointer, (read-only)    Game engine related settings for the object
+Object.grease_pencil -> grease_pencil:    pointer    Grease Pencil datablock
+Object.location -> location:    float    Location of the object
+Object.material_slots -> material_slots:    collection, (read-only)    Material slots in the object
+Object.matrix_local -> matrix_local:    float    Parent relative transformation matrix
+Object.matrix_world -> matrix_world:    float    Worldspace transformation matrix
+Object.max_draw_type -> max_draw_type:    enum    Maximum draw type to display object with in viewport
+Object.mode -> mode:    enum, (read-only)    Object interaction mode
+Object.modifiers -> modifiers:    collection, (read-only)    Modifiers affecting the geometric data of the object
+Object.motion_path -> motion_path:    pointer, (read-only)    Motion Path for this element
+Object.parent -> parent:    pointer    Parent Object
+Object.parent_bone -> parent_bone:    string    Name of parent bone in case of a bone parenting relation
+Object.parent_type -> parent_type:    enum    Type of parent relation
+Object.parent_vertices -> parent_vertices:    int, (read-only)    Indices of vertices in cases of a vertex parenting relation
+Object.particle_systems -> particle_systems:    collection, (read-only)    Particle systems emitted from the object
+Object.pass_index -> pass_index:    int    Index # for the IndexOB render pass
+Object.pose -> pose:    pointer, (read-only)    Current pose for armatures
+Object.pose_library -> pose_library:    pointer, (read-only)    Action used as a pose library for armatures
+Object.proxy -> proxy:    pointer, (read-only)    Library object this proxy object controls
+Object.proxy_group -> proxy_group:    pointer, (read-only)    Library group duplicator object this proxy object controls
+Object.rotation_axis_angle -> rotation_axis_angle:    float    Angle of Rotation for Axis-Angle rotation representation
+Object.rotation_euler -> rotation_euler:    float    Rotation in Eulers
+Object.rotation_mode -> rotation_mode:    enum    
+Object.rotation_quaternion -> rotation_quaternion:    float    Rotation in Quaternions
+Object.scale -> scale:    float    Scaling of the object
+Object.soft_body -> soft_body:    pointer, (read-only)    Settings for soft body simulation
+Object.time_offset -> time_offset:    float    Animation offset in frames for F-Curve and dupligroup instances
+Object.track_axis -> track_axis:    enum    Axis that points in 'forward' direction
+Object.type -> type:    enum, (read-only)    Type of Object
+Object.up_axis -> up_axis:    enum    Axis that points in the upward direction
+Object.vertex_groups -> vertex_groups:    collection, (read-only)    Vertex groups of the object
+ObjectActuator.angular_velocity -> angular_velocity:    float    Sets the angular velocity
+ObjectActuator.damping -> damping:    int    Number of frames to reach the target velocity
+ObjectActuator.derivate_coefficient -> derivate_coefficient:    float    Not required, high values can cause instability
+ObjectActuator.force -> force:    float    Sets the force
+ObjectActuator.force_max_x -> force_max_x:    float    Set the upper limit for force
+ObjectActuator.force_max_y -> force_max_y:    float    Set the upper limit for force
+ObjectActuator.force_max_z -> force_max_z:    float    Set the upper limit for force
+ObjectActuator.force_min_x -> force_min_x:    float    Set the lower limit for force
+ObjectActuator.force_min_y -> force_min_y:    float    Set the lower limit for force
+ObjectActuator.force_min_z -> force_min_z:    float    Set the lower limit for force
+ObjectActuator.integral_coefficient -> integral_coefficient:    float    Low value (0.01) for slow response, high value (0.5) for fast response
+ObjectActuator.linear_velocity -> linear_velocity:    float    Sets the linear velocity (in Servo mode it sets the target relative linear velocity, it will be achieved by automatic application of force. Null velocity is a valid target)
+ObjectActuator.loc -> loc:    float    Sets the location
+ObjectActuator.mode -> mode:    enum    Specify the motion system
+ObjectActuator.proportional_coefficient -> proportional_coefficient:    float    Typical value is 60x integral coefficient
+ObjectActuator.reference_object -> reference_object:    pointer    Reference object for velocity calculation, leave empty for world reference
+ObjectActuator.rot -> rot:    float    Sets the rotation
+ObjectActuator.torque -> torque:    float    Sets the torque
+ObjectBase.object -> object:    pointer, (read-only)    Object this base links to
+ObjectConstraints.active -> active:    pointer    Active Object constraint
+ObstacleFluidSettings.impact_factor -> impact_factor:    float    This is an unphysical value for moving objects - it controls the impact an obstacle has on the fluid, =0 behaves a bit like outflow (deleting fluid), =1 is default, while >1 results in high forces. Can be used to tweak total mass
+ObstacleFluidSettings.partial_slip_factor -> partial_slip_factor:    float    Amount of mixing between no- and free-slip, 0 is no slip and 1 is free slip
+ObstacleFluidSettings.slip_type -> slip_type:    enum    
+ObstacleFluidSettings.volume_initialization -> volume_initialization:    enum    Volume initialization type
+Operator.bl_description -> bl_description:    string    
+Operator.bl_idname -> bl_idname:    string    
+Operator.bl_label -> bl_label:    string    
+Operator.bl_options -> bl_options:    enum    Options for this operator type
+Operator.layout -> layout:    pointer, (read-only)    
+Operator.name -> name:    string, (read-only)    
+Operator.properties -> properties:    pointer, (read-only)    
+OperatorFileListElement.name -> name:    string    the name of a file or directory within a file list
+OperatorMousePath.loc -> loc:    float    Mouse location
+OperatorMousePath.time -> time:    float    Time of mouse location
+OperatorStrokeElement.location -> location:    float    
+OperatorStrokeElement.mouse -> mouse:    float    
+OperatorStrokeElement.pressure -> pressure:    float    Tablet pressure
+OperatorStrokeElement.time -> time:    float    
+OperatorTypeMacro.properties -> properties:    pointer, (read-only)    
+OutflowFluidSettings.volume_initialization -> volume_initialization:    enum    Volume initialization type
+PackedFile.size -> size:    int, (read-only)    Size of packed file in bytes
+Paint.active_brush_index -> active_brush_index:    int    
+Paint.active_brush_name -> active_brush_name:    string    
+Paint.brush -> brush:    pointer    Active paint brush
+Paint.brushes -> brushes:    collection, (read-only)    Brushes selected for this paint mode
+Panel.bl_context -> bl_context:    string    
+Panel.bl_idname -> bl_idname:    string    
+Panel.bl_label -> bl_label:    string    
+Panel.bl_region_type -> bl_region_type:    enum    
+Panel.bl_space_type -> bl_space_type:    enum    
+Panel.layout -> layout:    pointer, (read-only)    
+Panel.text -> text:    string    
+ParentActuator.mode -> mode:    enum    
+ParentActuator.object -> object:    pointer    Set this object as parent
+Particle.alive_state -> alive_state:    enum    
+Particle.angular_velocity -> angular_velocity:    float    
+Particle.birthtime -> birthtime:    float    
+Particle.die_time -> die_time:    float    
+Particle.hair -> hair:    collection, (read-only)    
+Particle.keys -> keys:    collection, (read-only)    
+Particle.lifetime -> lifetime:    float    
+Particle.location -> location:    float    
+Particle.prev_angular_velocity -> prev_angular_velocity:    float    
+Particle.prev_location -> prev_location:    float    
+Particle.prev_rotation -> prev_rotation:    float    
+Particle.prev_velocity -> prev_velocity:    float    
+Particle.rotation -> rotation:    float    
+Particle.size -> size:    float    
+Particle.velocity -> velocity:    float    
+ParticleBrush.count -> count:    int    Particle count
+ParticleBrush.curve -> curve:    pointer, (read-only)    
+ParticleBrush.length_mode -> length_mode:    enum    
+ParticleBrush.puff_mode -> puff_mode:    enum    
+ParticleBrush.size -> size:    int    Brush size
+ParticleBrush.steps -> steps:    int    Brush steps
+ParticleBrush.strength -> strength:    float    Brush strength
+ParticleDupliWeight.count -> count:    int    The number of times this object is repeated with respect to other objects
+ParticleDupliWeight.name -> name:    string, (read-only)    Particle dupliobject name
+ParticleEdit.add_keys -> add_keys:    int    How many keys to make new particles with
+ParticleEdit.brush -> brush:    pointer, (read-only)    
+ParticleEdit.draw_step -> draw_step:    int    How many steps to draw the path with
+ParticleEdit.emitter_distance -> emitter_distance:    float    Distance to keep particles away from the emitter
+ParticleEdit.fade_frames -> fade_frames:    int    How many frames to fade
+ParticleEdit.object -> object:    pointer, (read-only)    The edited object
+ParticleEdit.selection_mode -> selection_mode:    enum    Particle select and display mode
+ParticleEdit.tool -> tool:    enum    
+ParticleEdit.type -> type:    enum    
+ParticleFluidSettings.alpha_influence -> alpha_influence:    float    Amount of particle alpha change, inverse of size influence: 0=off (all same alpha), 1=full. (large particles get lower alphas, smaller ones higher values)
+ParticleFluidSettings.particle_influence -> particle_influence:    float    Amount of particle size scaling: 0=off (all same size), 1=full (range 0.2-2.0), >1=stronger
+ParticleFluidSettings.path -> path:    string    Directory (and/or filename prefix) to store and load particles from
+ParticleHairKey.location -> location:    float    Location of the hair key in object space
+ParticleHairKey.location_hairspace -> location_hairspace:    float    Location of the hair key in its internal coordinate system, relative to the emitting face
+ParticleHairKey.time -> time:    float    Relative time of key over hair length
+ParticleHairKey.weight -> weight:    float    Weight for cloth simulation
+ParticleInstanceModifier.axis -> axis:    enum    Pole axis for rotation
+ParticleInstanceModifier.object -> object:    pointer    Object that has the particle system
+ParticleInstanceModifier.particle_system_number -> particle_system_number:    int    
+ParticleInstanceModifier.position -> position:    float    Position along path
+ParticleInstanceModifier.random_position -> random_position:    float    Randomize position along path
+ParticleKey.angular_velocity -> angular_velocity:    float    Key angular velocity
+ParticleKey.location -> location:    float    Key location
+ParticleKey.rotation -> rotation:    float    Key rotation quaterion
+ParticleKey.time -> time:    float    Time of key over the simulation
+ParticleKey.velocity -> velocity:    float    Key velocity
+ParticleSettings.active_dupliweight -> active_dupliweight:    pointer, (read-only)    
+ParticleSettings.active_dupliweight_index -> active_dupliweight_index:    int    
+ParticleSettings.adaptive_angle -> adaptive_angle:    int    How many degrees path has to curve to make another render segment
+ParticleSettings.adaptive_pix -> adaptive_pix:    int    How many pixels path has to cover to make another render segment
+ParticleSettings.amount -> amount:    int    Total number of particles
+ParticleSettings.angular_velocity_factor -> angular_velocity_factor:    float    Angular velocity amount
+ParticleSettings.angular_velocity_mode -> angular_velocity_mode:    enum    Particle angular velocity mode
+ParticleSettings.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+ParticleSettings.billboard_align -> billboard_align:    enum    In respect to what the billboards are aligned
+ParticleSettings.billboard_animation -> billboard_animation:    enum    How to animate billboard textures
+ParticleSettings.billboard_object -> billboard_object:    pointer    Billboards face this object (default is active camera)
+ParticleSettings.billboard_offset -> billboard_offset:    float    
+ParticleSettings.billboard_random_tilt -> billboard_random_tilt:    float    Random tilt of the billboards
+ParticleSettings.billboard_split_offset -> billboard_split_offset:    enum    How to offset billboard textures
+ParticleSettings.billboard_tilt -> billboard_tilt:    float    Tilt of the billboards
+ParticleSettings.billboard_uv_split -> billboard_uv_split:    int    Amount of rows/columns to split UV coordinates for billboards
+ParticleSettings.boids -> boids:    pointer, (read-only)    
+ParticleSettings.branch_threshold -> branch_threshold:    float    Threshold of branching
+ParticleSettings.brownian_factor -> brownian_factor:    float    Specify the amount of Brownian motion
+ParticleSettings.child_length -> child_length:    float    Length of child paths
+ParticleSettings.child_length_thres -> child_length_thres:    float    Amount of particles left untouched by child path length
+ParticleSettings.child_nbr -> child_nbr:    int    Amount of children/parent
+ParticleSettings.child_radius -> child_radius:    float    Radius of children around parent
+ParticleSettings.child_random_size -> child_random_size:    float    Random variation to the size of the child particles
+ParticleSettings.child_roundness -> child_roundness:    float    Roundness of children around parent
+ParticleSettings.child_size -> child_size:    float    A multiplier for the child particle size
+ParticleSettings.child_type -> child_type:    enum    Create child particles
+ParticleSettings.clump_factor -> clump_factor:    float    Amount of clumping
+ParticleSettings.clumppow -> clumppow:    float    Shape of clumping
+ParticleSettings.damp_factor -> damp_factor:    float    Specify the amount of damping
+ParticleSettings.display -> display:    int    Percentage of particles to display in 3D view
+ParticleSettings.distribution -> distribution:    enum    How to distribute particles on selected element
+ParticleSettings.drag_factor -> drag_factor:    float    Specify the amount of air-drag
+ParticleSettings.draw_as -> draw_as:    enum    How particles are drawn in viewport
+ParticleSettings.draw_size -> draw_size:    int    Size of particles on viewport in pixels (0=default)
+ParticleSettings.draw_step -> draw_step:    int    How many steps paths are drawn with (power of 2)
+ParticleSettings.dupli_group -> dupli_group:    pointer    Show Objects in this Group in place of particles
+ParticleSettings.dupli_object -> dupli_object:    pointer    Show this Object in place of particles
+ParticleSettings.dupliweights -> dupliweights:    collection, (read-only)    Weights for all of the objects in the dupli group
+ParticleSettings.effect_hair -> effect_hair:    float    Hair stiffness for effectors
+ParticleSettings.effector_weights -> effector_weights:    pointer, (read-only)    
+ParticleSettings.emit_from -> emit_from:    enum    Where to emit particles from
+ParticleSettings.fluid -> fluid:    pointer, (read-only)    
+ParticleSettings.force_field_1 -> force_field_1:    pointer, (read-only)    
+ParticleSettings.force_field_2 -> force_field_2:    pointer, (read-only)    
+ParticleSettings.frame_end -> frame_end:    float    Frame # to stop emitting particles
+ParticleSettings.frame_start -> frame_start:    float    Frame # to start emitting particles
+ParticleSettings.grid_resolution -> grid_resolution:    int    The resolution of the particle grid
+ParticleSettings.hair_step -> hair_step:    int    Number of hair segments
+ParticleSettings.integrator -> integrator:    enum    Select physics integrator type
+ParticleSettings.jitter_factor -> jitter_factor:    float    Amount of jitter applied to the sampling
+ParticleSettings.keyed_loops -> keyed_loops:    int    Number of times the keys are looped
+ParticleSettings.keys_step -> keys_step:    int    
+ParticleSettings.kink -> kink:    enum    Type of periodic offset on the path
+ParticleSettings.kink_amplitude -> kink_amplitude:    float    The amplitude of the offset
+ParticleSettings.kink_axis -> kink_axis:    enum    Which axis to use for offset
+ParticleSettings.kink_frequency -> kink_frequency:    float    The frequency of the offset (1/total length)
+ParticleSettings.kink_shape -> kink_shape:    float    Adjust the offset to the beginning/end
+ParticleSettings.lifetime -> lifetime:    float    Specify the life span of the particles
+ParticleSettings.line_length_head -> line_length_head:    float    Length of the line's head
+ParticleSettings.line_length_tail -> line_length_tail:    float    Length of the line's tail
+ParticleSettings.mass -> mass:    float    Specify the mass of the particles
+ParticleSettings.material -> material:    int    Specify material used for the particles
+ParticleSettings.normal_factor -> normal_factor:    float    Let the surface normal give the particle a starting speed
+ParticleSettings.object_aligned_factor -> object_aligned_factor:    float    Let the emitter object orientation give the particle a starting speed
+ParticleSettings.object_factor -> object_factor:    float    Let the object give the particle a starting speed
+ParticleSettings.particle_factor -> particle_factor:    float    Let the target particle give the particle a starting speed
+ParticleSettings.particle_size -> particle_size:    float    The size of the particles
+ParticleSettings.path_end -> path_end:    float    End time of drawn path
+ParticleSettings.path_start -> path_start:    float    Starting time of drawn path
+ParticleSettings.phase_factor -> phase_factor:    float    Initial rotation phase
+ParticleSettings.physics_type -> physics_type:    enum    Particle physics type
+ParticleSettings.random_factor -> random_factor:    float    Give the starting speed a random variation
+ParticleSettings.random_length -> random_length:    float    Give path length a random variation
+ParticleSettings.random_lifetime -> random_lifetime:    float    Give the particle life a random variation
+ParticleSettings.random_phase_factor -> random_phase_factor:    float    Randomize rotation phase
+ParticleSettings.random_rotation_factor -> random_rotation_factor:    float    Randomize rotation
+ParticleSettings.random_size -> random_size:    float    Give the particle size a random variation
+ParticleSettings.react_event -> react_event:    enum    The event of target particles to react on
+ParticleSettings.reaction_shape -> reaction_shape:    float    Power of reaction strength dependence on distance to target
+ParticleSettings.reactor_factor -> reactor_factor:    float    Let the vector away from the target particles location give the particle a starting speed
+ParticleSettings.ren_as -> ren_as:    enum    How particles are rendered
+ParticleSettings.render_step -> render_step:    int    How many steps paths are rendered with (power of 2)
+ParticleSettings.rendered_child_nbr -> rendered_child_nbr:    int    Amount of children/parent for rendering
+ParticleSettings.rotate_from -> rotate_from:    enum    
+ParticleSettings.rotation_mode -> rotation_mode:    enum    Particles initial rotation
+ParticleSettings.rough1 -> rough1:    float    Amount of location dependent rough
+ParticleSettings.rough1_size -> rough1_size:    float    Size of location dependent rough
+ParticleSettings.rough2 -> rough2:    float    Amount of random rough
+ParticleSettings.rough2_size -> rough2_size:    float    Size of random rough
+ParticleSettings.rough2_thres -> rough2_thres:    float    Amount of particles left untouched by random rough
+ParticleSettings.rough_end_shape -> rough_end_shape:    float    Shape of end point rough
+ParticleSettings.rough_endpoint -> rough_endpoint:    float    Amount of end point rough
+ParticleSettings.simplify_rate -> simplify_rate:    float    Speed of simplification
+ParticleSettings.simplify_refsize -> simplify_refsize:    int    Reference size in pixels, after which simplification begins
+ParticleSettings.simplify_transition -> simplify_transition:    float    Transition period for fading out strands
+ParticleSettings.simplify_viewport -> simplify_viewport:    float    Speed of Simplification
+ParticleSettings.subframes -> subframes:    int    Subframes to simulate for improved stability and finer granularity simulations
+ParticleSettings.tangent_factor -> tangent_factor:    float    Let the surface tangent give the particle a starting speed
+ParticleSettings.tangent_phase -> tangent_phase:    float    Rotate the surface tangent
+ParticleSettings.time_tweak -> time_tweak:    float    A multiplier for physics timestep (1.0 means one frame = 1/25 seconds)
+ParticleSettings.trail_count -> trail_count:    int    Number of trail particles
+ParticleSettings.type -> type:    enum    
+ParticleSettings.userjit -> userjit:    int    Emission locations / face (0 = automatic)
+ParticleSettings.virtual_parents -> virtual_parents:    float    Relative amount of virtual parents
+ParticleSystem.active_particle_target -> active_particle_target:    pointer, (read-only)    
+ParticleSystem.active_particle_target_index -> active_particle_target_index:    int    
+ParticleSystem.billboard_normal_uv -> billboard_normal_uv:    string    UV Layer to control billboard normals
+ParticleSystem.billboard_split_uv -> billboard_split_uv:    string    UV Layer to control billboard splitting
+ParticleSystem.billboard_time_index_uv -> billboard_time_index_uv:    string    UV Layer to control billboard time index (X-Y)
+ParticleSystem.child_particles -> child_particles:    collection, (read-only)    Child particles generated by the particle system
+ParticleSystem.cloth -> cloth:    pointer, (read-only)    Cloth dynamics for hair
+ParticleSystem.name -> name:    string    Particle system name
+ParticleSystem.parent -> parent:    pointer    Use this object's coordinate system instead of global coordinate system
+ParticleSystem.particles -> particles:    collection, (read-only)    Particles generated by the particle system
+ParticleSystem.point_cache -> point_cache:    pointer, (read-only)    
+ParticleSystem.reactor_target_object -> reactor_target_object:    pointer    For reactor systems, the object that has the target particle system (empty if same object)
+ParticleSystem.reactor_target_particle_system -> reactor_target_particle_system:    int    For reactor systems, index of particle system on the target object
+ParticleSystem.seed -> seed:    int    Offset in the random number table, to get a different randomized result
+ParticleSystem.settings -> settings:    pointer    Particle system settings
+ParticleSystem.targets -> targets:    collection, (read-only)    Target particle systems
+ParticleSystem.vertex_group_clump -> vertex_group_clump:    string    Vertex group to control clump
+ParticleSystem.vertex_group_density -> vertex_group_density:    string    Vertex group to control density
+ParticleSystem.vertex_group_field -> vertex_group_field:    string    Vertex group to control field
+ParticleSystem.vertex_group_kink -> vertex_group_kink:    string    Vertex group to control kink
+ParticleSystem.vertex_group_length -> vertex_group_length:    string    Vertex group to control length
+ParticleSystem.vertex_group_rotation -> vertex_group_rotation:    string    Vertex group to control rotation
+ParticleSystem.vertex_group_roughness1 -> vertex_group_roughness1:    string    Vertex group to control roughness 1
+ParticleSystem.vertex_group_roughness2 -> vertex_group_roughness2:    string    Vertex group to control roughness 2
+ParticleSystem.vertex_group_roughness_end -> vertex_group_roughness_end:    string    Vertex group to control roughness end
+ParticleSystem.vertex_group_size -> vertex_group_size:    string    Vertex group to control size
+ParticleSystem.vertex_group_tangent -> vertex_group_tangent:    string    Vertex group to control tangent
+ParticleSystem.vertex_group_velocity -> vertex_group_velocity:    string    Vertex group to control velocity
+ParticleSystemModifier.particle_system -> particle_system:    pointer, (read-only)    Particle System that this modifier controls
+ParticleTarget.duration -> duration:    float    
+ParticleTarget.mode -> mode:    enum    
+ParticleTarget.name -> name:    string, (read-only)    Particle target name
+ParticleTarget.object -> object:    pointer    The object that has the target particle system (empty if same object)
+ParticleTarget.system -> system:    int    The index of particle system on the target object
+ParticleTarget.time -> time:    float    
+PivotConstraint.enabled_rotation_range -> enabled_rotation_range:    enum    Rotation range on which pivoting should occur
+PivotConstraint.head_tail -> head_tail:    float    Target along length of bone: Head=0, Tail=1
+PivotConstraint.offset -> offset:    float    Offset of pivot from target (when set), or from owner's location (when Fixed Position is off), or the absolute pivot point
+PivotConstraint.subtarget -> subtarget:    string    
+PivotConstraint.target -> target:    pointer    Target Object, defining the position of the pivot when defined
+PluginSequence.filename -> filename:    string, (read-only)    
+PointCache.active_point_cache_index -> active_point_cache_index:    int    
+PointCache.filepath -> filepath:    string    Cache file path
+PointCache.frame_end -> frame_end:    int    Frame on which the simulation stops
+PointCache.frame_start -> frame_start:    int    Frame on which the simulation starts
+PointCache.index -> index:    int    Index number of cache files
+PointCache.info -> info:    string, (read-only)    Info on current cache status
+PointCache.name -> name:    string    Cache name
+PointCache.point_cache_list -> point_cache_list:    collection, (read-only)    Point cache list
+PointCache.step -> step:    int    Number of frames between cached frames
+PointDensity.color_ramp -> color_ramp:    pointer, (read-only)    
+PointDensity.color_source -> color_source:    enum    Data to derive color results from
+PointDensity.falloff -> falloff:    enum    Method of attenuating density by distance from the point
+PointDensity.falloff_softness -> falloff_softness:    float    Softness of the 'soft' falloff option
+PointDensity.noise_basis -> noise_basis:    enum    Noise formula used for turbulence
+PointDensity.object -> object:    pointer    Object to take point data from
+PointDensity.particle_cache -> particle_cache:    enum    Co-ordinate system to cache particles in
+PointDensity.particle_system -> particle_system:    pointer    Particle System to render as points
+PointDensity.point_source -> point_source:    enum    Point data to use as renderable point density
+PointDensity.radius -> radius:    float    Radius from the shaded sample to look for points within
+PointDensity.speed_scale -> speed_scale:    float    Multiplier to bring particle speed within an acceptable range
+PointDensity.turbulence_depth -> turbulence_depth:    int    Level of detail in the added turbulent noise
+PointDensity.turbulence_influence -> turbulence_influence:    enum    Method for driving added turbulent noise
+PointDensity.turbulence_size -> turbulence_size:    float    Scale of the added turbulent noise
+PointDensity.turbulence_strength -> turbulence_strength:    float    
+PointDensity.vertices_cache -> vertices_cache:    enum    Co-ordinate system to cache vertices in
+PointDensityTexture.pointdensity -> pointdensity:    pointer, (read-only)    The point density settings associated with this texture
+PointLamp.falloff_curve -> falloff_curve:    pointer, (read-only)    Custom Lamp Falloff Curve
+PointLamp.falloff_type -> falloff_type:    enum    Intensity Decay with distance
+PointLamp.linear_attenuation -> linear_attenuation:    float    Linear distance attenuation
+PointLamp.quadratic_attenuation -> quadratic_attenuation:    float    Quadratic distance attenuation
+PointLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:    float    Threshold for Adaptive Sampling (Raytraced shadows)
+PointLamp.shadow_color -> shadow_color:    float    Color of shadows cast by the lamp
+PointLamp.shadow_method -> shadow_method:    enum    Method to compute lamp shadow with
+PointLamp.shadow_ray_samples -> shadow_ray_samples:    int    Amount of samples taken extra (samples x samples)
+PointLamp.shadow_ray_sampling_method -> shadow_ray_sampling_method:    enum    Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower
+PointLamp.shadow_soft_size -> shadow_soft_size:    float    Light size for ray shadow sampling (Raytraced shadows)
+PointerProperty.fixed_type -> fixed_type:    pointer, (read-only)    Fixed pointer type, empty if variable type
+Pose.active_bone_group -> active_bone_group:    pointer    Active bone group for this pose
+Pose.active_bone_group_index -> active_bone_group_index:    int    Active index in bone groups array
+Pose.animation_visualisation -> animation_visualisation:    pointer, (read-only)    Animation data for this datablock
+Pose.bone_groups -> bone_groups:    collection, (read-only)    Groups of the bones
+Pose.bones -> bones:    collection, (read-only)    Individual pose bones for the armature
+Pose.ik_param -> ik_param:    pointer, (read-only)    Parameters for IK solver
+Pose.ik_solver -> ik_solver:    enum    Selection of IK solver for IK chain, current choice is 0 for Legacy, 1 for iTaSC
+PoseBone.bone -> bone:    pointer, (read-only)    Bone associated with this PoseBone
+PoseBone.bone_group -> bone_group:    pointer    Bone Group this pose channel belongs to
+PoseBone.bone_group_index -> bone_group_index:    int    Bone Group this pose channel belongs to (0=no group)
+PoseBone.child -> child:    pointer, (read-only)    Child of this pose bone
+PoseBone.constraints -> constraints:    collection, (read-only)    Constraints that act on this PoseChannel
+PoseBone.custom_shape -> custom_shape:    pointer    Object that defines custom draw type for this bone
+PoseBone.custom_shape_transform -> custom_shape_transform:    pointer    Bone that defines the display transform of this custom shape
+PoseBone.head -> head:    float, (read-only)    Location of head of the channel's bone
+PoseBone.ik_lin_weight -> ik_lin_weight:    float    Weight of scale constraint for IK
+PoseBone.ik_max_x -> ik_max_x:    float    Maximum angles for IK Limit
+PoseBone.ik_max_y -> ik_max_y:    float    Maximum angles for IK Limit
+PoseBone.ik_max_z -> ik_max_z:    float    Maximum angles for IK Limit
+PoseBone.ik_min_x -> ik_min_x:    float    Minimum angles for IK Limit
+PoseBone.ik_min_y -> ik_min_y:    float    Minimum angles for IK Limit
+PoseBone.ik_min_z -> ik_min_z:    float    Minimum angles for IK Limit
+PoseBone.ik_rot_weight -> ik_rot_weight:    float    Weight of rotation constraint for IK
+PoseBone.ik_stiffness_x -> ik_stiffness_x:    float    IK stiffness around the X axis
+PoseBone.ik_stiffness_y -> ik_stiffness_y:    float    IK stiffness around the Y axis
+PoseBone.ik_stiffness_z -> ik_stiffness_z:    float    IK stiffness around the Z axis
+PoseBone.ik_stretch -> ik_stretch:    float    Allow scaling of the bone for IK
+PoseBone.location -> location:    float    
+PoseBone.matrix -> matrix:    float, (read-only)    Final 4x4 matrix for this channel
+PoseBone.matrix_channel -> matrix_channel:    float, (read-only)    4x4 matrix, before constraints
+PoseBone.matrix_local -> matrix_local:    float    Matrix representing the parent relative location, scale and rotation. Provides an alternative access to these properties.
+PoseBone.motion_path -> motion_path:    pointer, (read-only)    Motion Path for this element
+PoseBone.name -> name:    string    
+PoseBone.parent -> parent:    pointer, (read-only)    Parent of this pose bone
+PoseBone.rotation_axis_angle -> rotation_axis_angle:    float    Angle of Rotation for Axis-Angle rotation representation
+PoseBone.rotation_euler -> rotation_euler:    float    Rotation in Eulers
+PoseBone.rotation_mode -> rotation_mode:    enum    
+PoseBone.rotation_quaternion -> rotation_quaternion:    float    Rotation in Quaternions
+PoseBone.scale -> scale:    float    
+PoseBone.tail -> tail:    float, (read-only)    Location of tail of the channel's bone
+PoseBoneConstraints.active -> active:    pointer    Active PoseChannel constraint
+PoseTemplate.name -> name:    string    
+PoseTemplateSettings.active_template_index -> active_template_index:    int    
+PoseTemplateSettings.templates -> templates:    collection, (read-only)    
+Property.description -> description:    string, (read-only)    Description of the property for tooltips
+Property.identifier -> identifier:    string, (read-only)    Unique name used in the code and scripting
+Property.name -> name:    string, (read-only)    Human readable name
+Property.srna -> srna:    pointer, (read-only)    Struct definition used for properties assigned to this item
+Property.subtype -> subtype:    enum, (read-only)    Semantic interpretation of the property
+Property.type -> type:    enum, (read-only)    Data type of the property
+Property.unit -> unit:    enum, (read-only)    Type of units for this property
+PropertyActuator.mode -> mode:    enum    
+PropertyActuator.object -> object:    pointer    Copy from this Object
+PropertyActuator.object_property -> object_property:    string    Copy this property
+PropertyActuator.property -> property:    string    The name of the property
+PropertyActuator.value -> value:    string    The value to use, use "" around strings
+PropertySensor.evaluation_type -> evaluation_type:    enum    Type of property evaluation
+PropertySensor.max_value -> max_value:    string    Specify maximum value in Interval type
+PropertySensor.min_value -> min_value:    string    Specify minimum value in Interval type
+PropertySensor.property -> property:    string    
+PropertySensor.value -> value:    string    Check for this value in types in Equal or Not Equal types
+PythonConstraint.number_of_targets -> number_of_targets:    int    Usually only 1-3 are needed
+PythonConstraint.targets -> targets:    collection, (read-only)    Target Objects
+PythonConstraint.text -> text:    pointer    The text object that contains the Python script
+PythonController.mode -> mode:    enum    Python script type (textblock or module - faster)
+PythonController.module -> module:    string    Module name and function to run e.g. "someModule.main". Internal texts and external python files can be used
+PythonController.text -> text:    pointer    Text datablock with the python script
+RGBANodeSocket.default_value -> default_value:    float    Default value of the socket when no link is attached
+RGBANodeSocket.name -> name:    string, (read-only)    Socket name
+RadarSensor.angle -> angle:    float    Opening angle of the radar cone
+RadarSensor.axis -> axis:    enum    Specify along which axis the radar cone is cast
+RadarSensor.distance -> distance:    float    Depth of the radar cone
+RadarSensor.property -> property:    string    Only look for Objects with this property
+RandomActuator.chance -> chance:    float    Pick a number between 0 and 1. Success if you stay below this value
+RandomActuator.distribution -> distribution:    enum    Choose the type of distribution
+RandomActuator.float_max -> float_max:    float    Choose a number from a range. Upper boundary of the range
+RandomActuator.float_mean -> float_mean:    float    A normal distribution. Mean of the distribution
+RandomActuator.float_min -> float_min:    float    Choose a number from a range. Lower boundary of the range
+RandomActuator.float_value -> float_value:    float    Always return this number
+RandomActuator.half_life_time -> half_life_time:    float    Negative exponential dropoff
+RandomActuator.int_max -> int_max:    int    Choose a number from a range. Upper boundary of the range
+RandomActuator.int_mean -> int_mean:    float    Expected mean value of the distribution
+RandomActuator.int_min -> int_min:    int    Choose a number from a range. Lower boundary of the range
+RandomActuator.int_value -> int_value:    int    Always return this number
+RandomActuator.property -> property:    string    Assign the random value to this property
+RandomActuator.seed -> seed:    int    Initial seed of the random generator. Use Python for more freedom (choose 0 for not random)
+RandomActuator.standard_derivation -> standard_derivation:    float    A normal distribution. Standard deviation of the distribution
+RandomSensor.seed -> seed:    int    Initial seed of the generator. (Choose 0 for not random)
+RaySensor.axis -> axis:    enum    Specify along which axis the ray is cast
+RaySensor.material -> material:    string    Only look for Objects with this material
+RaySensor.property -> property:    string    Only look for Objects with this property
+RaySensor.range -> range:    float    Sense objects no farther than this distance
+RaySensor.ray_type -> ray_type:    enum    Toggle collision on material or property
+Region.height -> height:    int, (read-only)    Region height
+Region.id -> id:    int, (read-only)    Unique ID for this region
+Region.type -> type:    enum, (read-only)    Type of this region
+Region.width -> width:    int, (read-only)    Region width
+RegionView3D.perspective_matrix -> perspective_matrix:    float, (read-only)    Current perspective matrix of the 3D region
+RegionView3D.view_distance -> view_distance:    float    Distance to the view location
+RegionView3D.view_location -> view_location:    float    View pivot location
+RegionView3D.view_matrix -> view_matrix:    float, (read-only)    Current view matrix of the 3D region
+RegionView3D.view_perspective -> view_perspective:    enum    View Perspective
+RegionView3D.view_rotation -> view_rotation:    float    Rotation in quaternions (keep normalized)
+RenderEngine.bl_idname -> bl_idname:    string    
+RenderEngine.bl_label -> bl_label:    string    
+RenderLayer.light_override -> light_override:    pointer, (read-only)    Group to override all other lights in this render layer
+RenderLayer.material_override -> material_override:    pointer, (read-only)    Material to override all other materials in this render layer
+RenderLayer.name -> name:    string, (read-only)    Render layer name
+RenderLayer.passes -> passes:    collection, (read-only)    
+RenderLayer.rect -> rect:    float    
+RenderPass.channel_id -> channel_id:    string, (read-only)    
+RenderPass.channels -> channels:    int, (read-only)    
+RenderPass.name -> name:    string, (read-only)    
+RenderPass.rect -> rect:    float    
+RenderPass.type -> type:    enum, (read-only)    
+RenderResult.layers -> layers:    collection, (read-only)    
+RenderResult.resolution_x -> resolution_x:    int, (read-only)    
+RenderResult.resolution_y -> resolution_y:    int, (read-only)    
+RenderSettings.active_layer_index -> active_layer_index:    int    Active index in render layer array
+RenderSettings.alpha_mode -> alpha_mode:    enum    Representation of alpha information in the RGBA pixels
+RenderSettings.antialiasing_samples -> antialiasing_samples:    enum    Amount of anti-aliasing samples per pixel
+RenderSettings.bake_aa_mode -> bake_aa_mode:    enum    
+RenderSettings.bake_bias -> bake_bias:    float    Bias towards faces further away from the object (in blender units)
+RenderSettings.bake_distance -> bake_distance:    float    Maximum distance from active object to other object (in blender units
+RenderSettings.bake_margin -> bake_margin:    int    Amount of pixels to extend the baked result with, as post process filter
+RenderSettings.bake_normal_space -> bake_normal_space:    enum    Choose normal space for baking
+RenderSettings.bake_quad_split -> bake_quad_split:    enum    Choose the method used to split a quad into 2 triangles for baking
+RenderSettings.bake_type -> bake_type:    enum    Choose shading information to bake into the image
+RenderSettings.border_max_x -> border_max_x:    float    Sets maximum X value for the render border
+RenderSettings.border_max_y -> border_max_y:    float    Sets maximum Y value for the render border
+RenderSettings.border_min_x -> border_min_x:    float    Sets minimum X value to for the render border
+RenderSettings.border_min_y -> border_min_y:    float    Sets minimum Y value for the render border
+RenderSettings.cineon_black -> cineon_black:    int    Log conversion reference blackpoint
+RenderSettings.cineon_gamma -> cineon_gamma:    float    Log conversion gamma
+RenderSettings.cineon_white -> cineon_white:    int    Log conversion reference whitepoint
+RenderSettings.color_mode -> color_mode:    enum    Choose BW for saving greyscale images, RGB for saving red, green and blue channels, AND RGBA for saving red, green, blue + alpha channels
+RenderSettings.display_mode -> display_mode:    enum    Select where rendered images will be displayed
+RenderSettings.dither_intensity -> dither_intensity:    float    Amount of dithering noise added to the rendered image to break up banding
+RenderSettings.edge_color -> edge_color:    float    
+RenderSettings.edge_threshold -> edge_threshold:    int    Threshold for drawing outlines on geometry edges
+RenderSettings.engine -> engine:    enum    Engine to use for rendering
+RenderSettings.field_order -> field_order:    enum    Order of video fields. Select which lines get rendered first, to create smooth motion for TV output
+RenderSettings.file_extension -> file_extension:    string, (read-only)    The file extension used for saving renders
+RenderSettings.file_format -> file_format:    enum    File format to save the rendered images as
+RenderSettings.file_quality -> file_quality:    int    Quality of JPEG images, AVI Jpeg and SGI movies
+RenderSettings.filter_size -> filter_size:    float    Pixel width over which the reconstruction filter combines samples
+RenderSettings.fps -> fps:    int    Framerate, expressed in frames per second
+RenderSettings.fps_base -> fps_base:    float    Framerate base
+RenderSettings.layers -> layers:    collection, (read-only)    
+RenderSettings.motion_blur_samples -> motion_blur_samples:    int    Number of scene samples to take with motion blur
+RenderSettings.motion_blur_shutter -> motion_blur_shutter:    float    Time taken in frames between shutter open and close
+RenderSettings.octree_resolution -> octree_resolution:    enum    Resolution of raytrace accelerator. Use higher resolutions for larger scenes
+RenderSettings.output_path -> output_path:    string    Directory/name to save animations, # characters defines the position and length of frame numbers
+RenderSettings.parts_x -> parts_x:    int    Number of horizontal tiles to use while rendering
+RenderSettings.parts_y -> parts_y:    int    Number of vertical tiles to use while rendering
+RenderSettings.pixel_aspect_x -> pixel_aspect_x:    float    Horizontal aspect ratio - for anamorphic or non-square pixel output
+RenderSettings.pixel_aspect_y -> pixel_aspect_y:    float    Vertical aspect ratio - for anamorphic or non-square pixel output
+RenderSettings.pixel_filter -> pixel_filter:    enum    Reconstruction filter used for combining anti-aliasing samples
+RenderSettings.raytrace_structure -> raytrace_structure:    enum    Type of raytrace accelerator structure
+RenderSettings.resolution_percentage -> resolution_percentage:    int    Percentage scale for render resolution
+RenderSettings.resolution_x -> resolution_x:    int    Number of horizontal pixels in the rendered image
+RenderSettings.resolution_y -> resolution_y:    int    Number of vertical pixels in the rendered image
+RenderSettings.sequencer_gl_preview -> sequencer_gl_preview:    enum    Method to draw in the sequencer view
+RenderSettings.sequencer_gl_render -> sequencer_gl_render:    enum    Method to draw in the sequencer view
+RenderSettings.simplify_ao_sss -> simplify_ao_sss:    float    Global approximate AA and SSS quality factor
+RenderSettings.simplify_child_particles -> simplify_child_particles:    float    Global child particles percentage
+RenderSettings.simplify_shadow_samples -> simplify_shadow_samples:    int    Global maximum shadow samples
+RenderSettings.simplify_subdivision -> simplify_subdivision:    int    Global maximum subdivision level
+RenderSettings.stamp_background -> stamp_background:    float    Color to use behind stamp text
+RenderSettings.stamp_font_size -> stamp_font_size:    int    Size of the font used when rendering stamp text
+RenderSettings.stamp_foreground -> stamp_foreground:    float    Color to use for stamp text
+RenderSettings.stamp_note_text -> stamp_note_text:    string    Custom text to appear in the stamp note
+RenderSettings.threads -> threads:    int    Number of CPU threads to use simultaneously while rendering (for multi-core/CPU systems)
+RenderSettings.threads_mode -> threads_mode:    enum    Determine the amount of render threads used
+RigidBodyJointConstraint.axis_x -> axis_x:    float    Rotate pivot on X axis in degrees
+RigidBodyJointConstraint.axis_y -> axis_y:    float    Rotate pivot on Y axis in degrees
+RigidBodyJointConstraint.axis_z -> axis_z:    float    Rotate pivot on Z axis in degrees
+RigidBodyJointConstraint.child -> child:    pointer    Child object
+RigidBodyJointConstraint.pivot_type -> pivot_type:    enum    
+RigidBodyJointConstraint.pivot_x -> pivot_x:    float    Offset pivot on X
+RigidBodyJointConstraint.pivot_y -> pivot_y:    float    Offset pivot on Y
+RigidBodyJointConstraint.pivot_z -> pivot_z:    float    Offset pivot on Z
+RigidBodyJointConstraint.target -> target:    pointer    Target Object
+SPHFluidSettings.buoyancy -> buoyancy:    float    
+SPHFluidSettings.fluid_radius -> fluid_radius:    float    Fluid interaction Radius
+SPHFluidSettings.rest_density -> rest_density:    float    Density
+SPHFluidSettings.rest_length -> rest_length:    float    The Spring Rest Length (factor of interaction radius)
+SPHFluidSettings.spring_k -> spring_k:    float    Spring force constant
+SPHFluidSettings.stiffness_k -> stiffness_k:    float    Constant K - Stiffness
+SPHFluidSettings.stiffness_knear -> stiffness_knear:    float    Repulsion factor: stiffness_knear
+SPHFluidSettings.viscosity_beta -> viscosity_beta:    float    Square viscosity factor
+SPHFluidSettings.viscosity_omega -> viscosity_omega:    float    Linear viscosity
+Scene.active_keying_set -> active_keying_set:    pointer    Active Keying Set used to insert/delete keyframes
+Scene.active_keying_set_index -> active_keying_set_index:    int    Current Keying Set index (negative for 'builtin' and positive for 'absolute')
+Scene.all_keying_sets -> all_keying_sets:    collection, (read-only)    All Keying Sets available for use (builtins and Absolute Keying Sets for this Scene)
+Scene.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+Scene.bases -> bases:    collection, (read-only)    
+Scene.camera -> camera:    pointer    Active camera used for rendering the scene
+Scene.cursor_location -> cursor_location:    float    3D cursor location
+Scene.distance_model -> distance_model:    enum    Distance model for distance attenuation calculation
+Scene.doppler_factor -> doppler_factor:    float    Pitch factor for Doppler effect calculation
+Scene.frame_current -> frame_current:    int    
+Scene.frame_end -> frame_end:    int    Final frame of the playback/rendering range
+Scene.frame_start -> frame_start:    int    First frame of the playback/rendering range
+Scene.frame_step -> frame_step:    int    Number of frames to skip forward while rendering/playing back each frame
+Scene.game_data -> game_data:    pointer, (read-only)    
+Scene.gravity -> gravity:    float    Constant acceleration in a given direction
+Scene.grease_pencil -> grease_pencil:    pointer    Grease Pencil datablock
+Scene.keying_sets -> keying_sets:    collection, (read-only)    Absolute Keying Sets for this Scene
+Scene.network_render -> network_render:    pointer, (read-only)    Network Render Settings
+Scene.nodetree -> nodetree:    pointer, (read-only)    Compositing node tree
+Scene.objects -> objects:    collection, (read-only)    
+Scene.orientations -> orientations:    collection, (read-only)    
+Scene.pose_templates -> pose_templates:    pointer, (read-only)    Pose Template Settings
+Scene.pov_radio_adc_bailout -> pov_radio_adc_bailout:    float    The adc_bailout for radiosity rays. Use adc_bailout = 0.01 / brightest_ambient_object for good results
+Scene.pov_radio_brightness -> pov_radio_brightness:    float    Amount objects are brightened before being returned upwards to the rest of the system
+Scene.pov_radio_count -> pov_radio_count:    int    Number of rays that are sent out whenever a new radiosity value has to be calculated
+Scene.pov_radio_error_bound -> pov_radio_error_bound:    float    One of the two main speed/quality tuning values, lower values are more accurate
+Scene.pov_radio_gray_threshold -> pov_radio_gray_threshold:    float    One of the two main speed/quality tuning values, lower values are more accurate
+Scene.pov_radio_low_error_factor -> pov_radio_low_error_factor:    float    If you calculate just enough samples, but no more, you will get an image which has slightly blotchy lighting
+Scene.pov_radio_minimum_reuse -> pov_radio_minimum_reuse:    float    Fraction of the screen width which sets the minimum radius of reuse for each sample point (At values higher than 2% expect errors)
+Scene.pov_radio_nearest_count -> pov_radio_nearest_count:    int    Number of old ambient values blended together to create a new interpolated value
+Scene.pov_radio_recursion_limit -> pov_radio_recursion_limit:    int    how many recursion levels are used to calculate the diffuse inter-reflection
+Scene.preview_range_frame_end -> preview_range_frame_end:    int    Alternative end frame for UI playback
+Scene.preview_range_frame_start -> preview_range_frame_start:    int    Alternative start frame for UI playback
+Scene.render -> render:    pointer, (read-only)    
+Scene.sequence_editor -> sequence_editor:    pointer, (read-only)    
+Scene.set -> set:    pointer    Background set scene
+Scene.speed_of_sound -> speed_of_sound:    float    Speed of sound for Doppler effect calculation
+Scene.stamp_note -> stamp_note:    string    User define note for the render stamping
+Scene.sync_mode -> sync_mode:    enum    How to sync playback
+Scene.timeline_markers -> timeline_markers:    collection, (read-only)    Markers used in all timelines for the current scene
+Scene.tool_settings -> tool_settings:    pointer, (read-only)    
+Scene.unit_settings -> unit_settings:    pointer, (read-only)    Unit editing settings
+Scene.world -> world:    pointer    World used for rendering the scene
+SceneActuator.camera -> camera:    pointer    Set this Camera. Leave empty to refer to self object
+SceneActuator.mode -> mode:    enum    
+SceneActuator.scene -> scene:    pointer    Set the Scene to be added/removed/paused/resumed
+SceneBases.active -> active:    pointer    Active object base in the scene
+SceneGameData.activity_culling_box_radius -> activity_culling_box_radius:    float    Radius of the activity bubble, in Manhattan length. Objects outside the box are activity-culled
+SceneGameData.depth -> depth:    int    Displays bit depth of full screen display
+SceneGameData.dome_angle -> dome_angle:    int    Field of View of the Dome - it only works in mode Fisheye and Truncated
+SceneGameData.dome_buffer_resolution -> dome_buffer_resolution:    float    Buffer Resolution - decrease it to increase speed
+SceneGameData.dome_mode -> dome_mode:    enum    Dome physical configurations
+SceneGameData.dome_tesselation -> dome_tesselation:    int    Tessellation level - check the generated mesh in wireframe mode
+SceneGameData.dome_text -> dome_text:    pointer    Custom Warp Mesh data file
+SceneGameData.dome_tilt -> dome_tilt:    int    Camera rotation in horizontal axis
+SceneGameData.eye_separation -> eye_separation:    float    Set the distance between the eyes - the camera focal length/30 should be fine
+SceneGameData.fps -> fps:    int    The nominal number of game frames per second. Physics fixed timestep = 1/fps, independently of actual frame rate
+SceneGameData.framing_color -> framing_color:    float    Set colour of the bars
+SceneGameData.framing_type -> framing_type:    enum    Select the type of Framing you want
+SceneGameData.frequency -> frequency:    int    Displays clock frequency of fullscreen display
+SceneGameData.logic_step_max -> logic_step_max:    int    Sets the maximum number of logic frame per game frame if graphics slows down the game, higher value allows better synchronization with physics
+SceneGameData.material_mode -> material_mode:    enum    Material mode to use for rendering
+SceneGameData.occlusion_culling_resolution -> occlusion_culling_resolution:    float    The size of the occlusion buffer in pixel, use higher value for better precision (slower)
+SceneGameData.physics_engine -> physics_engine:    enum    Physics engine used for physics simulation in the game engine
+SceneGameData.physics_gravity -> physics_gravity:    float    Gravitational constant used for physics simulation in the game engine
+SceneGameData.physics_step_max -> physics_step_max:    int    Sets the maximum number of physics step per game frame if graphics slows down the game, higher value allows physics to keep up with realtime
+SceneGameData.physics_step_sub -> physics_step_sub:    int    Sets the number of simulation substep per physic timestep, higher value give better physics precision
+SceneGameData.resolution_x -> resolution_x:    int    Number of horizontal pixels in the screen
+SceneGameData.resolution_y -> resolution_y:    int    Number of vertical pixels in the screen
+SceneGameData.stereo -> stereo:    enum    
+SceneGameData.stereo_mode -> stereo_mode:    enum    Stereographic techniques
+SceneObjects.active -> active:    pointer    Active object for this scene
+SceneRenderLayer.light_override -> light_override:    pointer    Group to override all other lights in this render layer
+SceneRenderLayer.material_override -> material_override:    pointer    Material to override all other materials in this render layer
+SceneRenderLayer.name -> name:    string    Render layer name
+SceneSequence.animation_end_offset -> animation_end_offset:    int    Animation end offset (trim end)
+SceneSequence.animation_start_offset -> animation_start_offset:    int    Animation start offset (trim start)
+SceneSequence.color_balance -> color_balance:    pointer, (read-only)    
+SceneSequence.crop -> crop:    pointer, (read-only)    
+SceneSequence.multiply_colors -> multiply_colors:    float    
+SceneSequence.proxy -> proxy:    pointer, (read-only)    
+SceneSequence.scene -> scene:    pointer    Scene that this sequence uses
+SceneSequence.scene_camera -> scene_camera:    pointer    Override the scenes active camera
+SceneSequence.strobe -> strobe:    float    Only display every nth frame
+SceneSequence.transform -> transform:    pointer, (read-only)    
+Scopes.accuracy -> accuracy:    float    Proportion of original image source pixel lines to sample
+Scopes.histogram -> histogram:    pointer, (read-only)    Histogram for viewing image statistics
+Scopes.vectorscope_alpha -> vectorscope_alpha:    float    Opacity of the points
+Scopes.waveform_alpha -> waveform_alpha:    float    Opacity of the points
+Scopes.waveform_mode -> waveform_mode:    enum    
+Screen.areas -> areas:    collection, (read-only)    Areas the screen is subdivided into
+Screen.scene -> scene:    pointer    Active scene to be edited in the screen
+ScrewModifier.angle -> angle:    float    Angle of revolution
+ScrewModifier.axis -> axis:    enum    Screw axis
+ScrewModifier.iterations -> iterations:    int    Number of times to apply the screw operation
+ScrewModifier.object -> object:    pointer    Object to define the screw axis
+ScrewModifier.render_steps -> render_steps:    int    Number of steps in the revolution
+ScrewModifier.screw_offset -> screw_offset:    float    Offset the revolution along its axis
+ScrewModifier.steps -> steps:    int    Number of steps in the revolution
+Sensor.frequency -> frequency:    int    Delay between repeated pulses(in logic tics, 0=no delay)
+Sensor.name -> name:    string    Sensor name
+Sensor.type -> type:    enum    
+Sequence.blend_mode -> blend_mode:    enum    
+Sequence.blend_opacity -> blend_opacity:    float    
+Sequence.channel -> channel:    int    Y position of the sequence strip
+Sequence.effect_fader -> effect_fader:    float    
+Sequence.frame_final_end -> frame_final_end:    int    End frame displayed in the sequence editor after offsets are applied
+Sequence.frame_final_length -> frame_final_length:    int    The length of the contents of this strip before the handles are applied
+Sequence.frame_final_start -> 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
+Sequence.frame_length -> frame_length:    int, (read-only)    The length of the contents of this strip before the handles are applied
+Sequence.frame_offset_end -> frame_offset_end:    int, (read-only)    
+Sequence.frame_offset_start -> frame_offset_start:    int, (read-only)    
+Sequence.frame_start -> frame_start:    int    
+Sequence.frame_still_end -> frame_still_end:    int, (read-only)    
+Sequence.frame_still_start -> frame_still_start:    int, (read-only)    
+Sequence.name -> name:    string    
+Sequence.speed_fader -> speed_fader:    float    
+Sequence.type -> type:    enum, (read-only)    
+SequenceColorBalance.gain -> gain:    float    Color balance gain (highlights)
+SequenceColorBalance.gamma -> gamma:    float    Color balance gamma (midtones)
+SequenceColorBalance.lift -> lift:    float    Color balance lift (shadows)
+SequenceCrop.bottom -> bottom:    int    
+SequenceCrop.left -> left:    int    
+SequenceCrop.right -> right:    int    
+SequenceCrop.top -> top:    int    
+SequenceEditor.active_strip -> active_strip:    pointer    
+SequenceEditor.meta_stack -> meta_stack:    collection, (read-only)    Meta strip stack, last is currently edited meta strip
+SequenceEditor.overlay_frame -> overlay_frame:    int    Sequencers active strip
+SequenceEditor.sequences -> sequences:    collection, (read-only)    
+SequenceEditor.sequences_all -> sequences_all:    collection, (read-only)    
+SequenceElement.filename -> filename:    string    
+SequenceProxy.directory -> directory:    string    Location to store the proxy files
+SequenceProxy.filepath -> filepath:    string    Location of custom proxy file
+SequenceTransform.offset_x -> offset_x:    int    
+SequenceTransform.offset_y -> offset_y:    int    
+ShaderNode.type -> type:    enum, (read-only)    
+ShaderNodeExtendedMaterial.material -> material:    pointer    
+ShaderNodeGeometry.color_layer -> color_layer:    string    
+ShaderNodeGeometry.uv_layer -> uv_layer:    string    
+ShaderNodeMapping.location -> location:    float    Location offset for the input coordinate
+ShaderNodeMapping.maximum -> maximum:    float    Maximum value to clamp coordinate to
+ShaderNodeMapping.minimum -> minimum:    float    Minimum value to clamp coordinate to
+ShaderNodeMapping.rotation -> rotation:    float    Rotation offset for the input coordinate
+ShaderNodeMapping.scale -> scale:    float    Scale adjustment for the input coordinate
+ShaderNodeMaterial.material -> material:    pointer    
+ShaderNodeMath.operation -> operation:    enum    
+ShaderNodeMixRGB.blend_type -> blend_type:    enum    
+ShaderNodeRGBCurve.mapping -> mapping:    pointer, (read-only)    
+ShaderNodeTexture.node_output -> node_output:    int    For node-based textures, which output node to use
+ShaderNodeTexture.texture -> texture:    pointer    
+ShaderNodeValToRGB.color_ramp -> color_ramp:    pointer, (read-only)    
+ShaderNodeVectorCurve.mapping -> mapping:    pointer, (read-only)    
+ShaderNodeVectorMath.operation -> operation:    enum    
+ShapeActionActuator.action -> action:    pointer    
+ShapeActionActuator.blendin -> blendin:    int    Number of frames of motion blending
+ShapeActionActuator.frame_end -> frame_end:    int    
+ShapeActionActuator.frame_property -> frame_property:    string    Assign the action's current frame number to this property
+ShapeActionActuator.frame_start -> frame_start:    int    
+ShapeActionActuator.mode -> mode:    enum    Action playback type
+ShapeActionActuator.priority -> priority:    int    Execution priority - lower numbers will override actions with higher numbers. With 2 or more actions at once, the overriding channels must be lower in the stack
+ShapeActionActuator.property -> property:    string    Use this property to define the Action position
+ShapeKey.data -> data:    collection, (read-only)    
+ShapeKey.frame -> frame:    float, (read-only)    Frame for absolute keys
+ShapeKey.interpolation -> interpolation:    enum    Interpolation type
+ShapeKey.name -> name:    string    
+ShapeKey.relative_key -> relative_key:    pointer    Shape used as a relative key
+ShapeKey.slider_max -> slider_max:    float    Maximum for slider
+ShapeKey.slider_min -> slider_min:    float    Minimum for slider
+ShapeKey.value -> value:    float    Value of shape key at the current frame
+ShapeKey.vertex_group -> vertex_group:    string    Vertex weight group, to blend with basis shape
+ShapeKeyBezierPoint.co -> co:    float    
+ShapeKeyBezierPoint.handle_1_co -> handle_1_co:    float    
+ShapeKeyBezierPoint.handle_2_co -> handle_2_co:    float    
+ShapeKeyCurvePoint.co -> co:    float    
+ShapeKeyCurvePoint.tilt -> tilt:    float    
+ShapeKeyPoint.co -> co:    float    
+ShrinkwrapConstraint.distance -> distance:    float    Distance to Target
+ShrinkwrapConstraint.shrinkwrap_type -> shrinkwrap_type:    enum    Selects type of shrinkwrap algorithm for target position
+ShrinkwrapConstraint.target -> target:    pointer    Target Object
+ShrinkwrapModifier.auxiliary_target -> auxiliary_target:    pointer    Additional mesh target to shrink to
+ShrinkwrapModifier.mode -> mode:    enum    
+ShrinkwrapModifier.offset -> offset:    float    Distance to keep from the target
+ShrinkwrapModifier.subsurf_levels -> subsurf_levels:    int    Number of subdivisions that must be performed before extracting vertices' positions and normals
+ShrinkwrapModifier.target -> target:    pointer    Mesh target to shrink to
+ShrinkwrapModifier.vertex_group -> vertex_group:    string    Vertex group name
+SimpleDeformModifier.factor -> factor:    float    
+SimpleDeformModifier.limits -> limits:    float    Lower/Upper limits for deform
+SimpleDeformModifier.mode -> mode:    enum    
+SimpleDeformModifier.origin -> origin:    pointer    Origin of modifier space coordinates
+SimpleDeformModifier.vertex_group -> vertex_group:    string    Vertex group name
+SmokeDomainSettings.alpha -> alpha:    float    Higher value results in sinking smoke
+SmokeDomainSettings.amplify -> amplify:    int    Enhance the resolution of smoke by this factor using noise
+SmokeDomainSettings.beta -> beta:    float    Higher value results in faster rising smoke
+SmokeDomainSettings.coll_group -> coll_group:    pointer    Limit collisions to this group
+SmokeDomainSettings.dissolve_speed -> dissolve_speed:    int    Dissolve Speed
+SmokeDomainSettings.eff_group -> eff_group:    pointer    Limit effectors to this group
+SmokeDomainSettings.effector_weights -> effector_weights:    pointer, (read-only)    
+SmokeDomainSettings.fluid_group -> fluid_group:    pointer    Limit fluid objects to this group
+SmokeDomainSettings.maxres -> maxres:    int    Maximal resolution used in the fluid domain
+SmokeDomainSettings.noise_type -> noise_type:    enum    Noise method which is used for creating the high resolution
+SmokeDomainSettings.point_cache_high -> point_cache_high:    pointer, (read-only)    
+SmokeDomainSettings.point_cache_low -> point_cache_low:    pointer, (read-only)    
+SmokeDomainSettings.smoke_cache_comp -> smoke_cache_comp:    enum    Compression method to be used
+SmokeDomainSettings.smoke_cache_high_comp -> smoke_cache_high_comp:    enum    Compression method to be used
+SmokeDomainSettings.strength -> strength:    float    Strength of wavelet noise
+SmokeFlowSettings.density -> density:    float    
+SmokeFlowSettings.psys -> psys:    pointer    Particle systems emitted from the object
+SmokeFlowSettings.temperature -> temperature:    float    Temperature difference to ambient temperature
+SmokeModifier.coll_settings -> coll_settings:    pointer, (read-only)    
+SmokeModifier.domain_settings -> domain_settings:    pointer, (read-only)    
+SmokeModifier.flow_settings -> flow_settings:    pointer, (read-only)    
+SmokeModifier.smoke_type -> smoke_type:    enum    
+SmoothModifier.factor -> factor:    float    
+SmoothModifier.repeat -> repeat:    int    
+SmoothModifier.vertex_group -> vertex_group:    string    Vertex group name
+SoftBodyModifier.point_cache -> point_cache:    pointer, (read-only)    
+SoftBodyModifier.settings -> settings:    pointer, (read-only)    
+SoftBodySettings.aero -> aero:    float    Make edges 'sail'
+SoftBodySettings.aerodynamics_type -> aerodynamics_type:    enum    Method of calculating aerodynamic interaction
+SoftBodySettings.ball_damp -> ball_damp:    float    Blending to inelastic collision
+SoftBodySettings.ball_size -> ball_size:    float    Absolute ball size or factor if not manual adjusted
+SoftBodySettings.ball_stiff -> ball_stiff:    float    Ball inflating pressure
+SoftBodySettings.bending -> bending:    float    Bending Stiffness
+SoftBodySettings.choke -> choke:    int    'Viscosity' inside collision target
+SoftBodySettings.collision_type -> collision_type:    enum    Choose Collision Type
+SoftBodySettings.damp -> damp:    float    Edge spring friction
+SoftBodySettings.effector_weights -> effector_weights:    pointer, (read-only)    
+SoftBodySettings.error_limit -> error_limit:    float    The Runge-Kutta ODE solver error limit, low value gives more precision, high values speed
+SoftBodySettings.friction -> friction:    float    General media friction for point movements
+SoftBodySettings.fuzzy -> fuzzy:    int    Fuzziness while on collision, high values make collsion handling faster but less stable
+SoftBodySettings.goal_default -> goal_default:    float    Default Goal (vertex target position) value, when no Vertex Group used
+SoftBodySettings.goal_friction -> goal_friction:    float    Goal (vertex target position) friction
+SoftBodySettings.goal_max -> goal_max:    float    Goal maximum, vertex weights are scaled to match this range
+SoftBodySettings.goal_min -> goal_min:    float    Goal minimum, vertex weights are scaled to match this range
+SoftBodySettings.goal_spring -> goal_spring:    float    Goal (vertex target position) spring stiffness
+SoftBodySettings.goal_vertex_group -> goal_vertex_group:    string    Control point weight values
+SoftBodySettings.gravity -> gravity:    float    Apply gravitation to point movement
+SoftBodySettings.lcom -> lcom:    float    Location of Center of mass
+SoftBodySettings.lrot -> lrot:    float    Estimated rotation matrix
+SoftBodySettings.lscale -> lscale:    float    Estimated scale matrix
+SoftBodySettings.mass -> mass:    float    General Mass value
+SoftBodySettings.mass_vertex_group -> mass_vertex_group:    string    Control point mass values
+SoftBodySettings.maxstep -> maxstep:    int    Maximal # solver steps/frame
+SoftBodySettings.minstep -> minstep:    int    Minimal # solver steps/frame
+SoftBodySettings.plastic -> plastic:    float    Permanent deform
+SoftBodySettings.pull -> pull:    float    Edge spring stiffness when longer than rest length
+SoftBodySettings.push -> push:    float    Edge spring stiffness when shorter than rest length
+SoftBodySettings.shear -> shear:    float    Shear Stiffness
+SoftBodySettings.speed -> speed:    float    Tweak timing for physics to control frequency and speed
+SoftBodySettings.spring_length -> spring_length:    float    Alter spring length to shrink/blow up (unit %) 0 to disable
+SoftBodySettings.spring_vertex_group -> spring_vertex_group:    string    Control point spring strength values
+SolidifyModifier.edge_crease_inner -> edge_crease_inner:    float    Assign a crease to inner edges
+SolidifyModifier.edge_crease_outer -> edge_crease_outer:    float    Assign a crease to outer edges
+SolidifyModifier.edge_crease_rim -> edge_crease_rim:    float    Assign a crease to the edges making up the rim
+SolidifyModifier.offset -> offset:    float    
+SolidifyModifier.thickness -> thickness:    float    Thickness of the shell
+SolidifyModifier.vertex_group -> vertex_group:    string    Vertex group name
+Sound.filepath -> filepath:    string    Sound sample file used by this Sound datablock
+Sound.packed_file -> packed_file:    pointer, (read-only)    
+SoundActuator.cone_inner_angle_3d -> cone_inner_angle_3d:    float    The angle of the inner cone
+SoundActuator.cone_outer_angle_3d -> cone_outer_angle_3d:    float    The angle of the outer cone
+SoundActuator.cone_outer_gain_3d -> cone_outer_gain_3d:    float    The gain outside the outer cone. The gain in the outer cone will be interpolated between this value and the normal gain in the inner cone
+SoundActuator.max_distance_3d -> max_distance_3d:    float    The maximum distance at which you can hear the sound
+SoundActuator.maximum_gain_3d -> maximum_gain_3d:    float    The maximum gain of the sound, no matter how near it is
+SoundActuator.minimum_gain_3d -> minimum_gain_3d:    float    The minimum gain of the sound, no matter how far it is away
+SoundActuator.mode -> mode:    enum    
+SoundActuator.pitch -> pitch:    float    Sets the pitch of the sound
+SoundActuator.reference_distance_3d -> reference_distance_3d:    float    The distance where the sound has a gain of 1.0
+SoundActuator.rolloff_factor_3d -> rolloff_factor_3d:    float    The influence factor on volume depending on distance
+SoundActuator.sound -> sound:    pointer    
+SoundActuator.volume -> volume:    float    Sets the initial volume of the sound
+SoundSequence.animation_end_offset -> animation_end_offset:    int    Animation end offset (trim end)
+SoundSequence.animation_start_offset -> animation_start_offset:    int    Animation start offset (trim start)
+SoundSequence.attenuation -> attenuation:    float    Attenuation in dezibel
+SoundSequence.filepath -> filepath:    string    
+SoundSequence.sound -> sound:    pointer, (read-only)    Sound datablock used by this sequence
+SoundSequence.volume -> volume:    float    Playback volume of the sound
+Space.type -> type:    enum, (read-only)    Space data type
+SpaceConsole.console_type -> console_type:    enum    Console type
+SpaceConsole.font_size -> font_size:    int    Font size to use for displaying the text
+SpaceConsole.history -> history:    collection, (read-only)    Command history
+SpaceConsole.language -> language:    string    Command line prompt language
+SpaceConsole.prompt -> prompt:    string    Command line prompt
+SpaceConsole.scrollback -> scrollback:    collection, (read-only)    Command output
+SpaceConsole.selection_end -> selection_end:    int    
+SpaceConsole.selection_start -> selection_start:    int    
+SpaceDopeSheetEditor.action -> action:    pointer    Action displayed and edited in this space
+SpaceDopeSheetEditor.autosnap -> autosnap:    enum    Automatic time snapping settings for transformations
+SpaceDopeSheetEditor.dopesheet -> dopesheet:    pointer, (read-only)    Settings for filtering animation data
+SpaceDopeSheetEditor.mode -> mode:    enum    Editing context being displayed
+SpaceFileBrowser.params -> params:    pointer, (read-only)    Parameters and Settings for the Filebrowser
+SpaceGraphEditor.autosnap -> autosnap:    enum    Automatic time snapping settings for transformations
+SpaceGraphEditor.cursor_value -> cursor_value:    float    Graph Editor 2D-Value cursor - Y-Value component
+SpaceGraphEditor.dopesheet -> dopesheet:    pointer, (read-only)    Settings for filtering animation data
+SpaceGraphEditor.mode -> mode:    enum    Editing context being displayed
+SpaceGraphEditor.pivot_point -> pivot_point:    enum    Pivot center for rotation/scaling
+SpaceImageEditor.curves -> curves:    pointer, (read-only)    Color curve mapping to use for displaying the image
+SpaceImageEditor.draw_channels -> draw_channels:    enum    Channels of the image to draw
+SpaceImageEditor.grease_pencil -> grease_pencil:    pointer    Grease pencil data for this space
+SpaceImageEditor.image -> image:    pointer    Image displayed and edited in this space
+SpaceImageEditor.image_user -> image_user:    pointer, (read-only)    Parameters defining which layer, pass and frame of the image is displayed
+SpaceImageEditor.sample_histogram -> sample_histogram:    pointer, (read-only)    Sampled colors along line
+SpaceImageEditor.scopes -> scopes:    pointer, (read-only)    Scopes to visualize image statistics.
+SpaceImageEditor.uv_editor -> uv_editor:    pointer, (read-only)    UV editor settings
+SpaceNLA.autosnap -> autosnap:    enum    Automatic time snapping settings for transformations
+SpaceNLA.dopesheet -> dopesheet:    pointer, (read-only)    Settings for filtering animation data
+SpaceNodeEditor.id -> id:    pointer, (read-only)    Datablock whose nodes are being edited
+SpaceNodeEditor.id_from -> id_from:    pointer, (read-only)    Datablock from which the edited datablock is linked
+SpaceNodeEditor.nodetree -> nodetree:    pointer, (read-only)    Node tree being displayed and edited
+SpaceNodeEditor.texture_type -> texture_type:    enum    Type of data to take texture from
+SpaceNodeEditor.tree_type -> tree_type:    enum    Node tree type to display and edit
+SpaceOutliner.display_filter -> display_filter:    string    Live search filtering string
+SpaceOutliner.display_mode -> display_mode:    enum    Type of information to display
+SpaceProperties.align -> align:    enum    Arrangement of the panels
+SpaceProperties.context -> context:    enum    Type of active data to display and edit
+SpaceProperties.pin_id -> pin_id:    pointer    
+SpaceSequenceEditor.display_channel -> display_channel:    int    The channel number shown in the image preview. 0 is the result of all strips combined
+SpaceSequenceEditor.display_mode -> display_mode:    enum    The view mode to use for displaying sequencer output
+SpaceSequenceEditor.draw_overexposed -> draw_overexposed:    int    Show overexposed areas with zebra stripes
+SpaceSequenceEditor.grease_pencil -> grease_pencil:    pointer, (read-only)    Grease pencil data for this space
+SpaceSequenceEditor.offset_x -> offset_x:    float    Offsets image horizontally from the view center
+SpaceSequenceEditor.offset_y -> offset_y:    float    Offsets image horizontally from the view center
+SpaceSequenceEditor.proxy_render_size -> proxy_render_size:    enum    Draw preview using full resolution or different proxy resolutions
+SpaceSequenceEditor.view_type -> view_type:    enum    The type of the Sequencer view (sequencer, preview or both)
+SpaceSequenceEditor.zoom -> zoom:    float    Display zoom level
+SpaceTextEditor.find_text -> find_text:    string    Text to search for with the find tool
+SpaceTextEditor.font_size -> font_size:    int    Font size to use for displaying the text
+SpaceTextEditor.replace_text -> replace_text:    string    Text to replace selected text with using the replace tool
+SpaceTextEditor.tab_width -> tab_width:    int    Number of spaces to display tabs with
+SpaceTextEditor.text -> text:    pointer    Text displayed and edited in this space
+SpaceUVEditor.cursor_location -> cursor_location:    float    2D cursor location for this view
+SpaceUVEditor.draw_stretch_type -> draw_stretch_type:    enum    Type of stretch to draw
+SpaceUVEditor.edge_draw_type -> edge_draw_type:    enum    Draw type for drawing UV edges
+SpaceUVEditor.pivot -> pivot:    enum    Rotation/Scaling Pivot
+SpaceUVEditor.sticky_selection_mode -> sticky_selection_mode:    enum    Automatically select also UVs sharing the same vertex as the ones being selected
+SpaceUserPreferences.filter -> filter:    string    Search term for filtering in the UI
+SpaceView3D.background_images -> background_images:    collection, (read-only)    List of background images
+SpaceView3D.camera -> camera:    pointer    Active camera used in this view (when unlocked from the scene's active camera)
+SpaceView3D.clip_end -> clip_end:    float    3D View far clipping distance
+SpaceView3D.clip_start -> clip_start:    float    3D View near clipping distance
+SpaceView3D.current_orientation -> current_orientation:    pointer, (read-only)    Current Transformation orientation
+SpaceView3D.cursor_location -> cursor_location:    float    3D cursor location for this view (dependent on local view setting)
+SpaceView3D.grid_lines -> grid_lines:    int    The number of grid lines to display in perspective view
+SpaceView3D.grid_spacing -> grid_spacing:    float    The distance between 3D View grid lines
+SpaceView3D.grid_subdivisions -> grid_subdivisions:    int    The number of subdivisions between grid lines
+SpaceView3D.lens -> lens:    float    Lens angle (mm) in perspective view
+SpaceView3D.local_view -> local_view:    pointer, (read-only)    Display an isolated sub-set of objects, apart from the scene visibility
+SpaceView3D.lock_bone -> lock_bone:    string    3D View center is locked to this bone's position
+SpaceView3D.lock_object -> lock_object:    pointer    3D View center is locked to this object's position
+SpaceView3D.pivot_point -> pivot_point:    enum    Pivot center for rotation/scaling
+SpaceView3D.region_3d -> region_3d:    pointer, (read-only)    3D region in this space, in case of quad view the camera region
+SpaceView3D.region_quadview -> region_quadview:    pointer, (read-only)    3D region that defines the quad view settings
+SpaceView3D.transform_orientation -> transform_orientation:    enum    Transformation orientation
+SpaceView3D.viewport_shading -> viewport_shading:    enum    Method to display/shade objects in the 3D View
+SpeedControlSequence.global_speed -> global_speed:    float    
+Spline.bezier_points -> bezier_points:    collection, (read-only)    Collection of points for bezier curves only
+Spline.character_index -> character_index:    int, (read-only)    Location of this character in the text data (only for text curves)
+Spline.material_index -> material_index:    int    
+Spline.order_u -> order_u:    int    Nurbs order in the U direction (For splines and surfaces), Higher values let points influence a greater area
+Spline.order_v -> order_v:    int    Nurbs order in the V direction (For surfaces only), Higher values let points influence a greater area
+Spline.point_count_u -> point_count_u:    int, (read-only)    Total number points for the curve or surface in the U direction
+Spline.point_count_v -> point_count_v:    int, (read-only)    Total number points for the surface on the V direction
+Spline.points -> points:    collection, (read-only)    Collection of points that make up this poly or nurbs spline
+Spline.radius_interpolation -> radius_interpolation:    enum    The type of radius interpolation for Bezier curves
+Spline.resolution_u -> resolution_u:    int    Curve or Surface subdivisions per segment
+Spline.resolution_v -> resolution_v:    int    Surface subdivisions per segment
+Spline.tilt_interpolation -> tilt_interpolation:    enum    The type of tilt interpolation for 3D, Bezier curves
+Spline.type -> type:    enum    The interpolation type for this curve element
+SplineIKConstraint.chain_length -> chain_length:    int    How many bones are included in the chain
+SplineIKConstraint.joint_bindings -> joint_bindings:    float    (EXPERIENCED USERS ONLY) The relative positions of the joints along the chain as percentages
+SplineIKConstraint.target -> target:    pointer    Curve that controls this relationship
+SplineIKConstraint.xz_scaling_mode -> xz_scaling_mode:    enum    Method used for determining the scaling of the X and Z axes of the bones
+SplinePoint.co -> co:    float    Point coordinates
+SplinePoint.radius -> radius:    float, (read-only)    Radius for bevelling
+SplinePoint.tilt -> tilt:    float    Tilt in 3D View
+SplinePoint.weight -> weight:    float    Nurbs weight
+SplinePoint.weight_softbody -> weight_softbody:    float    Softbody goal weight
+SpotLamp.compression_threshold -> compression_threshold:    float    Deep shadow map compression threshold
+SpotLamp.falloff_curve -> falloff_curve:    pointer, (read-only)    Custom Lamp Falloff Curve
+SpotLamp.falloff_type -> falloff_type:    enum    Intensity Decay with distance
+SpotLamp.halo_intensity -> halo_intensity:    float    Brightness of the spotlight's halo cone  (Buffer Shadows)
+SpotLamp.halo_step -> halo_step:    int    Volumetric halo sampling frequency
+SpotLamp.linear_attenuation -> linear_attenuation:    float    Linear distance attenuation
+SpotLamp.quadratic_attenuation -> quadratic_attenuation:    float    Quadratic distance attenuation
+SpotLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:    float    Threshold for Adaptive Sampling (Raytraced shadows)
+SpotLamp.shadow_buffer_bias -> shadow_buffer_bias:    float    Shadow buffer sampling bias
+SpotLamp.shadow_buffer_clip_end -> shadow_buffer_clip_end:    float    Shadow map clip end beyond which objects will not generate shadows
+SpotLamp.shadow_buffer_clip_start -> shadow_buffer_clip_start:    float    Shadow map clip start: objects closer will not generate shadows
+SpotLamp.shadow_buffer_samples -> shadow_buffer_samples:    int    Number of shadow buffer samples
+SpotLamp.shadow_buffer_size -> shadow_buffer_size:    int    Resolution of the shadow buffer, higher values give crisper shadows but use more memory
+SpotLamp.shadow_buffer_soft -> shadow_buffer_soft:    float    Size of shadow buffer sampling area
+SpotLamp.shadow_buffer_type -> shadow_buffer_type:    enum    Type of shadow buffer
+SpotLamp.shadow_color -> shadow_color:    float    Color of shadows cast by the lamp
+SpotLamp.shadow_filter_type -> shadow_filter_type:    enum    Type of shadow filter (Buffer Shadows)
+SpotLamp.shadow_method -> shadow_method:    enum    Method to compute lamp shadow with
+SpotLamp.shadow_ray_samples -> shadow_ray_samples:    int    Amount of samples taken extra (samples x samples)
+SpotLamp.shadow_ray_sampling_method -> shadow_ray_sampling_method:    enum    Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower
+SpotLamp.shadow_sample_buffers -> shadow_sample_buffers:    enum    Number of shadow buffers to render for better AA, this increases memory usage
+SpotLamp.shadow_soft_size -> shadow_soft_size:    float    Light size for ray shadow sampling (Raytraced shadows)
+SpotLamp.spot_blend -> spot_blend:    float    The softness of the spotlight edge
+SpotLamp.spot_size -> spot_size:    float    Angle of the spotlight beam in degrees
+StateActuator.operation -> operation:    enum    Select the bit operation on object state mask
+StretchToConstraint.bulge -> bulge:    float    Factor between volume variation and stretching
+StretchToConstraint.head_tail -> head_tail:    float    Target along length of bone: Head=0, Tail=1
+StretchToConstraint.keep_axis -> keep_axis:    enum    Axis to maintain during stretch
+StretchToConstraint.original_length -> original_length:    float    Length at rest position
+StretchToConstraint.subtarget -> subtarget:    string    
+StretchToConstraint.target -> target:    pointer    Target Object
+StretchToConstraint.volume -> volume:    enum    Maintain the object's volume as it stretches
+StringProperty.default -> default:    string, (read-only)    string default value
+StringProperty.max_length -> max_length:    int, (read-only)    Maximum length of the string, 0 means unlimited
+Struct.base -> base:    pointer, (read-only)    Struct definition this is derived from
+Struct.description -> description:    string, (read-only)    Description of the Struct's purpose
+Struct.functions -> functions:    collection, (read-only)    
+Struct.identifier -> identifier:    string, (read-only)    Unique name used in the code and scripting
+Struct.name -> name:    string, (read-only)    Human readable name
+Struct.name_property -> name_property:    pointer, (read-only)    Property that gives the name of the struct
+Struct.nested -> nested:    pointer, (read-only)    Struct in which this struct is always nested, and to which it logically belongs
+Struct.properties -> properties:    collection, (read-only)    Properties in the struct
+StucciTexture.noise_basis -> noise_basis:    enum    Sets the noise basis used for turbulence
+StucciTexture.noise_size -> noise_size:    float    Sets scaling for noise input
+StucciTexture.noise_type -> noise_type:    enum    
+StucciTexture.stype -> stype:    enum    
+StucciTexture.turbulence -> turbulence:    float    Sets the turbulence of the bandnoise and ringnoise types
+SubsurfModifier.levels -> levels:    int    Number of subdivisions to perform
+SubsurfModifier.render_levels -> render_levels:    int    Number of subdivisions to perform when rendering
+SubsurfModifier.subdivision_type -> subdivision_type:    enum    Selects type of subdivision algorithm
+SunLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:    float    Threshold for Adaptive Sampling (Raytraced shadows)
+SunLamp.shadow_color -> shadow_color:    float    Color of shadows cast by the lamp
+SunLamp.shadow_method -> shadow_method:    enum    Method to compute lamp shadow with
+SunLamp.shadow_ray_samples -> shadow_ray_samples:    int    Amount of samples taken extra (samples x samples)
+SunLamp.shadow_ray_sampling_method -> shadow_ray_sampling_method:    enum    Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower
+SunLamp.shadow_soft_size -> shadow_soft_size:    float    Light size for ray shadow sampling (Raytraced shadows)
+SunLamp.sky -> sky:    pointer, (read-only)    Sky related settings for sun lamps
+TexMapping.location -> location:    float    
+TexMapping.maximum -> maximum:    float    Maximum value for clipping
+TexMapping.minimum -> minimum:    float    Minimum value for clipping
+TexMapping.rotation -> rotation:    float    
+TexMapping.scale -> scale:    float    
+Text.current_character -> current_character:    int, (read-only)    Index of current character in current line, and also start index of character in selection if one exists
+Text.current_line -> current_line:    pointer, (read-only)    Current line, and start line of selection if one exists
+Text.filepath -> filepath:    string    Filename of the text file
+Text.lines -> lines:    collection, (read-only)    Lines of text
+Text.markers -> markers:    collection, (read-only)    Text markers highlighting part of the text
+Text.selection_end_character -> selection_end_character:    int, (read-only)    Index of character after end of selection in the selection end line
+Text.selection_end_line -> selection_end_line:    pointer, (read-only)    End line of selection
+TextBox.height -> height:    float    
+TextBox.width -> width:    float    
+TextBox.x -> x:    float    
+TextBox.y -> y:    float    
+TextCurve.active_textbox -> active_textbox:    int    
+TextCurve.body -> body:    string    contents of this text object
+TextCurve.edit_format -> edit_format:    pointer, (read-only)    Editing settings character formatting
+TextCurve.family -> family:    string    Use Blender Objects as font characters. Give font objects a common name followed by the character it represents, eg. familya, familyb etc, and turn on Verts Duplication
+TextCurve.font -> font:    pointer    
+TextCurve.line_dist -> line_dist:    float    
+TextCurve.offset_x -> offset_x:    float    Horizontal offset from the object origin
+TextCurve.offset_y -> offset_y:    float    Vertical offset from the object origin
+TextCurve.shear -> shear:    float    Italic angle of the characters
+TextCurve.spacemode -> spacemode:    enum    Text align from the object center
+TextCurve.spacing -> spacing:    float    
+TextCurve.text_on_curve -> text_on_curve:    pointer    Curve deforming text object
+TextCurve.text_size -> text_size:    float    
+TextCurve.textboxes -> textboxes:    collection, (read-only)    
+TextCurve.ul_height -> ul_height:    float    
+TextCurve.ul_position -> ul_position:    float    Vertical position of underline
+TextCurve.word_spacing -> word_spacing:    float    
+TextLine.line -> line:    string    Text in the line
+TextMarker.color -> color:    float    Color to display the marker with
+TextMarker.end -> end:    int, (read-only)    Start position of the marker in the line
+TextMarker.group -> group:    int, (read-only)    
+TextMarker.line -> line:    int, (read-only)    Line in which the marker is located
+TextMarker.start -> start:    int, (read-only)    Start position of the marker in the line
+Texture.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+Texture.brightness -> brightness:    float    
+Texture.color_ramp -> color_ramp:    pointer, (read-only)    
+Texture.contrast -> contrast:    float    
+Texture.factor_blue -> factor_blue:    float    
+Texture.factor_green -> factor_green:    float    
+Texture.factor_red -> factor_red:    float    
+Texture.node_tree -> node_tree:    pointer, (read-only)    Node tree for node-based textures
+Texture.saturation -> saturation:    float    
+Texture.type -> type:    enum    
+TextureNode.type -> type:    enum, (read-only)    
+TextureNodeBricks.offset -> offset:    float    
+TextureNodeBricks.offset_frequency -> offset_frequency:    int    Offset every N rows
+TextureNodeBricks.squash -> squash:    float    
+TextureNodeBricks.squash_frequency -> squash_frequency:    int    Squash every N rows
+TextureNodeCurveRGB.mapping -> mapping:    pointer, (read-only)    
+TextureNodeCurveTime.curve -> curve:    pointer, (read-only)    
+TextureNodeCurveTime.end -> end:    int    
+TextureNodeCurveTime.start -> start:    int    
+TextureNodeImage.image -> image:    pointer    
+TextureNodeMath.operation -> operation:    enum    
+TextureNodeMixRGB.blend_type -> blend_type:    enum    
+TextureNodeOutput.output_name -> output_name:    string    
+TextureNodeTexture.node_output -> node_output:    int    For node-based textures, which output node to use
+TextureNodeTexture.texture -> texture:    pointer    
+TextureNodeValToRGB.color_ramp -> color_ramp:    pointer, (read-only)    
+TextureSlot.blend_type -> blend_type:    enum    
+TextureSlot.color -> color:    float    The default color for textures that don't return RGB
+TextureSlot.default_value -> default_value:    float    Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard
+TextureSlot.name -> name:    string, (read-only)    Texture slot name
+TextureSlot.offset -> offset:    float    Fine tunes texture mapping X, Y and Z locations
+TextureSlot.output_node -> output_node:    enum    Which output node to use, for node-based textures
+TextureSlot.size -> size:    float    Sets scaling for the texture's X, Y and Z sizes
+TextureSlot.texture -> texture:    pointer    Texture datablock used by this texture slot
+Theme.bone_color_sets -> bone_color_sets:    collection, (read-only)    
+Theme.console -> console:    pointer, (read-only)    
+Theme.dopesheet_editor -> dopesheet_editor:    pointer, (read-only)    
+Theme.file_browser -> file_browser:    pointer, (read-only)    
+Theme.graph_editor -> graph_editor:    pointer, (read-only)    
+Theme.image_editor -> image_editor:    pointer, (read-only)    
+Theme.info -> info:    pointer, (read-only)    
+Theme.logic_editor -> logic_editor:    pointer, (read-only)    
+Theme.name -> name:    string    Name of the theme
+Theme.nla_editor -> nla_editor:    pointer, (read-only)    
+Theme.node_editor -> node_editor:    pointer, (read-only)    
+Theme.outliner -> outliner:    pointer, (read-only)    
+Theme.properties -> properties:    pointer, (read-only)    
+Theme.sequence_editor -> sequence_editor:    pointer, (read-only)    
+Theme.text_editor -> text_editor:    pointer, (read-only)    
+Theme.theme_area -> theme_area:    enum    
+Theme.timeline -> timeline:    pointer, (read-only)    
+Theme.user_interface -> user_interface:    pointer, (read-only)    
+Theme.user_preferences -> user_preferences:    pointer, (read-only)    
+Theme.view_3d -> view_3d:    pointer, (read-only)    
+ThemeAudioWindow.back -> back:    float    
+ThemeAudioWindow.button -> button:    float    
+ThemeAudioWindow.button_text -> button_text:    float    
+ThemeAudioWindow.button_text_hi -> button_text_hi:    float    
+ThemeAudioWindow.button_title -> button_title:    float    
+ThemeAudioWindow.frame_current -> frame_current:    float    
+ThemeAudioWindow.grid -> grid:    float    
+ThemeAudioWindow.header -> header:    float    
+ThemeAudioWindow.header_text -> header_text:    float    
+ThemeAudioWindow.header_text_hi -> header_text_hi:    float    
+ThemeAudioWindow.text -> text:    float    
+ThemeAudioWindow.text_hi -> text_hi:    float    
+ThemeAudioWindow.title -> title:    float    
+ThemeAudioWindow.window_sliders -> window_sliders:    float    
+ThemeBoneColorSet.active -> active:    float    Color used for active bones
+ThemeBoneColorSet.normal -> normal:    float    Color used for the surface of bones
+ThemeBoneColorSet.selected -> selected:    float    Color used for selected bones
+ThemeConsole.back -> back:    float    
+ThemeConsole.button -> button:    float    
+ThemeConsole.button_text -> button_text:    float    
+ThemeConsole.button_text_hi -> button_text_hi:    float    
+ThemeConsole.button_title -> button_title:    float    
+ThemeConsole.cursor -> cursor:    float    
+ThemeConsole.header -> header:    float    
+ThemeConsole.header_text -> header_text:    float    
+ThemeConsole.header_text_hi -> header_text_hi:    float    
+ThemeConsole.line_error -> line_error:    float    
+ThemeConsole.line_info -> line_info:    float    
+ThemeConsole.line_input -> line_input:    float    
+ThemeConsole.line_output -> line_output:    float    
+ThemeConsole.text -> text:    float    
+ThemeConsole.text_hi -> text_hi:    float    
+ThemeConsole.title -> title:    float    
+ThemeDopeSheet.active_channels_group -> active_channels_group:    float    
+ThemeDopeSheet.back -> back:    float    
+ThemeDopeSheet.button -> button:    float    
+ThemeDopeSheet.button_text -> button_text:    float    
+ThemeDopeSheet.button_text_hi -> button_text_hi:    float    
+ThemeDopeSheet.button_title -> button_title:    float    
+ThemeDopeSheet.channel_group -> channel_group:    float    
+ThemeDopeSheet.channels -> channels:    float    
+ThemeDopeSheet.channels_selected -> channels_selected:    float    
+ThemeDopeSheet.dopesheet_channel -> dopesheet_channel:    float    
+ThemeDopeSheet.dopesheet_subchannel -> dopesheet_subchannel:    float    
+ThemeDopeSheet.frame_current -> frame_current:    float    
+ThemeDopeSheet.grid -> grid:    float    
+ThemeDopeSheet.header -> header:    float    
+ThemeDopeSheet.header_text -> header_text:    float    
+ThemeDopeSheet.header_text_hi -> header_text_hi:    float    
+ThemeDopeSheet.list -> list:    float    
+ThemeDopeSheet.list_text -> list_text:    float    
+ThemeDopeSheet.list_text_hi -> list_text_hi:    float    
+ThemeDopeSheet.list_title -> list_title:    float    
+ThemeDopeSheet.long_key -> long_key:    float    
+ThemeDopeSheet.long_key_selected -> long_key_selected:    float    
+ThemeDopeSheet.text -> text:    float    
+ThemeDopeSheet.text_hi -> text_hi:    float    
+ThemeDopeSheet.title -> title:    float    
+ThemeDopeSheet.value_sliders -> value_sliders:    float    
+ThemeDopeSheet.view_sliders -> view_sliders:    float    
+ThemeFileBrowser.active_file -> active_file:    float    
+ThemeFileBrowser.active_file_text -> active_file_text:    float    
+ThemeFileBrowser.back -> back:    float    
+ThemeFileBrowser.button -> button:    float    
+ThemeFileBrowser.button_text -> button_text:    float    
+ThemeFileBrowser.button_text_hi -> button_text_hi:    float    
+ThemeFileBrowser.button_title -> button_title:    float    
+ThemeFileBrowser.header -> header:    float    
+ThemeFileBrowser.header_text -> header_text:    float    
+ThemeFileBrowser.header_text_hi -> header_text_hi:    float    
+ThemeFileBrowser.list -> list:    float    
+ThemeFileBrowser.list_text -> list_text:    float    
+ThemeFileBrowser.list_text_hi -> list_text_hi:    float    
+ThemeFileBrowser.list_title -> list_title:    float    
+ThemeFileBrowser.scroll_handle -> scroll_handle:    float    
+ThemeFileBrowser.scrollbar -> scrollbar:    float    
+ThemeFileBrowser.selected_file -> selected_file:    float    
+ThemeFileBrowser.text -> text:    float    
+ThemeFileBrowser.text_hi -> text_hi:    float    
+ThemeFileBrowser.tiles -> tiles:    float    
+ThemeFileBrowser.title -> title:    float    
+ThemeFontStyle.font_kerning_style -> font_kerning_style:    enum    Which style to use for font kerning
+ThemeFontStyle.points -> points:    int    
+ThemeFontStyle.shadow -> shadow:    int    Shadow size in pixels (0, 3 and 5 supported)
+ThemeFontStyle.shadowalpha -> shadowalpha:    float    
+ThemeFontStyle.shadowcolor -> shadowcolor:    float    Shadow color in grey value
+ThemeFontStyle.shadx -> shadx:    int    Shadow offset in pixels
+ThemeFontStyle.shady -> shady:    int    Shadow offset in pixels
+ThemeGraphEditor.active_channels_group -> active_channels_group:    float    
+ThemeGraphEditor.back -> back:    float    
+ThemeGraphEditor.button -> button:    float    
+ThemeGraphEditor.button_text -> button_text:    float    
+ThemeGraphEditor.button_text_hi -> button_text_hi:    float    
+ThemeGraphEditor.button_title -> button_title:    float    
+ThemeGraphEditor.channel_group -> channel_group:    float    
+ThemeGraphEditor.channels_region -> channels_region:    float    
+ThemeGraphEditor.dopesheet_channel -> dopesheet_channel:    float    
+ThemeGraphEditor.dopesheet_subchannel -> dopesheet_subchannel:    float    
+ThemeGraphEditor.frame_current -> frame_current:    float    
+ThemeGraphEditor.grid -> grid:    float    
+ThemeGraphEditor.handle_align -> handle_align:    float    
+ThemeGraphEditor.handle_auto -> handle_auto:    float    
+ThemeGraphEditor.handle_free -> handle_free:    float    
+ThemeGraphEditor.handle_sel_align -> handle_sel_align:    float    
+ThemeGraphEditor.handle_sel_auto -> handle_sel_auto:    float    
+ThemeGraphEditor.handle_sel_free -> handle_sel_free:    float    
+ThemeGraphEditor.handle_sel_vect -> handle_sel_vect:    float    
+ThemeGraphEditor.handle_vect -> handle_vect:    float    
+ThemeGraphEditor.handle_vertex -> handle_vertex:    float    
+ThemeGraphEditor.handle_vertex_select -> handle_vertex_select:    float    
+ThemeGraphEditor.handle_vertex_size -> handle_vertex_size:    int    
+ThemeGraphEditor.header -> header:    float    
+ThemeGraphEditor.header_text -> header_text:    float    
+ThemeGraphEditor.header_text_hi -> header_text_hi:    float    
+ThemeGraphEditor.lastsel_point -> lastsel_point:    float    
+ThemeGraphEditor.list -> list:    float    
+ThemeGraphEditor.list_text -> list_text:    float    
+ThemeGraphEditor.list_text_hi -> list_text_hi:    float    
+ThemeGraphEditor.list_title -> list_title:    float    
+ThemeGraphEditor.panel -> panel:    float    
+ThemeGraphEditor.text -> text:    float    
+ThemeGraphEditor.text_hi -> text_hi:    float    
+ThemeGraphEditor.title -> title:    float    
+ThemeGraphEditor.vertex -> vertex:    float    
+ThemeGraphEditor.vertex_select -> vertex_select:    float    
+ThemeGraphEditor.vertex_size -> vertex_size:    int    
+ThemeGraphEditor.window_sliders -> window_sliders:    float    
+ThemeImageEditor.back -> back:    float    
+ThemeImageEditor.button -> button:    float    
+ThemeImageEditor.button_text -> button_text:    float    
+ThemeImageEditor.button_text_hi -> button_text_hi:    float    
+ThemeImageEditor.button_title -> button_title:    float    
+ThemeImageEditor.editmesh_active -> editmesh_active:    float    
+ThemeImageEditor.face -> face:    float    
+ThemeImageEditor.face_dot -> face_dot:    float    
+ThemeImageEditor.face_select -> face_select:    float    
+ThemeImageEditor.facedot_size -> facedot_size:    int    
+ThemeImageEditor.header -> header:    float    
+ThemeImageEditor.header_text -> header_text:    float    
+ThemeImageEditor.header_text_hi -> header_text_hi:    float    
+ThemeImageEditor.scope_back -> scope_back:    float    
+ThemeImageEditor.text -> text:    float    
+ThemeImageEditor.text_hi -> text_hi:    float    
+ThemeImageEditor.title -> title:    float    
+ThemeImageEditor.vertex -> vertex:    float    
+ThemeImageEditor.vertex_select -> vertex_select:    float    
+ThemeImageEditor.vertex_size -> vertex_size:    int    
+ThemeInfo.back -> back:    float    
+ThemeInfo.button -> button:    float    
+ThemeInfo.button_text -> button_text:    float    
+ThemeInfo.button_text_hi -> button_text_hi:    float    
+ThemeInfo.button_title -> button_title:    float    
+ThemeInfo.header -> header:    float    
+ThemeInfo.header_text -> header_text:    float    
+ThemeInfo.header_text_hi -> header_text_hi:    float    
+ThemeInfo.text -> text:    float    
+ThemeInfo.text_hi -> text_hi:    float    
+ThemeInfo.title -> title:    float    
+ThemeLogicEditor.back -> back:    float    
+ThemeLogicEditor.button -> button:    float    
+ThemeLogicEditor.button_text -> button_text:    float    
+ThemeLogicEditor.button_text_hi -> button_text_hi:    float    
+ThemeLogicEditor.button_title -> button_title:    float    
+ThemeLogicEditor.header -> header:    float    
+ThemeLogicEditor.header_text -> header_text:    float    
+ThemeLogicEditor.header_text_hi -> header_text_hi:    float    
+ThemeLogicEditor.panel -> panel:    float    
+ThemeLogicEditor.text -> text:    float    
+ThemeLogicEditor.text_hi -> text_hi:    float    
+ThemeLogicEditor.title -> title:    float    
+ThemeNLAEditor.back -> back:    float    
+ThemeNLAEditor.bars -> bars:    float    
+ThemeNLAEditor.bars_selected -> bars_selected:    float    
+ThemeNLAEditor.button -> button:    float    
+ThemeNLAEditor.button_text -> button_text:    float    
+ThemeNLAEditor.button_text_hi -> button_text_hi:    float    
+ThemeNLAEditor.button_title -> button_title:    float    
+ThemeNLAEditor.frame_current -> frame_current:    float    
+ThemeNLAEditor.grid -> grid:    float    
+ThemeNLAEditor.header -> header:    float    
+ThemeNLAEditor.header_text -> header_text:    float    
+ThemeNLAEditor.header_text_hi -> header_text_hi:    float    
+ThemeNLAEditor.list -> list:    float    
+ThemeNLAEditor.list_text -> list_text:    float    
+ThemeNLAEditor.list_text_hi -> list_text_hi:    float    
+ThemeNLAEditor.list_title -> list_title:    float    
+ThemeNLAEditor.strips -> strips:    float    
+ThemeNLAEditor.strips_selected -> strips_selected:    float    
+ThemeNLAEditor.text -> text:    float    
+ThemeNLAEditor.text_hi -> text_hi:    float    
+ThemeNLAEditor.title -> title:    float    
+ThemeNLAEditor.view_sliders -> view_sliders:    float    
+ThemeNodeEditor.back -> back:    float    
+ThemeNodeEditor.button -> button:    float    
+ThemeNodeEditor.button_text -> button_text:    float    
+ThemeNodeEditor.button_text_hi -> button_text_hi:    float    
+ThemeNodeEditor.button_title -> button_title:    float    
+ThemeNodeEditor.converter_node -> converter_node:    float    
+ThemeNodeEditor.group_node -> group_node:    float    
+ThemeNodeEditor.header -> header:    float    
+ThemeNodeEditor.header_text -> header_text:    float    
+ThemeNodeEditor.header_text_hi -> header_text_hi:    float    
+ThemeNodeEditor.in_out_node -> in_out_node:    float    
+ThemeNodeEditor.list -> list:    float    
+ThemeNodeEditor.list_text -> list_text:    float    
+ThemeNodeEditor.list_text_hi -> list_text_hi:    float    
+ThemeNodeEditor.list_title -> list_title:    float    
+ThemeNodeEditor.node_backdrop -> node_backdrop:    float    
+ThemeNodeEditor.operator_node -> operator_node:    float    
+ThemeNodeEditor.selected_text -> selected_text:    float    
+ThemeNodeEditor.text -> text:    float    
+ThemeNodeEditor.text_hi -> text_hi:    float    
+ThemeNodeEditor.title -> title:    float    
+ThemeNodeEditor.wire_select -> wire_select:    float    
+ThemeNodeEditor.wires -> wires:    float    
+ThemeOutliner.back -> back:    float    
+ThemeOutliner.button -> button:    float    
+ThemeOutliner.button_text -> button_text:    float    
+ThemeOutliner.button_text_hi -> button_text_hi:    float    
+ThemeOutliner.button_title -> button_title:    float    
+ThemeOutliner.header -> header:    float    
+ThemeOutliner.header_text -> header_text:    float    
+ThemeOutliner.header_text_hi -> header_text_hi:    float    
+ThemeOutliner.text -> text:    float    
+ThemeOutliner.text_hi -> text_hi:    float    
+ThemeOutliner.title -> title:    float    
+ThemeProperties.back -> back:    float    
+ThemeProperties.button -> button:    float    
+ThemeProperties.button_text -> button_text:    float    
+ThemeProperties.button_text_hi -> button_text_hi:    float    
+ThemeProperties.button_title -> button_title:    float    
+ThemeProperties.header -> header:    float    
+ThemeProperties.header_text -> header_text:    float    
+ThemeProperties.header_text_hi -> header_text_hi:    float    
+ThemeProperties.panel -> panel:    float    
+ThemeProperties.text -> text:    float    
+ThemeProperties.text_hi -> text_hi:    float    
+ThemeProperties.title -> title:    float    
+ThemeSequenceEditor.audio_strip -> audio_strip:    float    
+ThemeSequenceEditor.back -> back:    float    
+ThemeSequenceEditor.button -> button:    float    
+ThemeSequenceEditor.button_text -> button_text:    float    
+ThemeSequenceEditor.button_text_hi -> button_text_hi:    float    
+ThemeSequenceEditor.button_title -> button_title:    float    
+ThemeSequenceEditor.draw_action -> draw_action:    float    
+ThemeSequenceEditor.effect_strip -> effect_strip:    float    
+ThemeSequenceEditor.frame_current -> frame_current:    float    
+ThemeSequenceEditor.grid -> grid:    float    
+ThemeSequenceEditor.header -> header:    float    
+ThemeSequenceEditor.header_text -> header_text:    float    
+ThemeSequenceEditor.header_text_hi -> header_text_hi:    float    
+ThemeSequenceEditor.image_strip -> image_strip:    float    
+ThemeSequenceEditor.keyframe -> keyframe:    float    
+ThemeSequenceEditor.meta_strip -> meta_strip:    float    
+ThemeSequenceEditor.movie_strip -> movie_strip:    float    
+ThemeSequenceEditor.plugin_strip -> plugin_strip:    float    
+ThemeSequenceEditor.scene_strip -> scene_strip:    float    
+ThemeSequenceEditor.text -> text:    float    
+ThemeSequenceEditor.text_hi -> text_hi:    float    
+ThemeSequenceEditor.title -> title:    float    
+ThemeSequenceEditor.transition_strip -> transition_strip:    float    
+ThemeSequenceEditor.window_sliders -> window_sliders:    float    
+ThemeStyle.grouplabel -> grouplabel:    pointer, (read-only)    
+ThemeStyle.paneltitle -> paneltitle:    pointer, (read-only)    
+ThemeStyle.panelzoom -> panelzoom:    float    Default zoom level for panel areas
+ThemeStyle.widget -> widget:    pointer, (read-only)    
+ThemeStyle.widgetlabel -> widgetlabel:    pointer, (read-only)    
+ThemeTextEditor.back -> back:    float    
+ThemeTextEditor.button -> button:    float    
+ThemeTextEditor.button_text -> button_text:    float    
+ThemeTextEditor.button_text_hi -> button_text_hi:    float    
+ThemeTextEditor.button_title -> button_title:    float    
+ThemeTextEditor.cursor -> cursor:    float    
+ThemeTextEditor.header -> header:    float    
+ThemeTextEditor.header_text -> header_text:    float    
+ThemeTextEditor.header_text_hi -> header_text_hi:    float    
+ThemeTextEditor.line_numbers_background -> line_numbers_background:    float    
+ThemeTextEditor.scroll_bar -> scroll_bar:    float    
+ThemeTextEditor.selected_text -> selected_text:    float    
+ThemeTextEditor.syntax_builtin -> syntax_builtin:    float    
+ThemeTextEditor.syntax_comment -> syntax_comment:    float    
+ThemeTextEditor.syntax_numbers -> syntax_numbers:    float    
+ThemeTextEditor.syntax_special -> syntax_special:    float    
+ThemeTextEditor.syntax_string -> syntax_string:    float    
+ThemeTextEditor.text -> text:    float    
+ThemeTextEditor.text_hi -> text_hi:    float    
+ThemeTextEditor.title -> title:    float    
+ThemeTimeline.back -> back:    float    
+ThemeTimeline.button -> button:    float    
+ThemeTimeline.button_text -> button_text:    float    
+ThemeTimeline.button_text_hi -> button_text_hi:    float    
+ThemeTimeline.button_title -> button_title:    float    
+ThemeTimeline.frame_current -> frame_current:    float    
+ThemeTimeline.grid -> grid:    float    
+ThemeTimeline.header -> header:    float    
+ThemeTimeline.header_text -> header_text:    float    
+ThemeTimeline.header_text_hi -> header_text_hi:    float    
+ThemeTimeline.text -> text:    float    
+ThemeTimeline.text_hi -> text_hi:    float    
+ThemeTimeline.title -> title:    float    
+ThemeUserInterface.icon_file -> icon_file:    string    
+ThemeUserInterface.wcol_box -> wcol_box:    pointer, (read-only)    
+ThemeUserInterface.wcol_list_item -> wcol_list_item:    pointer, (read-only)    
+ThemeUserInterface.wcol_menu -> wcol_menu:    pointer, (read-only)    
+ThemeUserInterface.wcol_menu_back -> wcol_menu_back:    pointer, (read-only)    
+ThemeUserInterface.wcol_menu_item -> wcol_menu_item:    pointer, (read-only)    
+ThemeUserInterface.wcol_num -> wcol_num:    pointer, (read-only)    
+ThemeUserInterface.wcol_numslider -> wcol_numslider:    pointer, (read-only)    
+ThemeUserInterface.wcol_option -> wcol_option:    pointer, (read-only)    
+ThemeUserInterface.wcol_progress -> wcol_progress:    pointer, (read-only)    
+ThemeUserInterface.wcol_pulldown -> wcol_pulldown:    pointer, (read-only)    
+ThemeUserInterface.wcol_radio -> wcol_radio:    pointer, (read-only)    
+ThemeUserInterface.wcol_regular -> wcol_regular:    pointer, (read-only)    
+ThemeUserInterface.wcol_scroll -> wcol_scroll:    pointer, (read-only)    
+ThemeUserInterface.wcol_state -> wcol_state:    pointer, (read-only)    
+ThemeUserInterface.wcol_text -> wcol_text:    pointer, (read-only)    
+ThemeUserInterface.wcol_toggle -> wcol_toggle:    pointer, (read-only)    
+ThemeUserInterface.wcol_tool -> wcol_tool:    pointer, (read-only)    
+ThemeUserPreferences.back -> back:    float    
+ThemeUserPreferences.button -> button:    float    
+ThemeUserPreferences.button_text -> button_text:    float    
+ThemeUserPreferences.button_text_hi -> button_text_hi:    float    
+ThemeUserPreferences.button_title -> button_title:    float    
+ThemeUserPreferences.header -> header:    float    
+ThemeUserPreferences.header_text -> header_text:    float    
+ThemeUserPreferences.header_text_hi -> header_text_hi:    float    
+ThemeUserPreferences.text -> text:    float    
+ThemeUserPreferences.text_hi -> text_hi:    float    
+ThemeUserPreferences.title -> title:    float    
+ThemeView3D.act_spline -> act_spline:    float    
+ThemeView3D.back -> back:    float    
+ThemeView3D.bone_pose -> bone_pose:    float    
+ThemeView3D.bone_solid -> bone_solid:    float    
+ThemeView3D.button -> button:    float    
+ThemeView3D.button_text -> button_text:    float    
+ThemeView3D.button_text_hi -> button_text_hi:    float    
+ThemeView3D.button_title -> button_title:    float    
+ThemeView3D.edge_crease -> edge_crease:    float    
+ThemeView3D.edge_facesel -> edge_facesel:    float    
+ThemeView3D.edge_seam -> edge_seam:    float    
+ThemeView3D.edge_select -> edge_select:    float    
+ThemeView3D.edge_sharp -> edge_sharp:    float    
+ThemeView3D.editmesh_active -> editmesh_active:    float    
+ThemeView3D.face -> face:    float    
+ThemeView3D.face_dot -> face_dot:    float    
+ThemeView3D.face_select -> face_select:    float    
+ThemeView3D.facedot_size -> facedot_size:    int    
+ThemeView3D.frame_current -> frame_current:    float    
+ThemeView3D.grid -> grid:    float    
+ThemeView3D.handle_align -> handle_align:    float    
+ThemeView3D.handle_auto -> handle_auto:    float    
+ThemeView3D.handle_free -> handle_free:    float    
+ThemeView3D.handle_sel_align -> handle_sel_align:    float    
+ThemeView3D.handle_sel_auto -> handle_sel_auto:    float    
+ThemeView3D.handle_sel_free -> handle_sel_free:    float    
+ThemeView3D.handle_sel_vect -> handle_sel_vect:    float    
+ThemeView3D.handle_vect -> handle_vect:    float    
+ThemeView3D.header -> header:    float    
+ThemeView3D.header_text -> header_text:    float    
+ThemeView3D.header_text_hi -> header_text_hi:    float    
+ThemeView3D.lamp -> lamp:    float    
+ThemeView3D.lastsel_point -> lastsel_point:    float    
+ThemeView3D.normal -> normal:    float    
+ThemeView3D.nurb_sel_uline -> nurb_sel_uline:    float    
+ThemeView3D.nurb_sel_vline -> nurb_sel_vline:    float    
+ThemeView3D.nurb_uline -> nurb_uline:    float    
+ThemeView3D.nurb_vline -> nurb_vline:    float    
+ThemeView3D.object_active -> object_active:    float    
+ThemeView3D.object_grouped -> object_grouped:    float    
+ThemeView3D.object_grouped_active -> object_grouped_active:    float    
+ThemeView3D.object_selected -> object_selected:    float    
+ThemeView3D.panel -> panel:    float    
+ThemeView3D.text -> text:    float    
+ThemeView3D.text_hi -> text_hi:    float    
+ThemeView3D.title -> title:    float    
+ThemeView3D.transform -> transform:    float    
+ThemeView3D.vertex -> vertex:    float    
+ThemeView3D.vertex_normal -> vertex_normal:    float    
+ThemeView3D.vertex_select -> vertex_select:    float    
+ThemeView3D.vertex_size -> vertex_size:    int    
+ThemeView3D.wire -> wire:    float    
+ThemeWidgetColors.inner -> inner:    float    
+ThemeWidgetColors.inner_sel -> inner_sel:    float    
+ThemeWidgetColors.item -> item:    float    
+ThemeWidgetColors.outline -> outline:    float    
+ThemeWidgetColors.shadedown -> shadedown:    int    
+ThemeWidgetColors.shadetop -> shadetop:    int    
+ThemeWidgetColors.text -> text:    float    
+ThemeWidgetColors.text_sel -> text_sel:    float    
+ThemeWidgetStateColors.blend -> blend:    float    
+ThemeWidgetStateColors.inner_anim -> inner_anim:    float    
+ThemeWidgetStateColors.inner_anim_sel -> inner_anim_sel:    float    
+ThemeWidgetStateColors.inner_driven -> inner_driven:    float    
+ThemeWidgetStateColors.inner_driven_sel -> inner_driven_sel:    float    
+ThemeWidgetStateColors.inner_key -> inner_key:    float    
+ThemeWidgetStateColors.inner_key_sel -> inner_key_sel:    float    
+TimelineMarker.camera -> camera:    pointer    Camera this timeline sets to active
+TimelineMarker.frame -> frame:    int    The frame on which the timeline marker appears
+TimelineMarker.name -> name:    string    
+ToolSettings.autokey_mode -> autokey_mode:    enum    Mode of automatic keyframe insertion for Objects and Bones
+ToolSettings.edge_path_mode -> edge_path_mode:    enum    The edge flag to tag when selecting the shortest path
+ToolSettings.etch_adaptive_limit -> etch_adaptive_limit:    float    Number of bones in the subdivided stroke
+ToolSettings.etch_convert_mode -> etch_convert_mode:    enum    Method used to convert stroke to bones
+ToolSettings.etch_length_limit -> etch_length_limit:    float    Number of bones in the subdivided stroke
+ToolSettings.etch_number -> etch_number:    string    DOC BROKEN
+ToolSettings.etch_roll_mode -> etch_roll_mode:    enum    Method used to adjust the roll of bones when retargeting
+ToolSettings.etch_side -> etch_side:    string    DOC BROKEN
+ToolSettings.etch_subdivision_number -> etch_subdivision_number:    int    Number of bones in the subdivided stroke
+ToolSettings.etch_template -> etch_template:    pointer    Template armature that will be retargeted to the stroke
+ToolSettings.image_paint -> image_paint:    pointer, (read-only)    
+ToolSettings.normal_size -> normal_size:    float    Display size for normals in the 3D view
+ToolSettings.particle_edit -> particle_edit:    pointer, (read-only)    
+ToolSettings.proportional_editing -> proportional_editing:    enum    Proportional editing mode
+ToolSettings.proportional_editing_falloff -> proportional_editing_falloff:    enum    Falloff type for proportional editing mode
+ToolSettings.sculpt -> sculpt:    pointer, (read-only)    
+ToolSettings.snap_element -> snap_element:    enum    Type of element to snap to
+ToolSettings.snap_target -> snap_target:    enum    Which part to snap onto the target
+ToolSettings.uv_selection_mode -> uv_selection_mode:    enum    UV selection and display mode
+ToolSettings.vertex_group_weight -> vertex_group_weight:    float    Weight to assign in vertex groups
+ToolSettings.vertex_paint -> vertex_paint:    pointer, (read-only)    
+ToolSettings.weight_paint -> weight_paint:    pointer, (read-only)    
+TouchSensor.material -> material:    pointer    Only look for objects with this material
+TrackToConstraint.head_tail -> head_tail:    float    Target along length of bone: Head=0, Tail=1
+TrackToConstraint.subtarget -> subtarget:    string    
+TrackToConstraint.target -> target:    pointer    Target Object
+TrackToConstraint.track -> track:    enum    Axis that points to the target object
+TrackToConstraint.up -> up:    enum    Axis that points upward
+TransformConstraint.from_max_x -> from_max_x:    float    Top range of X axis source motion
+TransformConstraint.from_max_y -> from_max_y:    float    Top range of Y axis source motion
+TransformConstraint.from_max_z -> from_max_z:    float    Top range of Z axis source motion
+TransformConstraint.from_min_x -> from_min_x:    float    Bottom range of X axis source motion
+TransformConstraint.from_min_y -> from_min_y:    float    Bottom range of Y axis source motion
+TransformConstraint.from_min_z -> from_min_z:    float    Bottom range of Z axis source motion
+TransformConstraint.map_from -> map_from:    enum    The transformation type to use from the target
+TransformConstraint.map_to -> map_to:    enum    The transformation type to affect of the constrained object
+TransformConstraint.map_to_x_from -> map_to_x_from:    enum    The source axis constrained object's X axis uses
+TransformConstraint.map_to_y_from -> map_to_y_from:    enum    The source axis constrained object's Y axis uses
+TransformConstraint.map_to_z_from -> map_to_z_from:    enum    The source axis constrained object's Z axis uses
+TransformConstraint.subtarget -> subtarget:    string    
+TransformConstraint.target -> target:    pointer    Target Object
+TransformConstraint.to_max_x -> to_max_x:    float    Top range of X axis destination motion
+TransformConstraint.to_max_y -> to_max_y:    float    Top range of Y axis destination motion
+TransformConstraint.to_max_z -> to_max_z:    float    Top range of Z axis destination motion
+TransformConstraint.to_min_x -> to_min_x:    float    Bottom range of X axis destination motion
+TransformConstraint.to_min_y -> to_min_y:    float    Bottom range of Y axis destination motion
+TransformConstraint.to_min_z -> to_min_z:    float    Bottom range of Z axis destination motion
+TransformOrientation.matrix -> matrix:    float    
+TransformOrientation.name -> name:    string    
+TransformSequence.interpolation -> interpolation:    enum    
+TransformSequence.rotation_start -> rotation_start:    float    
+TransformSequence.scale_start_x -> scale_start_x:    float    
+TransformSequence.scale_start_y -> scale_start_y:    float    
+TransformSequence.translate_start_x -> translate_start_x:    float    
+TransformSequence.translate_start_y -> translate_start_y:    float    
+TransformSequence.translation_unit -> translation_unit:    enum    
+UILayout.alignment -> alignment:    enum    
+UILayout.operator_context -> operator_context:    enum    
+UILayout.scale_x -> scale_x:    float    
+UILayout.scale_y -> scale_y:    float    
+UVProjectModifier.aspect_x -> aspect_x:    float    
+UVProjectModifier.aspect_y -> aspect_y:    float    
+UVProjectModifier.image -> image:    pointer    
+UVProjectModifier.num_projectors -> num_projectors:    int    Number of projectors to use
+UVProjectModifier.projectors -> projectors:    collection, (read-only)    
+UVProjectModifier.scale_x -> scale_x:    float    
+UVProjectModifier.scale_y -> scale_y:    float    
+UVProjectModifier.uv_layer -> uv_layer:    string    UV layer name
+UVProjector.object -> object:    pointer    Object to use as projector transform
+UnitSettings.rotation_units -> rotation_units:    enum    Unit to use for displaying/editing rotation values
+UnitSettings.scale_length -> scale_length:    float    Scale to use when converting between blender units and dimensions
+UnitSettings.system -> system:    enum    The unit system to use for button display
+UserPreferences.active_section -> active_section:    enum    Active section of the user preferences shown in the user interface
+UserPreferences.addons -> addons:    collection, (read-only)    
+UserPreferences.edit -> edit:    pointer, (read-only)    Settings for interacting with Blender data
+UserPreferences.filepaths -> filepaths:    pointer, (read-only)    Default paths for external files
+UserPreferences.inputs -> inputs:    pointer, (read-only)    Settings for input devices
+UserPreferences.system -> system:    pointer, (read-only)    Graphics driver and operating system settings
+UserPreferences.themes -> themes:    collection, (read-only)    
+UserPreferences.uistyles -> uistyles:    collection, (read-only)    
+UserPreferences.view -> view:    pointer, (read-only)    Preferences related to viewing data
+UserPreferencesEdit.auto_keying_mode -> auto_keying_mode:    enum    Mode of automatic keyframe insertion for Objects and Bones
+UserPreferencesEdit.grease_pencil_eraser_radius -> grease_pencil_eraser_radius:    int    Radius of eraser 'brush'
+UserPreferencesEdit.grease_pencil_euclidean_distance -> grease_pencil_euclidean_distance:    int    Distance moved by mouse when drawing stroke (in pixels) to include
+UserPreferencesEdit.grease_pencil_manhattan_distance -> grease_pencil_manhattan_distance:    int    Pixels moved by mouse per axis when drawing stroke
+UserPreferencesEdit.keyframe_new_handle_type -> keyframe_new_handle_type:    enum    
+UserPreferencesEdit.keyframe_new_interpolation_type -> keyframe_new_interpolation_type:    enum    
+UserPreferencesEdit.material_link -> material_link:    enum    Toggle whether the material is linked to object data or the object block
+UserPreferencesEdit.object_align -> object_align:    enum    When adding objects from a 3D View menu, either align them to that view's direction or the world coordinates
+UserPreferencesEdit.undo_memory_limit -> undo_memory_limit:    int    Maximum memory usage in megabytes (0 means unlimited)
+UserPreferencesEdit.undo_steps -> undo_steps:    int    Number of undo steps available (smaller values conserve memory)
+UserPreferencesFilePaths.animation_player -> animation_player:    string    Path to a custom animation/frame sequence player
+UserPreferencesFilePaths.animation_player_preset -> animation_player_preset:    enum    Preset configs for external animation players
+UserPreferencesFilePaths.auto_save_time -> auto_save_time:    int    The time (in minutes) to wait between automatic temporary saves
+UserPreferencesFilePaths.fonts_directory -> fonts_directory:    string    The default directory to search for loading fonts
+UserPreferencesFilePaths.image_editor -> image_editor:    string    Path to an image editor
+UserPreferencesFilePaths.python_scripts_directory -> python_scripts_directory:    string    The default directory to search for Python scripts (resets python module search path: sys.path)
+UserPreferencesFilePaths.recent_files -> recent_files:    int    Maximum number of recently opened files to remember
+UserPreferencesFilePaths.render_output_directory -> render_output_directory:    string    The default directory for rendering output
+UserPreferencesFilePaths.save_version -> save_version:    int    The number of old versions to maintain in the current directory, when manually saving
+UserPreferencesFilePaths.sequence_plugin_directory -> sequence_plugin_directory:    string    The default directory to search for sequence plugins
+UserPreferencesFilePaths.sounds_directory -> sounds_directory:    string    The default directory to search for sounds
+UserPreferencesFilePaths.temporary_directory -> temporary_directory:    string    The directory for storing temporary save files
+UserPreferencesFilePaths.texture_plugin_directory -> texture_plugin_directory:    string    The default directory to search for texture plugins
+UserPreferencesFilePaths.textures_directory -> textures_directory:    string    The default directory to search for textures
+UserPreferencesInput.double_click_time -> double_click_time:    int    The time (in ms) for a double click
+UserPreferencesInput.edited_keymaps -> edited_keymaps:    collection, (read-only)    
+UserPreferencesInput.ndof_pan_speed -> ndof_pan_speed:    int    The overall panning speed of an NDOF device, as percent of standard
+UserPreferencesInput.ndof_rotate_speed -> ndof_rotate_speed:    int    The overall rotation speed of an NDOF device, as percent of standard
+UserPreferencesInput.select_mouse -> select_mouse:    enum    The mouse button used for selection
+UserPreferencesInput.view_rotation -> view_rotation:    enum    Rotation style in the viewport
+UserPreferencesInput.zoom_axis -> zoom_axis:    enum    Axis of mouse movement to zoom in or out on
+UserPreferencesInput.zoom_style -> zoom_style:    enum    Which style to use for viewport scaling
+UserPreferencesSystem.audio_channels -> audio_channels:    enum    Sets the audio channel count
+UserPreferencesSystem.audio_device -> audio_device:    enum    Sets the audio output device
+UserPreferencesSystem.audio_mixing_buffer -> audio_mixing_buffer:    enum    Sets the number of samples used by the audio mixing buffer
+UserPreferencesSystem.audio_sample_format -> audio_sample_format:    enum    Sets the audio sample format
+UserPreferencesSystem.audio_sample_rate -> audio_sample_rate:    enum    Sets the audio sample rate
+UserPreferencesSystem.clip_alpha -> clip_alpha:    float    Clip alpha below this threshold in the 3D textured view
+UserPreferencesSystem.color_picker_type -> color_picker_type:    enum    Different styles of displaying the color picker widget
+UserPreferencesSystem.dpi -> dpi:    int    Font size and resolution for display
+UserPreferencesSystem.frame_server_port -> frame_server_port:    int    Frameserver Port for Frameserver Rendering
+UserPreferencesSystem.gl_texture_limit -> gl_texture_limit:    enum    Limit the texture size to save graphics memory
+UserPreferencesSystem.language -> language:    enum    Language use for translation
+UserPreferencesSystem.memory_cache_limit -> memory_cache_limit:    int    Memory cache limit in sequencer (megabytes)
+UserPreferencesSystem.prefetch_frames -> prefetch_frames:    int    Number of frames to render ahead during playback
+UserPreferencesSystem.screencast_fps -> screencast_fps:    int    Frame rate for the screencast to be played back
+UserPreferencesSystem.screencast_wait_time -> screencast_wait_time:    int    Time in milliseconds between each frame recorded for screencast
+UserPreferencesSystem.scrollback -> scrollback:    int    Maximum number of lines to store for the console buffer
+UserPreferencesSystem.solid_lights -> solid_lights:    collection, (read-only)    Lights user to display objects in solid draw mode
+UserPreferencesSystem.texture_collection_rate -> texture_collection_rate:    int    Number of seconds between each run of the GL texture garbage collector
+UserPreferencesSystem.texture_time_out -> 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.)
+UserPreferencesSystem.weight_color_range -> weight_color_range:    pointer, (read-only)    Color range used for weight visualization in weight painting mode
+UserPreferencesSystem.window_draw_method -> window_draw_method:    enum    Drawing method used by the window manager
+UserPreferencesView.manipulator_handle_size -> manipulator_handle_size:    int    Size of widget handles as percentage of widget radius
+UserPreferencesView.manipulator_hotspot -> manipulator_hotspot:    int    Hotspot in pixels for clicking widget handles
+UserPreferencesView.manipulator_size -> manipulator_size:    int    Diameter of widget, in 10 pixel units
+UserPreferencesView.mini_axis_brightness -> mini_axis_brightness:    int    The brightness of the icon
+UserPreferencesView.mini_axis_size -> mini_axis_size:    int    The axis icon's size
+UserPreferencesView.object_origin_size -> object_origin_size:    int    Diameter in Pixels for Object/Lamp origin display
+UserPreferencesView.open_left_mouse_delay -> open_left_mouse_delay:    int    Time in 1/10 seconds to hold the Left Mouse Button before opening the toolbox
+UserPreferencesView.open_right_mouse_delay -> open_right_mouse_delay:    int    Time in 1/10 seconds to hold the Right Mouse Button before opening the toolbox
+UserPreferencesView.open_sublevel_delay -> open_sublevel_delay:    int    Time delay in 1/10 seconds before automatically opening sub level menus
+UserPreferencesView.open_toplevel_delay -> open_toplevel_delay:    int    Time delay in 1/10 seconds before automatically opening top level menus
+UserPreferencesView.properties_width_check -> properties_width_check:    int    Dual Column layout will change to single column layout when the width of the area gets below this value (needs restart to take effect)
+UserPreferencesView.rotation_angle -> rotation_angle:    int    The rotation step for numerical pad keys (2 4 6 8)
+UserPreferencesView.smooth_view -> smooth_view:    int    The time to animate the view in milliseconds, zero to disable
+UserPreferencesView.timecode_style -> timecode_style:    enum    Format of Time Codes displayed when not displaying timing in terms of frames
+UserPreferencesView.view2d_grid_minimum_spacing -> view2d_grid_minimum_spacing:    int    Minimum number of pixels between each gridline in 2D Viewports
+UserPreferencesView.wheel_scroll_lines -> wheel_scroll_lines:    int    The number of lines scrolled at a time with the mouse wheel
+UserSolidLight.diffuse_color -> diffuse_color:    float    The diffuse color of the OpenGL light
+UserSolidLight.direction -> direction:    float    The direction that the OpenGL light is shining
+UserSolidLight.specular_color -> specular_color:    float    The color of the lights specular highlight
+ValueNodeSocket.default_value -> default_value:    float    Default value of the socket when no link is attached
+ValueNodeSocket.name -> name:    string, (read-only)    Socket name
+VectorFont.filepath -> filepath:    string, (read-only)    
+VectorFont.packed_file -> packed_file:    pointer, (read-only)    
+VectorNodeSocket.default_value -> default_value:    float    Default value of the socket when no link is attached
+VectorNodeSocket.name -> name:    string, (read-only)    Socket name
+VertexGroup.index -> index:    int, (read-only)    Index number of the vertex group
+VertexGroup.name -> name:    string    Vertex group name
+VertexGroupElement.group -> group:    int, (read-only)    
+VertexGroupElement.weight -> weight:    float    Vertex Weight
+VoronoiTexture.coloring -> coloring:    enum    
+VoronoiTexture.distance_metric -> distance_metric:    enum    
+VoronoiTexture.minkovsky_exponent -> minkovsky_exponent:    float    Minkovsky exponent
+VoronoiTexture.nabla -> nabla:    float    Size of derivative offset used for calculating normal
+VoronoiTexture.noise_intensity -> noise_intensity:    float    
+VoronoiTexture.noise_size -> noise_size:    float    Sets scaling for noise input
+VoronoiTexture.weight_1 -> weight_1:    float    Voronoi feature weight 1
+VoronoiTexture.weight_2 -> weight_2:    float    Voronoi feature weight 2
+VoronoiTexture.weight_3 -> weight_3:    float    Voronoi feature weight 3
+VoronoiTexture.weight_4 -> weight_4:    float    Voronoi feature weight 4
+VoxelData.domain_object -> domain_object:    pointer    Object used as the smoke simulation domain
+VoxelData.extension -> extension:    enum    Sets how the texture is extrapolated past its original bounds
+VoxelData.file_format -> file_format:    enum    Format of the source data set to render
+VoxelData.intensity -> intensity:    float    Multiplier for intensity values
+VoxelData.interpolation -> interpolation:    enum    Method to interpolate/smooth values between voxel cells
+VoxelData.resolution -> resolution:    int    Resolution of the voxel grid
+VoxelData.smoke_data_type -> smoke_data_type:    enum    Simulation value to be used as a texture
+VoxelData.source_path -> source_path:    string    The external source data file to use
+VoxelData.still_frame_number -> still_frame_number:    int    The frame number to always use
+VoxelDataTexture.image -> image:    pointer    
+VoxelDataTexture.image_user -> image_user:    pointer, (read-only)    Parameters defining which layer, pass and frame of the image is displayed
+VoxelDataTexture.voxeldata -> voxeldata:    pointer, (read-only)    The voxel data associated with this texture
+WaveModifier.damping_time -> damping_time:    float    
+WaveModifier.falloff_radius -> falloff_radius:    float    
+WaveModifier.height -> height:    float    
+WaveModifier.lifetime -> lifetime:    float    
+WaveModifier.narrowness -> narrowness:    float    
+WaveModifier.speed -> speed:    float    
+WaveModifier.start_position_object -> start_position_object:    pointer    
+WaveModifier.start_position_x -> start_position_x:    float    
+WaveModifier.start_position_y -> start_position_y:    float    
+WaveModifier.texture -> texture:    pointer    Texture for modulating the wave
+WaveModifier.texture_coordinates -> texture_coordinates:    enum    Texture coordinates used for modulating input
+WaveModifier.texture_coordinates_object -> texture_coordinates_object:    pointer    
+WaveModifier.time_offset -> time_offset:    float    Either the starting frame (for positive speed) or ending frame (for negative speed.)
+WaveModifier.uv_layer -> uv_layer:    string    UV layer name
+WaveModifier.vertex_group -> vertex_group:    string    Vertex group name for modulating the wave
+WaveModifier.width -> width:    float    
+Window.screen -> screen:    pointer    Active screen showing in the window
+WindowManager.active_keyconfig -> active_keyconfig:    pointer    
+WindowManager.default_keyconfig -> default_keyconfig:    pointer, (read-only)    
+WindowManager.keyconfigs -> keyconfigs:    collection, (read-only)    Registered key configurations
+WindowManager.operators -> operators:    collection, (read-only)    Operator registry
+WindowManager.windows -> windows:    collection, (read-only)    Open windows
+WipeSequence.angle -> angle:    float    Edge angle
+WipeSequence.blur_width -> blur_width:    float    Width of the blur edge, in percentage relative to the image size
+WipeSequence.direction -> direction:    enum    Wipe direction
+WipeSequence.transition_type -> transition_type:    enum    
+WoodTexture.nabla -> nabla:    float    Size of derivative offset used for calculating normal
+WoodTexture.noise_basis -> noise_basis:    enum    Sets the noise basis used for turbulence
+WoodTexture.noise_size -> noise_size:    float    Sets scaling for noise input
+WoodTexture.noise_type -> noise_type:    enum    
+WoodTexture.noisebasis2 -> noisebasis2:    enum    
+WoodTexture.stype -> stype:    enum    
+WoodTexture.turbulence -> turbulence:    float    Sets the turbulence of the bandnoise and ringnoise types
+World.active_texture -> active_texture:    pointer    Active texture slot being displayed
+World.active_texture_index -> active_texture_index:    int    Index of active texture slot
+World.ambient_color -> ambient_color:    float    
+World.animation_data -> animation_data:    pointer, (read-only)    Animation data for this datablock
+World.exposure -> exposure:    float    Amount of exponential color correction for light
+World.horizon_color -> horizon_color:    float    Color at the horizon
+World.lighting -> lighting:    pointer, (read-only)    World lighting settings
+World.mist -> mist:    pointer, (read-only)    World mist settings
+World.range -> range:    float    The color range that will be mapped to 0-1
+World.stars -> stars:    pointer, (read-only)    World stars settings
+World.texture_slots -> texture_slots:    collection, (read-only)    Texture slots defining the mapping and influence of textures
+World.zenith_color -> zenith_color:    float    Color at the zenith
+WorldLighting.adapt_to_speed -> adapt_to_speed:    float    Use the speed vector pass to reduce AO samples in fast moving pixels. Higher values result in more aggressive sample reduction. Requires Vec pass enabled (for Raytrace Adaptive QMC)
+WorldLighting.ao_blend_mode -> ao_blend_mode:    enum    Defines how AO mixes with material shading
+WorldLighting.ao_factor -> ao_factor:    float    Factor for ambient occlusion blending
+WorldLighting.bias -> bias:    float    Bias (in radians) to prevent smoothed faces from showing banding (for Raytrace Constant Jittered)
+WorldLighting.correction -> correction:    float    Ad-hoc correction for over-occlusion due to the approximation (for Approximate)
+WorldLighting.distance -> distance:    float    Length of rays, defines how far away other faces give occlusion effect
+WorldLighting.environment_color -> environment_color:    enum    Defines where the color of the environment light comes from
+WorldLighting.environment_energy -> environment_energy:    float    Defines the strength of environment light
+WorldLighting.error_tolerance -> error_tolerance:    float    Low values are slower and higher quality (for Approximate)
+WorldLighting.falloff_strength -> falloff_strength:    float    Distance attenuation factor, the higher, the 'shorter' the shadows
+WorldLighting.gather_method -> gather_method:    enum    
+WorldLighting.indirect_bounces -> indirect_bounces:    int    Number of indirect diffuse light bounces to use for approximate ambient occlusion
+WorldLighting.indirect_factor -> indirect_factor:    float    Factor for how much surrounding objects contribute to light
+WorldLighting.passes -> passes:    int    Number of preprocessing passes to reduce overocclusion (for approximate ambient occlusion)
+WorldLighting.sample_method -> sample_method:    enum    Method for generating shadow samples (for Raytrace)
+WorldLighting.samples -> samples:    int    Amount of ray samples. Higher values give smoother results and longer rendering times
+WorldLighting.threshold -> threshold:    float    Samples below this threshold will be considered fully shadowed/unshadowed and skipped (for Raytrace Adaptive QMC)
+WorldMistSettings.depth -> depth:    float    The distance over which the mist effect fades in
+WorldMistSettings.falloff -> falloff:    enum    Type of transition used to fade mist
+WorldMistSettings.height -> height:    float    Control how much mist density decreases with height
+WorldMistSettings.intensity -> intensity:    float    Intensity of the mist effect
+WorldMistSettings.start -> start:    float    Starting distance of the mist, measured from the camera
+WorldStarsSettings.average_separation -> average_separation:    float    Average distance between any two stars
+WorldStarsSettings.color_randomization -> color_randomization:    float    Randomize star colors
+WorldStarsSettings.min_distance -> min_distance:    float    Minimum distance to the camera for stars
+WorldStarsSettings.size -> size:    float    Average screen dimension of stars
+WorldTextureSlot.blend_factor -> blend_factor:    float    Amount texture affects color progression of the background
+WorldTextureSlot.horizon_factor -> horizon_factor:    float    Amount texture affects color of the horizon
+WorldTextureSlot.object -> object:    pointer    Object to use for mapping with Object texture coordinates
+WorldTextureSlot.texture_coordinates -> texture_coordinates:    enum    Texture coordinates used to map the texture onto the background
+WorldTextureSlot.zenith_down_factor -> zenith_down_factor:    float    Amount texture affects color of the zenith below
+WorldTextureSlot.zenith_up_factor -> zenith_up_factor:    float    Amount texture affects color of the zenith above