rna refactor...

- added a script to merge 2 lists of rna renaming from/to
- merged rna_booleans.txt into rna_properties.txt
- made rna_cleaner.py sort by class.from by default.

4 files changed, 4673 insertions, 4526 deletions

diff --git a/source/blender/makesrna/rna_cleanup/rna_booleans.txt b/source/blender/makesrna/rna_cleanup/rna_booleans.txt
deleted file mode 100644
index 51be6427c88..00000000000
--- a/source/blender/makesrna/rna_cleanup/rna_booleans.txt
+++ /dev/null
@@ -1,1330 +0,0 @@
-ActionActuator.continue_last_frame -> use_continue_last_frame:    boolean    Restore last frame when switching on/off, otherwise play from the start each time
-ActionGroup.expanded -> show_expanded:    boolean    Action Group is expanded
-
-Actuator.expanded -> show_expanded:    boolean    Set actuator expanded in the user interface
-AnimData.nla_enabled -> use_nla:    boolean    NLA stack is evaluated when evaluating this block
-AnimVizMotionPaths.highlight_keyframes -> show_keyframe_highlight:    boolean    Emphasize position of keyframes on Motion Paths
-AnimVizMotionPaths.search_all_action_keyframes -> show_keyframe_action_all:    boolean    For bone motion paths, search whole Action for keyframes instead of in group with matching name only (is slower)
-AnimVizMotionPaths.show_frame_numbers -> show_frame_numbers:    boolean    Show frame numbers on Motion Paths
-AnimVizMotionPaths.show_keyframe_numbers -> show_keyframe_numbers:    boolean    Show frame numbers of Keyframes on Motion Paths
-AnimVizOnionSkinning.only_selected -> show_only_selected:    boolean    For Pose-Mode drawing, only draw ghosts for selected bones
-Area.show_menus -> show_menus:    boolean    Show menus in the header
-AreaLamp.dither -> use_dither:    boolean    Use 2x2 dithering for sampling  (Constant Jittered sampling)
-AreaLamp.jitter -> use_jitter:    boolean    Use noise for sampling  (Constant Jittered sampling)
-AreaLamp.only_shadow -> use_only_shadow:    boolean    Causes light to cast shadows only without illuminating objects
-AreaLamp.shadow_layer -> use_shadow_layer:    boolean    Causes only objects on the same layer to cast shadows
-AreaLamp.umbra -> use_umbra:    boolean    Emphasize parts that are fully shadowed (Constant Jittered sampling)
-Armature.auto_ik -> use_auto_ik:    boolean    Add temporaral IK constraints while grabbing bones in Pose Mode
-Armature.deform_envelope -> use_deform_envelopes:    boolean    Enable Bone Envelopes when defining deform
-Armature.deform_quaternion -> use_deform_preserve_volume:    boolean    Deform rotation interpolation with quaternions
-Armature.deform_vertexgroups -> use_deform_vertex_groups:    boolean    Enable Vertex Groups when defining deform
-Armature.delay_deform -> use_deform_delay:    boolean    Don't deform children when manipulating bones in Pose Mode
-Armature.draw_axes -> show_axes:    boolean    Draw bone axes
-Armature.draw_custom_bone_shapes -> show_bone_custom_shapes:    boolean    Draw bones with their custom shapes
-Armature.draw_group_colors -> show_group_colors:    boolean    Draw bone group colors
-Armature.draw_names -> show_names:    boolean    Draw bone names
-Armature.show_ghost_only_selected -> show_only_ghost_selected:    boolean
-Armature.layer -> layers:    boolean    Armature layer visibility
-Armature.layer_protection -> layers_protected:    boolean    Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo
-Armature.x_axis_mirror -> use_mirror_x:    boolean    Apply changes to matching bone on opposite side of X-Axis
-ArmatureModifier.invert -> invert_vertex_group:    boolean    Invert vertex group influence
-ArmatureModifier.multi_modifier -> use_multi_modifier:    boolean    Use same input as previous modifier, and mix results using overall vgroup
-ArmatureModifier.quaternion -> use_deform_preserve_volume:    boolean    Deform rotation interpolation with quaternions
-ArmatureModifier.use_deform_envelopes -> use_deform_envelopes:    boolean
-ArmatureModifier.use_deform_vertex_groups -> use_deform_vertex_groups:    boolean
-ArrayModifier.add_offset_object -> use_object_offset:    boolean    Add another object's transformation to the total offset
-ArrayModifier.constant_offset -> use_constant_offset:    boolean    Add a constant offset
-ArrayModifier.merge_adjacent_vertices -> use_merge_adjacent_vertices:    boolean    Merge vertices in adjacent duplicates
-ArrayModifier.merge_end_vertices -> use_merge_end_vertices:    boolean    Merge vertices in first and last duplicates
-ArrayModifier.relative_offset -> use_relative_offset:    boolean    Add an offset relative to the object's bounding box
-BackgroundImage.show_expanded -> show_expanded:    boolean    Show the expanded in the user interface
-BevelModifier.only_vertices -> use_only_vertices:    boolean    Bevel verts/corners, not edges
-
-BoidRule.in_air -> use_in_air:    boolean    Use rule when boid is flying
-BoidRule.on_land -> use_on_land:    boolean    Use rule when boid is on land
-BoidRuleAvoid.predict -> use_predict:    boolean    Predict target movement
-BoidRuleAvoidCollision.boids -> use_avoid:    boolean    Avoid collision with other boids
-BoidRuleAvoidCollision.deflectors -> use_avoid_collision:    boolean    Avoid collision with deflector objects
-BoidRuleFollowLeader.line -> use_line:    boolean    Follow leader in a line
-BoidRuleGoal.predict -> use_predict:    boolean    Predict target movement
-BoidSettings.allow_climb -> use_climb:    boolean    Allow boids to climb goal objects
-BoidSettings.allow_flight -> use_flight:    boolean    Allow boids to move in air
-BoidSettings.allow_land -> use_land:    boolean    Allow boids to move on land
-Bone.connected -> use_connect:    boolean, (read-only)    When bone has a parent, bone's head is struck to the parent's tail
-Bone.cyclic_offset -> use_cyclic_offset:    boolean    When bone doesn't have a parent, it receives cyclic offset effects
-Bone.deform -> use_deform:    boolean    Bone does not deform any geometry
-Bone.draw_wire -> show_wire:    boolean    Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes
-
-Bone.hinge -> use_hinge:    boolean    Bone inherits rotation or scale from parent bone
-Bone.inherit_scale -> use_inherit_scale:    boolean    Bone inherits scaling from parent bone
-Bone.layer -> layers:    boolean    Layers bone exists in
-Bone.local_location -> use_local_location:    boolean    Bone location is set in local space
-Bone.multiply_vertexgroup_with_envelope -> use_envelope_multiply:    boolean    When deforming bone, multiply effects of Vertex Group weights with Envelope influence
-BooleanProperty.default -> default:    boolean, (read-only)    Default value for this number
-BooleanProperty.default_array -> default_array:    boolean, (read-only)    Default value for this array
-Brush.use_accumulate -> use_accumulate:    boolean    Accumulate stroke dabs on top of each other
-Brush.use_airbrush -> use_airbrush:    boolean    Keep applying paint effect while holding mouse (spray)
-Brush.use_alpha -> use_alpha:    boolean    When this is disabled, lock alpha while painting
-Brush.use_anchor -> use_anchor:    boolean    Keep the brush anchored to the initial location
-Brush.use_jitter_pressure -> use_pressure_jitter:    boolean    Enable tablet pressure sensitivity for jitter
-Brush.use_persistent -> use_persistent:    boolean    Sculpts on a persistent layer of the mesh
-Brush.use_rake -> use_rake:    boolean    Rotate the brush texture to match the stroke direction
-Brush.use_size_pressure -> use_pressure_size:    boolean    Enable tablet pressure sensitivity for size
-Brush.use_smooth_stroke -> use_smooth_stroke:    boolean    Brush lags behind mouse and follows a smoother path
-Brush.use_space -> use_space:    boolean    Limit brush application to the distance specified by spacing
-Brush.use_spacing_pressure -> use_pressure_spacing:    boolean    Enable tablet pressure sensitivity for spacing
-Brush.use_strength_pressure -> use_pressure_strength:    boolean    Enable tablet pressure sensitivity for strength
-Brush.use_wrap -> use_wrap:    boolean    Enable torus wrapping while painting
-BuildModifier.randomize -> use_random_order:    boolean    Randomize the faces or edges during build
-Camera.panorama -> use_panorama:    boolean    Render the scene with a cylindrical camera for pseudo-fisheye lens effects
-Camera.show_limits -> show_limits:    boolean    Draw the clipping range and focus point on the camera
-Camera.show_mist -> show_mist:    boolean    Draw a line from the Camera to indicate the mist area
-Camera.show_name -> show_name:    boolean    Show the active Camera's name in Camera view
-Camera.show_passepartout -> show_passepartout:    boolean    Show a darkened overlay outside the image area in Camera view
-Camera.show_title_safe -> show_title_safe:    boolean    Show indicators for the title safe zone in Camera view
-CastModifier.from_radius -> use_radius_as_size:    boolean    Use radius as size of projection shape (0 = auto)
-CastModifier.use_transform -> use_transform:    boolean    Use object transform to control projection shape
-CastModifier.x -> use_x:    boolean
-CastModifier.y -> use_y:    boolean
-CastModifier.z -> use_z:    boolean
-ChildOfConstraint.use_location_x -> use_location_x:    boolean    Use X Location of Parent
-ChildOfConstraint.use_location_y -> use_location_y:    boolean    Use Y Location of Parent
-ChildOfConstraint.use_location_z -> use_location_z:    boolean    Use Z Location of Parent
-ChildOfConstraint.use_rotation_x -> use_rotation_x:    boolean    Use X Rotation of Parent
-ChildOfConstraint.use_rotation_y -> use_rotation_y:    boolean    Use Y Rotation of Parent
-ChildOfConstraint.use_rotation_z -> use_rotation_z:    boolean    Use Z Rotation of Parent
-ChildOfConstraint.use_scale_x -> use_scale_x:    boolean    Use X Scale of Parent
-ChildOfConstraint.use_scale_y -> use_scale_y:    boolean    Use Y Scale of Parent
-ChildOfConstraint.use_scale_z -> use_scale_z:    boolean    Use Z Scale of Parent
-ClampToConstraint.cyclic -> use_cyclic:    boolean    Treat curve as cyclic curve (no clamping to curve bounding box
-ClothCollisionSettings.enable_collision -> use_collision:    boolean    Enable collisions with other objects
-ClothCollisionSettings.enable_self_collision -> use_self_collision:    boolean    Enable self collisions
-ClothSettings.pin_cloth -> use_pin_cloth:    boolean    Enable pinning of cloth vertices to other objects/positions
-ClothSettings.stiffness_scaling -> use_stiffness_scale:    boolean    If enabled, stiffness can be scaled along a weight painted vertex group
-CollisionSensor.collision_type -> use_material:    boolean    Use material instead of property
-CollisionSensor.pulse -> use_pulse:    boolean    Changes to the set of colliding objects generates pulse
-CollisionSettings.enabled -> use:    boolean    Enable this objects as a collider for physics systems
-CollisionSettings.kill_particles -> use_particle_kill:    boolean    Kill colliding particles
-CompositorNodeAlphaOver.convert_premul -> use_premultiply:    boolean
-CompositorNodeBlur.bokeh -> use_bokeh:    boolean
-CompositorNodeBlur.gamma -> use_gamma_correction:    boolean
-CompositorNodeBlur.relative -> use_relative:    boolean
-CompositorNodeColorSpill.unspill -> use_unspill:    boolean    Compensate all channels (diffenrently) by hand
-CompositorNodeCrop.crop_size -> use_crop_size:    boolean    Whether to crop the size of the input image
-CompositorNodeDBlur.wrap -> use_wrap:    boolean
-CompositorNodeDefocus.gamma_correction -> use_gamma_correction:    boolean    Enable gamma correction before and after main process
-CompositorNodeDefocus.preview -> use_preview:    boolean    Enable sampling mode, useful for preview when using low samplecounts
-CompositorNodeDefocus.use_zbuffer -> use_zbuffer:    boolean    Disable when using an image as input instead of actual zbuffer (auto enabled if node not image based, eg. time node)
-CompositorNodeGlare.rotate_45 -> use_rotate_45:    boolean    Simple star filter: add 45 degree rotation offset
-CompositorNodeImage.auto_refresh -> use_auto_refresh:    boolean
-CompositorNodeImage.cyclic -> use_cyclic:    boolean
-CompositorNodeInvert.alpha -> invert_alpha:    boolean
-CompositorNodeInvert.rgb -> invert_rgb:    boolean
-CompositorNodeLensdist.fit -> use_fit:    boolean    For positive distortion factor only: scale image such that black areas are not visible
-CompositorNodeLensdist.jitter -> use_jitter:    boolean    Enable/disable jittering; faster, but also noisier
-CompositorNodeLensdist.projector -> use_projector:    boolean    Enable/disable projector mode. Effect is applied in horizontal direction only
-CompositorNodeMapValue.use_max -> use_max:    boolean
-CompositorNodeMapValue.use_min -> use_min:    boolean
-CompositorNodeMixRGB.alpha -> use_alpha:    boolean    Include alpha of second input in this operation
-CompositorNodeOutputFile.exr_half -> use_exr_half:    boolean
-CompositorNodeVecBlur.curved -> use_curved:    boolean    Interpolate between frames in a bezier curve, rather than linearly
-Constraint.active -> active:    boolean    Constraint is the one being edited
-Constraint.disabled -> is_valid:    boolean, (read-only)    Constraint has invalid settings and will not be evaluated
-Constraint.expanded -> show_expanded:    boolean    Constraint's panel is expanded in UI
-Constraint.proxy_local -> is_proxy_local:    boolean    Constraint was added in this proxy instance (i.e. did not belong to source Armature)
-ConstraintActuator.detect_material -> use_material_detect:    boolean    Detect material instead of property
-ConstraintActuator.fh_normal -> use_fh_normal:    boolean    Add a horizontal spring force on slopes
-ConstraintActuator.fh_paralel_axis -> use_fh_paralel_axis:    boolean    Keep object axis parallel to normal
-ConstraintActuator.force_distance -> use_force_distance:    boolean    Force distance of object to point of impact of ray
-ConstraintActuator.local -> use_local:    boolean    Set ray along object's axis or global axis
-ConstraintActuator.normal -> use_normal:    boolean    Set object axis along (local axis) or parallel (global axis) to the normal at hit position
-ConstraintActuator.persistent -> use_persistent:    boolean    Persistent actuator: stays active even if ray does not reach target
-ControlFluidSettings.active -> use:    boolean    Object contributes to the fluid simulation
-ControlFluidSettings.reverse_frames -> use_reverse_frames:    boolean    Reverse control object movement
-Controller.expanded -> show_expanded:    boolean    Set controller expanded in the user interface
-Controller.priority -> use_priority:    boolean    Mark controller for execution before all non-marked controllers (good for startup scripts)
-Controller.state -> states:    boolean, (read-only)    Set Controller state index (1 to 30)
-CopyLocationConstraint.invert_x -> invert_x:    boolean    Invert the X location
-CopyLocationConstraint.invert_y -> invert_y:    boolean    Invert the Y location
-CopyLocationConstraint.invert_z -> invert_z:    boolean    Invert the Z location
-CopyLocationConstraint.use_offset -> use_offset:    boolean    Add original location into copied location
-CopyLocationConstraint.use_x -> use_x:    boolean    Copy the target's X location
-CopyLocationConstraint.use_y -> use_y:    boolean    Copy the target's Y location
-CopyLocationConstraint.use_z -> use_z:    boolean    Copy the target's Z location
-CopyRotationConstraint.invert_x -> invert_x:    boolean    Invert the X rotation
-CopyRotationConstraint.invert_y -> invert_y:    boolean    Invert the Y rotation
-CopyRotationConstraint.invert_z -> invert_z:    boolean    Invert the Z rotation
-CopyRotationConstraint.use_offset -> use_offset:    boolean    Add original rotation into copied rotation
-CopyRotationConstraint.use_x -> use_x:    boolean    Copy the target's X rotation
-CopyRotationConstraint.use_y -> use_y:    boolean    Copy the target's Y rotation
-CopyRotationConstraint.use_z -> use_z:    boolean    Copy the target's Z rotation
-CopyScaleConstraint.use_offset -> use_offset:    boolean    Add original scale into copied scale
-CopyScaleConstraint.use_x -> use_x:    boolean    Copy the target's X scale
-CopyScaleConstraint.use_y -> use_y:    boolean    Copy the target's Y scale
-CopyScaleConstraint.use_z -> use_z:    boolean    Copy the target's Z scale
-Curve.auto_texspace -> use_auto_texspace:    boolean    Adjusts active object's texture space automatically when transforming object
-Curve.back -> use_fill_back:    boolean    Draw filled back for extruded/beveled curves
-Curve.draw_handles -> show_handles:    boolean    Display bezier handles in editmode
-Curve.draw_normals -> show_normals:    boolean    Display 3D curve normals in editmode
-Curve.front -> use_fill_front:    boolean    Draw filled front for extruded/beveled curves
-Curve.map_along_length -> use_map_along_length:    boolean    Generate texture mapping coordinates following the curve direction, rather than the local bounding box
-Curve.use_deform_fill -> use_fill_deform:    boolean    Fill curve after applying deformation
-Curve.use_path -> use_path:    boolean    Enable the curve to become a translation path
-Curve.use_path_follow -> use_path_follow:    boolean    Make curve path children to rotate along the path
-Curve.use_radius -> use_radius:    boolean    Option for paths: apply the curve radius with path following it and deforming
-Curve.use_stretch -> use_stretch:    boolean    Option for curve-deform: makes deformed child to stretch along entire path
-Curve.use_time_offset -> use_time_offset:    boolean    Children will use Time Offset value as path distance offset
-
-CurveMapping.clip -> use_clip:    boolean    Force the curve view to fit a defined boundary
-DelaySensor.repeat -> use_repeat:    boolean    Toggle repeat option. If selected, the sensor restarts after Delay+Dur logic tics
-DomainFluidSettings.generate_speed_vectors -> use_speed_vectors:    boolean    Generate speed vectors for vector blur
-DomainFluidSettings.override_time -> use_time_override:    boolean    Use a custom start and end time (in seconds) instead of the scene's timeline
-DomainFluidSettings.reverse_frames -> use_reverse_frames:    boolean    Reverse fluid frames
-NEGATE * DopeSheet.collapse_summary -> show_expanded_summary:    boolean    Collapse summary when shown, so all other channels get hidden. (DopeSheet Editors Only)
-DopeSheet.display_armature -> show_armatures:    boolean    Include visualization of Armature related Animation data
-DopeSheet.display_camera -> show_cameras:    boolean    Include visualization of Camera related Animation data
-DopeSheet.display_curve -> show_curves:    boolean    Include visualization of Curve related Animation data
-DopeSheet.display_lamp -> show_lamps:    boolean    Include visualization of Lamp related Animation data
-DopeSheet.display_material -> show_materials:    boolean    Include visualization of Material related Animation data
-DopeSheet.display_mesh -> show_meshes:    boolean    Include visualization of Mesh related Animation data
-DopeSheet.display_metaball -> show_metaballs:    boolean    Include visualization of Metaball related Animation data
-DopeSheet.display_node -> show_nodes:    boolean    Include visualization of Node related Animation data
-DopeSheet.display_particle -> show_particles:    boolean    Include visualization of Particle related Animation data
-DopeSheet.display_scene -> show_scenes:    boolean    Include visualization of Scene related Animation data
-DopeSheet.display_shapekeys -> show_shapekeys:    boolean    Include visualization of ShapeKey related Animation data
-DopeSheet.display_summary -> show_summary:    boolean    Display an additional 'summary' line. (DopeSheet Editors only)
-DopeSheet.display_texture -> show_textures:    boolean    Include visualization of Texture related Animation data
-DopeSheet.display_transforms -> show_transforms:    boolean    Include visualization of Object-level Animation data (mostly Transforms)
-DopeSheet.display_world -> show_worlds:    boolean    Include visualization of World related Animation data
-DopeSheet.include_missing_nla -> show_missing_nla:    boolean    Include Animation Data blocks with no NLA data. (NLA Editor only)
-DopeSheet.only_group_objects -> show_only_group_objects:    boolean    Only include channels from Objects in the specified Group
-DopeSheet.only_selected -> show_only_selected:    boolean    Only include channels relating to selected objects and data
-Driver.invalid -> is_valid:    boolean    Driver could not be evaluated in past, so should be skipped
-Driver.show_debug_info -> show_debug_info:    boolean    Show intermediate values for the driver calculations to allow debugging of drivers
-DriverTarget.use_local_space_transforms -> use_local_space_transform:    boolean    Use transforms in Local Space (as opposed to the worldspace default)
-EdgeSplitModifier.use_edge_angle -> use_edge_angle:    boolean    Split edges with high angle between faces
-EdgeSplitModifier.use_sharp -> use_edge_sharp:    boolean    Split edges that are marked as sharp
-EditBone.connected -> use_connect:    boolean    When bone has a parent, bone's head is struck to the parent's tail
-EditBone.cyclic_offset -> use_cyclic_offset:    boolean    When bone doesn't have a parent, it receives cyclic offset effects
-EditBone.deform -> use_deform:    boolean    Bone does not deform any geometry
-EditBone.draw_wire -> show_wire:    boolean    Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes
-
-EditBone.hinge -> use_hinge:    boolean    Bone inherits rotation or scale from parent bone
-EditBone.inherit_scale -> use_inherit_scale:    boolean    Bone inherits scaling from parent bone
-EditBone.layer -> layers:    boolean    Layers bone exists in
-EditBone.local_location -> use_local_location:    boolean    Bone location is set in local space
-EditBone.multiply_vertexgroup_with_envelope -> use_envelope_multiply:    boolean    When deforming bone, multiply effects of Vertex Group weights with Envelope influence
-
-EditObjectActuator.enable_3d_tracking -> use_3d_tracking:    boolean    Enable 3D tracking
-EditObjectActuator.local_angular_velocity -> use_local_angular_velocity:    boolean    Apply the rotation locally
-EditObjectActuator.local_linear_velocity -> use_local_linear_velocity:    boolean    Apply the transformation locally
-EditObjectActuator.replace_display_mesh -> use_replace_display_mesh:    boolean    Replace the display mesh
-EditObjectActuator.replace_physics_mesh -> use_replace_physics_mesh:    boolean    Replace the physics mesh (triangle bounds only - compound shapes not supported)
-EffectSequence.convert_float -> use_float:    boolean    Convert input to float data
-EffectSequence.de_interlace -> use_deinterlace:    boolean    For video movies to remove fields
-EffectSequence.flip_x -> use_flip_x:    boolean    Flip on the X axis
-EffectSequence.flip_y -> use_flip_y:    boolean    Flip on the Y axis
-EffectSequence.premultiply -> use_premultiply:    boolean    Convert RGB from key alpha to premultiplied alpha
-EffectSequence.proxy_custom_directory -> use_proxy_custom_directory:    boolean    Use a custom directory to store data
-EffectSequence.proxy_custom_file -> use_proxy_custom_file:    boolean    Use a custom file to read proxy data from
-EffectSequence.reverse_frames -> use_reverse_frames:    boolean    Reverse frame order
-EffectSequence.use_color_balance -> use_color_balance:    boolean    (3-Way color correction) on input
-EffectSequence.use_crop -> use_crop:    boolean    Crop image before processing
-EffectSequence.use_proxy -> use_proxy:    boolean    Use a preview proxy for this strip
-EffectSequence.use_translation -> use_translation:    boolean    Translate image before processing
-EffectorWeights.do_growing_hair -> apply_to_hair_growing:    boolean    Use force fields when growing hair
-EnvironmentMap.ignore_layers -> layers_ignore:    boolean    Hide objects on these layers when generating the Environment Map
-EnvironmentMapTexture.use_filter_size_min -> use_minimum_filter_size:    boolean    Use Filter Size as a minimal filter value in pixels
-EnvironmentMapTexture.mipmap -> use_mipmap:    boolean    Uses auto-generated MIP maps for the image
-EnvironmentMapTexture.mipmap_gauss -> use_mipmap_gauss:    boolean    Uses Gauss filter to sample down MIP maps
-Event.alt -> is_pressed_alt:    boolean, (read-only)    True when the Alt/Option key is held
-Event.ctrl -> is_pressed_ctrl:    boolean, (read-only)    True when the Ctrl key is held
-Event.oskey -> is_pressed_cmd:    boolean, (read-only)    True when the Cmd key is held
-Event.shift -> is_pressed_shift:    boolean, (read-only)    True when the Shift key is held
-ExplodeModifier.alive -> show_alive:    boolean    Show mesh when particles are alive
-ExplodeModifier.dead -> show_dead:    boolean    Show mesh when particles are dead
-ExplodeModifier.size -> use_size:    boolean    Use particle size for the shrapnel
-ExplodeModifier.split_edges -> use_edge_split:    boolean    Split face edges for nicer shrapnel
-ExplodeModifier.unborn -> show_unborn:    boolean    Show mesh when particles are unborn
-FCurve.auto_clamped_handles -> use_auto_handle_clamp:    boolean    All auto-handles for F-Curve are clamped
-FModifier.active -> active:    boolean    F-Curve Modifier is the one being edited
-NEGATE * FModifier.disabled -> use:    boolean, (read-only)    F-Curve Modifier has invalid settings and will not be evaluated
-FModifier.expanded -> show_expanded:    boolean    F-Curve Modifier's panel is expanded in UI
-FModifierFunctionGenerator.additive -> use_additive:    boolean    Values generated by this modifier are applied on top of the existing values instead of overwriting them
-FModifierGenerator.additive -> use_additive:    boolean    Values generated by this modifier are applied on top of the existing values instead of overwriting them
-FModifierLimits.use_maximum_x -> use_max_x:    boolean    Use the maximum X value
-FModifierLimits.use_maximum_y -> use_max_y:    boolean    Use the maximum Y value
-FModifierLimits.use_minimum_x -> use_min_x:    boolean    Use the minimum X value
-FModifierLimits.use_minimum_y -> use_min_y:    boolean    Use the minimum Y value
-FModifierStepped.use_frame_end -> use_frame_end:    boolean    Restrict modifier to only act before its 'end' frame
-FModifierStepped.use_frame_start -> use_frame_start:    boolean    Restrict modifier to only act after its 'start' frame
-FcurveActuator.add -> use_add:    boolean    F-Curve is added to the current loc/rot/scale in global or local coordinate according to Local flag
-FcurveActuator.child -> apply_to_children:    boolean    Update F-Curve on all children Objects as well
-FcurveActuator.force -> use_force:    boolean    Apply F-Curve as a global or local force depending on the local option (dynamic objects only)
-FcurveActuator.local -> use_local:    boolean    Let the F-Curve act in local coordinates, used in Force and Add mode
-FieldSettings.do_absorption -> use_absorption:    boolean    Force gets absorbed by collision objects
-FieldSettings.do_location -> apply_to_location:    boolean    Effect particles' location
-FieldSettings.do_rotation -> apply_to_rotation:    boolean    Effect particles' dynamic rotation
-FieldSettings.force_2d -> use_2d_force:    boolean    Apply force only in 2d
-FieldSettings.global_coordinates -> use_global_coordinates:    boolean    Use effector/global coordinates for turbulence
-FieldSettings.guide_path_add -> use_guide_path_add:    boolean    Based on distance/falloff it adds a portion of the entire path
-FieldSettings.multiple_springs -> use_multiple_springs:    boolean    Every point is effected by multiple springs
-FieldSettings.root_coordinates -> use_root_coordinates:    boolean    Texture coordinates from root particle locations
-FieldSettings.use_coordinates -> use_object_coordinates:    boolean    Use object/global coordinates for texture
-FieldSettings.use_guide_path_weight -> use_guide_path_weight:    boolean    Use curve weights to influence the particle influence along the curve
-FieldSettings.use_max_distance -> use_max_distance:    boolean    Use a maximum distance for the field to work
-FieldSettings.use_min_distance -> use_min_distance:    boolean    Use a minimum distance for the field's fall-off
-FieldSettings.use_radial_max -> use_radial_max:    boolean    Use a maximum radial distance for the field to work
-FieldSettings.use_radial_min -> use_radial_min:    boolean    Use a minimum radial distance for the field's fall-off
-FileSelectParams.do_filter -> use_filter:    boolean    Enable filtering of files
-FileSelectParams.filter_blender -> use_filter_blender:    boolean    Show .blend files
-FileSelectParams.filter_folder -> use_filter_folder:    boolean    Show folders
-FileSelectParams.filter_font -> use_filter_font:    boolean    Show font files
-FileSelectParams.filter_image -> use_filter_image:    boolean    Show image files
-FileSelectParams.filter_movie -> use_filter_movie:    boolean    Show movie files
-FileSelectParams.filter_script -> use_filter_script:    boolean    Show script files
-FileSelectParams.filter_sound -> use_filter_sound:    boolean    Show sound files
-FileSelectParams.filter_text -> use_filter_text:    boolean    Show text files
-NEGATE *  FileSelectParams.hide_dot -> show_hidden:    boolean    Hide hidden dot files
-Filter2DActuator.enable_motion_blur -> use_motion_blur:    boolean    Enable/Disable Motion Blur
-FloorConstraint.sticky -> use_sticky:    boolean    Immobilize object while constrained
-FloorConstraint.use_rotation -> use_rotation:    boolean    Use the target's rotation to determine floor
-FluidFluidSettings.active -> use:    boolean    Object contributes to the fluid simulation
-FluidFluidSettings.export_animated_mesh -> use_animated_mesh:    boolean    Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it
-FollowPathConstraint.use_curve_follow -> use_curve_follow:    boolean    Object will follow the heading and banking of the curve
-FollowPathConstraint.use_curve_radius -> use_curve_radius:    boolean    Objects scale by the curve radius
-FollowPathConstraint.use_fixed_position -> use_fixed_location:    boolean    Object will stay locked to a single point somewhere along the length of the curve regardless of time
-Function.registered -> is_registered:    boolean, (read-only)    Function is registered as callback as part of type registration
-Function.registered_optional -> is_registered_optional:    boolean, (read-only)    Function is optionally registered as callback part of type registration
-GPencilFrame.paint_lock -> is_edited:    boolean    Frame is being edited (painted on)
-GPencilLayer.active -> active:    boolean    Set active layer for editing
-GPencilLayer.frame_lock -> lock_frame:    boolean    Lock current frame displayed by layer
-GPencilLayer.hide -> hide:    boolean    Set layer Visibility
-
-GPencilLayer.show_points -> show_points:    boolean    Draw the points which make up the strokes (for debugging purposes)
-GPencilLayer.use_onion_skinning -> use_onion_skinning:    boolean    Ghost frames on either side of frame
-GameBooleanProperty.value -> value:    boolean    Property value
-GameObjectSettings.actor -> use_actor:    boolean    Object is detected by the Near and Radar sensor
-GameObjectSettings.all_states -> use_all_states:    boolean    Set all state bits
-GameObjectSettings.anisotropic_friction -> use_anisotropic_friction:    boolean    Enable anisotropic friction
-GameObjectSettings.collision_compound -> use_collision_compound:    boolean    Add children to form a compound collision object
-GameObjectSettings.debug_state -> show_debug_state:    boolean    Print state debug info in the game engine
-GameObjectSettings.ghost -> use_ghost:    boolean    Object does not restitute collisions, like a ghost
-GameObjectSettings.initial_state -> states_initial:    boolean    Initial state when the game starts
-GameObjectSettings.lock_x_axis -> lock_location_x:    boolean    Disable simulation of linear motion along the X axis
-GameObjectSettings.lock_x_rot_axis -> lock_rotation_x:    boolean    Disable simulation of angular  motion along the X axis
-GameObjectSettings.lock_y_axis -> lock_location_y:    boolean    Disable simulation of linear motion along the Y axis
-GameObjectSettings.lock_y_rot_axis -> lock_rotation_y:    boolean    Disable simulation of angular  motion along the Y axis
-GameObjectSettings.lock_z_axis -> lock_location_z:    boolean    Disable simulation of linear motion along the Z axis
-GameObjectSettings.lock_z_rot_axis -> lock_rotation_z:    boolean    Disable simulation of angular  motion along the Z axis
-GameObjectSettings.material_physics -> use_material_physics:    boolean    Use physics settings in materials
-NEGATE * GameObjectSettings.no_sleeping -> use_sleep:    boolean    Disable auto (de)activation in physics simulation
-GameObjectSettings.rotate_from_normal -> use_rotate_from_normal:    boolean    Use face normal to rotate object, so that it points away from the surface
-GameObjectSettings.show_actuators -> show_actuators:    boolean    Shows actuators for this object in the user interface
-GameObjectSettings.show_controllers -> show_controllers:    boolean    Shows controllers for this object in the user interface
-GameObjectSettings.show_sensors -> show_sensors:    boolean    Shows sensors for this object in the user interface
-GameObjectSettings.show_state_panel -> show_state_panel:    boolean    Show state panel
-GameObjectSettings.use_activity_culling -> use_activity_culling:    boolean    Disable simulation of angular  motion along the Z axis
-GameObjectSettings.use_collision_bounds -> use_collision_bounds:    boolean    Specify a collision bounds type other than the default
-GameObjectSettings.used_state -> states_used:    boolean, (read-only)    States which are being used by controllers
-GameObjectSettings.visible_state -> states_visible:    boolean    State determining which controllers are displayed
-GameProperty.debug -> show_debug:    boolean    Print debug information for this property
-GameSoftBodySettings.bending_const -> use_bending_constraints:    boolean    Enable bending constraints
-GameSoftBodySettings.cluster_rigid_to_softbody -> use_cluster_rigid_to_softbody:    boolean    Enable cluster collision between soft and rigid body
-GameSoftBodySettings.cluster_soft_to_softbody -> use_cluster_soft_to_softbody:    boolean    Enable cluster collision between soft and soft body
-GameSoftBodySettings.shape_match -> use_shape_match:    boolean    Enable soft body shape matching goal
-GlowSequence.only_boost -> use_only_boost:    boolean    Show the glow buffer only
-GreasePencil.use_stroke_endpoints -> use_stroke_endpoints:    boolean    Only use the first and last parts of the stroke for snapping
-Group.layer -> layers:    boolean    Layers visible when this groups is instanced as a dupli
-ID.fake_user -> use_fake_user:    boolean    Saves this datablock even if it has no users
-ID.tag -> tag:    boolean    Tools can use this to tag data, (initial state is undefined)
-Image.animated -> use_animation:    boolean    Use as animated texture in the game engine
-Image.clamp_x -> use_clamp_x:    boolean    Disable texture repeating horizontally
-Image.clamp_y -> use_clamp_y:    boolean    Disable texture repeating vertically
-Image.dirty -> is_dirty:    boolean, (read-only)    Image has changed and is not saved
-Image.fields -> use_fields:    boolean    Use fields of the image
-Image.has_data -> has_data:    boolean, (read-only)    True if this image has data
-Image.premultiply -> use_premultiply:    boolean    Convert RGB from key alpha to premultiplied alpha
-Image.tiles -> use_tiles:    boolean    Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)
-ImagePaint.invert_stencil -> invert_stencil:    boolean    Invert the stencil layer
-ImagePaint.show_brush -> show_brush:    boolean    Enables brush shape while not drawing
-ImagePaint.show_brush_draw -> show_brush_draw:    boolean    Enables brush shape while drawing
-ImagePaint.use_backface_cull -> use_backface_culling:    boolean    Ignore faces pointing away from the view (faster)
-ImagePaint.use_clone_layer -> use_clone_layer:    boolean    Use another UV layer as clone source, otherwise use 3D the cursor as the source
-ImagePaint.use_normal_falloff -> use_normal_falloff:    boolean    Paint most on faces pointing towards the view
-ImagePaint.use_occlude -> use_occlude:    boolean    Only paint onto the faces directly under the brush (slower)
-ImagePaint.use_projection -> use_projection:    boolean    Use projection painting for improved consistency in the brush strokes
-ImagePaint.use_stencil_layer -> use_stencil_layer:    boolean    Set the mask layer from the UV layer buttons
-ImageSequence.convert_float -> use_float:    boolean    Convert input to float data
-ImageSequence.de_interlace -> use_deinterlace:    boolean    For video movies to remove fields
-ImageSequence.flip_x -> use_flip_x:    boolean    Flip on the X axis
-ImageSequence.flip_y -> use_flip_y:    boolean    Flip on the Y axis
-ImageSequence.premultiply -> use_premultiply:    boolean    Convert RGB from key alpha to premultiplied alpha
-ImageSequence.proxy_custom_directory -> use_proxy_custom_directory:    boolean    Use a custom directory to store data
-ImageSequence.proxy_custom_file -> use_proxy_custom_file:    boolean    Use a custom file to read proxy data from
-ImageSequence.reverse_frames -> use_reverse_frames:    boolean    Reverse frame order
-ImageSequence.use_color_balance -> use_color_balance:    boolean    (3-Way color correction) on input
-ImageSequence.use_crop -> use_crop:    boolean    Crop image before processing
-ImageSequence.use_proxy -> use_proxy:    boolean    Use a preview proxy for this strip
-ImageSequence.use_translation -> use_translation:    boolean    Translate image before processing
-ImageTexture.calculate_alpha -> use_calculate_alpha:    boolean    Calculates an alpha channel based on RGB values in the image
-ImageTexture.checker_even -> use_checker_even:    boolean    Sets even checker tiles
-ImageTexture.checker_odd -> use_checker_odd:    boolean    Sets odd checker tiles
-ImageTexture.filter_size_minimum -> use_minimum_filter_size:    boolean    Use Filter Size as a minimal filter value in pixels
-ImageTexture.flip_axis -> use_flip_axis:    boolean    Flips the texture's X and Y axis
-ImageTexture.interpolation -> use_interpolation:    boolean    Interpolates pixels using Area filter
-ImageTexture.invert_alpha -> invert_alpha:    boolean    Inverts all the alpha values in the image
-ImageTexture.mipmap -> use_mipmap:    boolean    Uses auto-generated MIP maps for the image
-ImageTexture.mipmap_gauss -> use_mipmap_gauss:    boolean    Uses Gauss filter to sample down MIP maps
-ImageTexture.mirror_x -> use_mirror_x:    boolean    Mirrors the image repetition on the X direction
-ImageTexture.mirror_y -> use_mirror_y:    boolean    Mirrors the image repetition on the Y direction
-ImageTexture.normal_map -> use_normal_map:    boolean    Uses image RGB values for normal mapping
-ImageTexture.use_alpha -> use_alpha:    boolean    Uses the alpha channel information in the image
-ImageUser.auto_refresh -> use_auto_refresh:    boolean    Always refresh image on frame changes
-ImageUser.cyclic -> use_cyclic:    boolean    Cycle the images in the movie
-InflowFluidSettings.active -> use:    boolean    Object contributes to the fluid simulation
-InflowFluidSettings.export_animated_mesh -> use_animated_mesh:    boolean    Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it
-InflowFluidSettings.local_coordinates -> use_local_coordinates:    boolean    Use local coordinates for inflow. (e.g. for rotating objects)
-Itasc.auto_step -> use_auto_step:    boolean    Automatically determine the optimal number of steps for best performance/accuracy trade off
-JoystickSensor.all_events -> use_all_events:    boolean    Triggered by all events on this joysticks current type (axis/button/hat)
-Key.relative -> use_relative:    boolean    Makes shape keys relative
-KeyConfig.user_defined -> is_user_defined:    boolean, (read-only)    Indicates that a keyconfig was defined by the user
-KeyMap.children_expanded -> show_expanded_children:    boolean    Children expanded in the user interface
-KeyMap.items_expanded -> show_expanded_items:    boolean    Expanded in the user interface
-KeyMap.modal -> is_modal:    boolean, (read-only)    Indicates that a keymap is used for translate modal events for an operator
-KeyMap.user_defined -> is_user_defined:    boolean    Keymap is defined by the user
-KeyMapItem.active -> active:    boolean    Activate or deactivate item
-KeyMapItem.alt -> pressed_alt:    boolean    Alt key pressed
-KeyMapItem.any -> pressed_any:    boolean    Any modifier keys pressed
-KeyMapItem.ctrl -> pressed_ctrl:    boolean    Control key pressed
-KeyMapItem.expanded -> show_expanded:    boolean    Show key map event and property details in the user interface
-KeyMapItem.oskey -> pressed_cmd:    boolean    Operating system key pressed
-KeyMapItem.shift -> pressed_shift:    boolean    Shift key pressed
-KeyboardSensor.all_keys -> use_all_keys:    boolean    Trigger this sensor on any keystroke
-KeyingSet.absolute -> use_absolute:    boolean    Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)
-KeyingSet.insertkey_needed -> use_insertkey_needed:    boolean    Only insert keyframes where they're needed in the relevant F-Curves
-KeyingSet.insertkey_visual -> use_insertkey_visual:    boolean    Insert keyframes based on 'visual transforms'
-KeyingSet.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:    boolean    Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis
-KeyingSetInfo.insertkey_needed -> use_insertkey_needed:    boolean    Only insert keyframes where they're needed in the relevant F-Curves
-KeyingSetInfo.insertkey_visual -> use_insertkey_visual:    boolean    Insert keyframes based on 'visual transforms'
-KeyingSetInfo.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:    boolean    Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis
-KeyingSetPath.entire_array -> use_entire_array:    boolean    When an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used
-KeyingSetPath.insertkey_needed -> use_insertkey_needed:    boolean    Only insert keyframes where they're needed in the relevant F-Curves
-KeyingSetPath.insertkey_visual -> use_insertkey_visual:    boolean    Insert keyframes based on 'visual transforms'
-KeyingSetPath.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:    boolean    Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis
-KinematicConstraint.pos_lock_x -> lock_location_x:    boolean    Constraint position along X axis
-KinematicConstraint.pos_lock_y -> lock_location_y:    boolean    Constraint position along Y axis
-KinematicConstraint.pos_lock_z -> lock_location_z:    boolean    Constraint position along Z axis
-KinematicConstraint.rot_lock_x -> lock_rotation_x:    boolean    Constraint rotation along X axis
-KinematicConstraint.rot_lock_y -> lock_rotation_y:    boolean    Constraint rotation along Y axis
-KinematicConstraint.rot_lock_z -> lock_rotation_z:    boolean    Constraint rotation along Z axis
-KinematicConstraint.use_position -> use_location:    boolean    Chain follows position of target
-KinematicConstraint.use_rotation -> use_rotation:    boolean    Chain follows rotation of target
-KinematicConstraint.use_stretch -> use_stretch:    boolean    Enable IK Stretching
-KinematicConstraint.use_tail -> use_tail:    boolean    Include bone's tail as last element in chain
-KinematicConstraint.use_target -> use_target:    boolean    Disable for targetless IK
-Lamp.diffuse -> use_diffuse:    boolean    Lamp does diffuse shading
-Lamp.layer -> use_own_layer:    boolean    Illuminates objects only on the same layer the lamp is on
-Lamp.negative -> use_negative:    boolean    Lamp casts negative light
-Lamp.specular -> use_specular:    boolean    Lamp creates specular highlights
-LampSkySettings.use_atmosphere -> use_atmosphere:    boolean    Apply sun effect on atmosphere
-LampSkySettings.use_sky -> use_sky:    boolean    Apply sun effect on sky
-LampTextureSlot.map_color -> use_map_color:    boolean    Lets the texture affect the basic color of the lamp
-LampTextureSlot.map_shadow -> use_map_shadow:    boolean    Lets the texture affect the shadow color of the lamp
-Lattice.outside -> use_outside:    boolean    Only draw, and take into account, the outer vertices
-LimitLocationConstraint.limit_transform -> limit_transform:    boolean    Transforms are affected by this constraint as well
-LimitLocationConstraint.use_maximum_x -> use_max_x:    boolean    Use the maximum X value
-LimitLocationConstraint.use_maximum_y -> use_max_y:    boolean    Use the maximum Y value
-LimitLocationConstraint.use_maximum_z -> use_max_z:    boolean    Use the maximum Z value
-LimitLocationConstraint.use_minimum_x -> use_min_x:    boolean    Use the minimum X value
-LimitLocationConstraint.use_minimum_y -> use_min_y:    boolean    Use the minimum Y value
-LimitLocationConstraint.use_minimum_z -> use_min_z:    boolean    Use the minimum Z value
-LimitRotationConstraint.limit_transform -> limit_transform:    boolean    Transforms are affected by this constraint as well
-LimitRotationConstraint.use_limit_x -> use_limit_x:    boolean    Use the minimum X value
-LimitRotationConstraint.use_limit_y -> use_limit_y:    boolean    Use the minimum Y value
-LimitRotationConstraint.use_limit_z -> use_limit_z:    boolean    Use the minimum Z value
-LimitScaleConstraint.limit_transform -> limit_transform:    boolean    Transforms are affected by this constraint as well
-LimitScaleConstraint.use_maximum_x -> use_max_x:    boolean    Use the maximum X value
-LimitScaleConstraint.use_maximum_y -> use_max_y:    boolean    Use the maximum Y value
-LimitScaleConstraint.use_maximum_z -> use_max_z:    boolean    Use the maximum Z value
-LimitScaleConstraint.use_minimum_x -> use_min_x:    boolean    Use the minimum X value
-LimitScaleConstraint.use_minimum_y -> use_min_y:    boolean    Use the minimum Y value
-LimitScaleConstraint.use_minimum_z -> use_min_z:    boolean    Use the minimum Z value
-Main.debug -> show_debug:    boolean    Print debugging information in console
-Main.file_is_saved -> is_saved:    boolean, (read-only)    Has the current session been saved to disk as a .blend file
-MaskModifier.invert -> invert_vertex_group:    boolean    Use vertices that are not part of region defined
-Material.cast_approximate -> use_cast_approximate:    boolean    Allow this material to cast shadows when using approximate ambient occlusion.
-Material.cast_buffer_shadows -> use_cast_buffer_shadows:    boolean    Allow this material to cast shadows from shadow buffer lamps
-Material.cast_shadows_only -> use_cast_shadows_only:    boolean    Makes objects with this material appear invisible, only casting shadows (not rendered)
-Material.cubic -> use_cubic:    boolean    Use cubic interpolation for diffuse values, for smoother transitions
-NEGATE *  Material.exclude_mist -> use_mist:    boolean    Excludes this material from mist effects (in world settings)
-Material.face_texture -> use_face_texture:    boolean    Replaces the object's base color with color from face assigned image textures
-Material.face_texture_alpha -> use_face_texture_alpha:    boolean    Replaces the object's base alpha value with alpha from face assigned image textures
-Material.full_oversampling -> use_full_oversampling:    boolean    Force this material to render full shading/textures for all anti-aliasing samples
-Material.invert_z -> invert_z:    boolean    Renders material's faces with an inverted Z buffer (scanline only)
-Material.light_group_exclusive -> use_light_group_exclusive:    boolean    Material uses the light group exclusively - these lamps are excluded from other scene lighting
-Material.object_color -> use_object_color:    boolean    Modulate the result with a per-object color
-Material.only_shadow -> use_only_shadow:    boolean    Renders shadows as the material's alpha value, making materials transparent except for shadowed areas
-Material.ray_shadow_bias -> use_ray_shadow_bias:    boolean    Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)
-Material.receive_transparent_shadows -> use_transparent_shadows:    boolean    Allow this object to receive transparent shadows casted through other objects
-Material.shadeless -> use_shadeless:    boolean    Makes this material insensitive to light or shadow
-Material.shadows -> use_shadows:    boolean    Allows this material to receive shadows
-Material.tangent_shading -> use_tangent_shading:    boolean    Use the material's tangent vector instead of the normal for shading - for anisotropic shading effects
-Material.traceable -> use_traceable:    boolean    Include this material and geometry that uses it in ray tracing calculations
-Material.transparency -> use_transparency:    boolean    Render material as transparent
-Material.use_diffuse_ramp -> use_diffuse_ramp:    boolean    Toggle diffuse ramp operations
-Material.use_nodes -> use_nodes:    boolean    Use shader nodes to render the material
-Material.use_sky -> use_sky:    boolean    Renders this material with zero alpha, with sky background in place (scanline only)
-Material.use_specular_ramp -> use_specular_ramp:    boolean    Toggle specular ramp operations
-Material.use_textures -> use_textures:    boolean    Enable/Disable each texture
-Material.vertex_color_light -> use_vertex_color_light:    boolean    Add vertex colors as additional lighting
-Material.vertex_color_paint -> use_vertex_color_paint:    boolean    Replaces object base color with vertex colors (multiplies with 'texture face' face assigned textures)
-MaterialHalo.flare_mode -> use_flare_mode:    boolean    Renders halo as a lensflare
-MaterialHalo.lines -> use_lines:    boolean    Renders star shaped lines over halo
-MaterialHalo.ring -> use_ring:    boolean    Renders rings over halo
-MaterialHalo.shaded -> use_shading:    boolean    Lets halo receive light and shadows from external objects
-MaterialHalo.soft -> use_soft:    boolean    Softens the edges of halos at intersections with other geometry
-MaterialHalo.star -> use_star:    boolean    Renders halo as a star
-MaterialHalo.texture -> use_texture:    boolean    Gives halo a texture
-MaterialHalo.vertex_normal -> use_vertex_normal:    boolean    Uses the vertex normal to specify the dimension of the halo
-MaterialHalo.xalpha -> use_extreme_alpha:    boolean    Uses extreme alpha
-MaterialPhysics.align_to_normal -> use_align_to_normal:    boolean    Align dynamic game objects along the surface normal, when inside the physics distance area
-MaterialRaytraceMirror.enabled -> use:    boolean    Enable raytraced reflections
-MaterialStrand.blender_units -> use_blender_units:    boolean    Use Blender units for widths instead of pixels
-MaterialStrand.surface_diffuse -> use_surface_diffuse:    boolean    Make diffuse shading more similar to shading the surface
-MaterialStrand.tangent_shading -> use_tangent_shading:    boolean    Uses direction of strands as normal for tangent-shading
-MaterialSubsurfaceScattering.enabled -> use:    boolean    Enable diffuse subsurface scatting effects in a material
-MaterialTextureSlot.enabled -> use:    boolean    Enable this material texture slot
-MaterialTextureSlot.from_dupli -> use_from_dupli:    boolean    Dupli's instanced from verts, faces or particles, inherit texture coordinate from their parent
-MaterialTextureSlot.from_original -> use_from_original:    boolean    Dupli's derive their object coordinates from the original objects transformation
-MaterialTextureSlot.map_alpha -> use_map_alpha:    boolean    Causes the texture to affect the alpha value
-MaterialTextureSlot.map_ambient -> use_map_ambient:    boolean    Causes the texture to affect the value of ambient
-MaterialTextureSlot.map_colordiff -> use_map_colordiff:    boolean    Causes the texture to affect basic color of the material
-MaterialTextureSlot.map_coloremission -> use_map_coloremission:    boolean    Causes the texture to affect the color of emission
-MaterialTextureSlot.map_colorreflection -> use_map_colorreflection:    boolean    Causes the texture to affect the color of scattered light
-MaterialTextureSlot.map_colorspec -> use_map_colorspec:    boolean    Causes the texture to affect the specularity color
-MaterialTextureSlot.map_colortransmission -> use_map_colortransmission:    boolean    Causes the texture to affect the result color after other light has been scattered/absorbed
-MaterialTextureSlot.map_density -> use_map_density:    boolean    Causes the texture to affect the volume's density
-MaterialTextureSlot.map_diffuse -> use_map_diffuse:    boolean    Causes the texture to affect the value of the materials diffuse reflectivity
-MaterialTextureSlot.map_displacement -> use_map_displacement:    boolean    Let the texture displace the surface
-MaterialTextureSlot.map_emission -> use_map_emission:    boolean    Causes the texture to affect the volume's emission
-MaterialTextureSlot.map_emit -> use_map_emit:    boolean    Causes the texture to affect the emit value
-MaterialTextureSlot.map_hardness -> use_map_hardness:    boolean    Causes the texture to affect the hardness value
-MaterialTextureSlot.map_mirror -> use_map_mirror:    boolean    Causes the texture to affect the mirror color
-MaterialTextureSlot.map_normal -> use_map_normal:    boolean    Causes the texture to affect the rendered normal
-MaterialTextureSlot.map_raymir -> use_map_raymir:    boolean    Causes the texture to affect the ray-mirror value
-MaterialTextureSlot.map_reflection -> use_map_reflect:    boolean    Causes the texture to affect the reflected light's brightness
-MaterialTextureSlot.map_scattering -> use_map_scatter:    boolean    Causes the texture to affect the volume's scattering
-MaterialTextureSlot.map_specular -> use_map_specular:    boolean    Causes the texture to affect the value of specular reflectivity
-MaterialTextureSlot.map_translucency -> use_map_translucency:    boolean    Causes the texture to affect the translucency value
-MaterialTextureSlot.map_warp -> use_map_warp:    boolean    Let the texture warp texture coordinates of next channels
-MaterialTextureSlot.new_bump -> use_new_bump:    boolean    Use new, corrected bump mapping code (backwards compatibility option)
-MaterialVolume.external_shadows -> use_external_shadows:    boolean    Receive shadows from sources outside the volume (temporary)
-MaterialVolume.light_cache -> use_light_cache:    boolean    Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy
-Mesh.all_edges -> show_all_edges:    boolean    Displays all edges for wireframe in all view modes in the 3D view
-Mesh.auto_texspace -> use_auto_texspace:    boolean    Adjusts active object's texture space automatically when transforming object
-Mesh.autosmooth -> use_autosmooth:    boolean    Treats all set-smoothed faces with angles less than the specified angle as 'smooth' during render
-Mesh.double_sided -> show_double_sided:    boolean    Render/display the mesh with double or single sided lighting
-Mesh.draw_bevel_weights -> show_bevel_weights:    boolean    Displays weights created for the Bevel modifier
-Mesh.draw_creases -> show_creases:    boolean    Displays creases created for subsurf weighting
-Mesh.draw_edge_angle -> show_edge_angle:    boolean    Displays the angles in the selected edges in degrees
-Mesh.draw_edge_lenght -> show_edge_lenght:    boolean    Displays selected edge lengths
-Mesh.draw_edges -> show_edges:    boolean    Displays selected edges using highlights in the 3D view and UV editor
-Mesh.draw_face_area -> show_face_area:    boolean    Displays the area of selected faces
-Mesh.draw_faces -> show_faces:    boolean    Displays all faces as shades in the 3D view and UV editor
-Mesh.draw_normals -> show_normals:    boolean    Displays face normals as lines
-Mesh.draw_seams -> show_seams:    boolean    Displays UV unwrapping seams
-Mesh.draw_sharp -> show_sharp:    boolean    Displays sharp edges, used with the EdgeSplit modifier
-Mesh.draw_vertex_normals -> show_vertex_normals:    boolean    Displays vertex normals as lines
-Mesh.use_mirror_topology -> use_mirror_topology:    boolean    Use topology based mirroring
-Mesh.use_mirror_x -> use_mirror_x:    boolean    X Axis mirror editing
-Mesh.use_paint_mask -> use_paint_mask:    boolean    Face selection masking for painting
-Mesh.vertex_normal_flip -> use_vertex_normal_flip:    boolean    Flip vertex normals towards the camera during render
-MeshColorLayer.active -> active:    boolean    Sets the layer as active for display and editing
-MeshColorLayer.active_render -> active_render:    boolean    Sets the layer as active for rendering
-MeshDeformModifier.dynamic -> use_dynamic_bind:    boolean    Recompute binding dynamically on top of other deformers (slower and more memory consuming.)
-MeshDeformModifier.invert -> invert_vertex_group:    boolean    Invert vertex group influence
-MeshDeformModifier.is_bound -> is_bound:    boolean, (read-only)    Whether geometry has been bound to control cage
-MeshEdge.fgon -> is_fgon:    boolean, (read-only)    Fgon edge
-MeshEdge.loose -> is_loose:    boolean, (read-only)    Loose edge
-MeshEdge.seam -> use_seam:    boolean    Seam edge for UV unwrapping
-MeshEdge.sharp -> use_sharp:    boolean    Sharp edge for the EdgeSplit modifier
-
-MeshFace.smooth -> use_smooth:    boolean
-MeshTextureFace.alpha_sort -> use_alpha_sort:    boolean    Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible)
-MeshTextureFace.billboard -> use_billboard:    boolean    Billboard with Z-axis constraint
-MeshTextureFace.collision -> use_collision:    boolean    Use face for collision and ray-sensor detection
-MeshTextureFace.halo -> use_halo:    boolean    Screen aligned billboard
-MeshTextureFace.invisible -> hide:    boolean    Make face invisible
-MeshTextureFace.light -> use_light:    boolean    Use light for face
-MeshTextureFace.object_color -> use_object_color:    boolean    Use ObColor instead of vertex colors
-MeshTextureFace.shadow -> use_shadow_face:    boolean    Face is used for shadow
-MeshTextureFace.shared -> use_blend_shared:    boolean    Blend vertex colors across face when vertices are shared
-MeshTextureFace.tex -> use_texture:    boolean    Render face with texture
-MeshTextureFace.text -> use_bitmap_text:    boolean    Enable bitmap text on face
-MeshTextureFace.twoside -> use_twoside:    boolean    Render face two-sided
-MeshTextureFace.uv_pinned -> pin_uv:    boolean
-MeshTextureFace.uv_selected -> select_uv:    boolean
-MeshTextureFaceLayer.active -> active:    boolean    Sets the layer as active for display and editing
-MeshTextureFaceLayer.active_clone -> active_clone:    boolean    Sets the layer as active for cloning
-MeshTextureFaceLayer.active_render -> active_render:    boolean    Sets the layer as active for rendering
-MetaBall.auto_texspace -> use_auto_texspace:    boolean    Adjusts active object's texture space automatically when transforming object
-MetaElement.hide -> hide:    boolean    Hide element
-MetaElement.negative -> use_negative:    boolean    Set metaball as negative one
-MetaSequence.convert_float -> use_float:    boolean    Convert input to float data
-MetaSequence.de_interlace -> use_deinterlace:    boolean    For video movies to remove fields
-MetaSequence.flip_x -> use_flip_x:    boolean    Flip on the X axis
-MetaSequence.flip_y -> use_flip_y:    boolean    Flip on the Y axis
-MetaSequence.premultiply -> use_premultiply:    boolean    Convert RGB from key alpha to premultiplied alpha
-MetaSequence.proxy_custom_directory -> use_proxy_custom_directory:    boolean    Use a custom directory to store data
-MetaSequence.proxy_custom_file -> use_proxy_custom_file:    boolean    Use a custom file to read proxy data from
-MetaSequence.reverse_frames -> use_reverse_frames:    boolean    Reverse frame order
-MetaSequence.use_color_balance -> use_color_balance:    boolean    (3-Way color correction) on input
-MetaSequence.use_crop -> use_crop:    boolean    Crop image before processing
-MetaSequence.use_proxy -> use_proxy:    boolean    Use a preview proxy for this strip
-MetaSequence.use_translation -> use_translation:    boolean    Translate image before processing
-MirrorModifier.clip -> use_clip:    boolean    Prevents vertices from going through the mirror during transform
-MirrorModifier.mirror_u -> use_mirror_u:    boolean    Mirror the U texture coordinate around the 0.5 point
-MirrorModifier.mirror_v -> use_mirror_v:    boolean    Mirror the V texture coordinate around the 0.5 point
-MirrorModifier.mirror_vertex_groups -> use_mirror_vertex_groups:    boolean    Mirror vertex groups (e.g. .R->.L)
-MirrorModifier.x -> use_x:    boolean    Enable X axis mirror
-MirrorModifier.y -> use_y:    boolean    Enable Y axis mirror
-MirrorModifier.z -> use_z:    boolean    Enable Z axis mirror
-Modifier.editmode -> show_in_editmode:    boolean    Use modifier while in the edit mode
-Modifier.expanded -> show_expanded:    boolean    Set modifier expanded in the user interface
-Modifier.on_cage -> show_on_cage:    boolean    Enable direct editing of modifier control cage
-Modifier.realtime -> show_realtime:    boolean    Realtime display of a modifier
-Modifier.render -> use_render:    boolean    Use modifier during rendering
-MotionPath.editing -> is_edited:    boolean    Path is being edited
-MotionPath.use_bone_head -> use_bone_head:    boolean, (read-only)    For PoseBone paths, use the bone head location when calculating this path
-MovieSequence.convert_float -> use_float:    boolean    Convert input to float data
-MovieSequence.de_interlace -> use_deinterlace:    boolean    For video movies to remove fields
-MovieSequence.flip_x -> use_flip_x:    boolean    Flip on the X axis
-MovieSequence.flip_y -> use_flip_y:    boolean    Flip on the Y axis
-MovieSequence.premultiply -> use_premultiply:    boolean    Convert RGB from key alpha to premultiplied alpha
-MovieSequence.proxy_custom_directory -> use_proxy_custom_directory:    boolean    Use a custom directory to store data
-MovieSequence.proxy_custom_file -> use_proxy_custom_file:    boolean    Use a custom file to read proxy data from
-MovieSequence.reverse_frames -> use_reverse_frames:    boolean    Reverse frame order
-MovieSequence.use_color_balance -> use_color_balance:    boolean    (3-Way color correction) on input
-MovieSequence.use_crop -> use_crop:    boolean    Crop image before processing
-MovieSequence.use_proxy -> use_proxy:    boolean    Use a preview proxy for this strip
-MovieSequence.use_translation -> use_translation:    boolean    Translate image before processing
-MulticamSequence.convert_float -> use_float:    boolean    Convert input to float data
-MulticamSequence.de_interlace -> use_deinterlace:    boolean    For video movies to remove fields
-MulticamSequence.flip_x -> use_flip_x:    boolean    Flip on the X axis
-MulticamSequence.flip_y -> use_flip_y:    boolean    Flip on the Y axis
-MulticamSequence.premultiply -> use_premultiply:    boolean    Convert RGB from key alpha to premultiplied alpha
-MulticamSequence.proxy_custom_directory -> use_proxy_custom_directory:    boolean    Use a custom directory to store data
-MulticamSequence.proxy_custom_file -> use_proxy_custom_file:    boolean    Use a custom file to read proxy data from
-MulticamSequence.reverse_frames -> use_reverse_frames:    boolean    Reverse frame order
-MulticamSequence.use_color_balance -> use_color_balance:    boolean    (3-Way color correction) on input
-MulticamSequence.use_crop -> use_crop:    boolean    Crop image before processing
-MulticamSequence.use_proxy -> use_proxy:    boolean    Use a preview proxy for this strip
-MulticamSequence.use_translation -> use_translation:    boolean    Translate image before processing
-MultiresModifier.external -> is_external:    boolean, (read-only)    Store multires displacements outside the .blend file, to save memory
-MultiresModifier.optimal_display -> show_only_control_edges:    boolean    Skip drawing/rendering of interior subdivided edges
-NetRenderSettings.master_broadcast -> use_master_broadcast:    boolean    broadcast master server address on local network
-NetRenderSettings.master_clear -> use_master_clear:    boolean    delete saved files on exit
-NetRenderSettings.slave_clear -> use_slave_clear:    boolean    delete downloaded files on exit
-NetRenderSettings.slave_outputlog -> use_slave_output_log:    boolean    Output render text log to console as well as sending it to the master
-NetRenderSettings.slave_thumb -> use_slave_thumb:    boolean    Generate thumbnails on slaves instead of master
-NlaStrip.active -> active:    boolean, (read-only)    NLA Strip is active
-NlaStrip.animated_influence -> use_animated_influence:    boolean    Influence setting is controlled by an F-Curve rather than automatically determined
-NlaStrip.animated_time -> use_animated_time:    boolean    Strip time is controlled by an F-Curve rather than automatically determined
-NlaStrip.animated_time_cyclic -> use_animated_time_cyclic:    boolean    Cycle the animated time within the action start & end
-NlaStrip.auto_blending -> use_auto_blend:    boolean    Number of frames for Blending In/Out is automatically determined from overlapping strips
-NlaStrip.muted -> mute:    boolean    NLA Strip is not evaluated
-NlaStrip.reversed -> use_reverse:    boolean    NLA Strip is played back in reverse order (only when timing is automatically determined)
-NlaTrack.active -> active:    boolean, (read-only)    NLA Track is active
-NlaTrack.solo -> is_solo:    boolean, (read-only)    NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)
-Object.draw_axis -> show_axis:    boolean    Displays the object's origin and axis
-Object.draw_bounds -> show_bounds:    boolean    Displays the object's bounds
-Object.draw_name -> show_name:    boolean    Displays the object's name
-Object.draw_texture_space -> show_texture_space:    boolean    Displays the object's texture space
-Object.draw_transparent -> show_transparent:    boolean    Enables transparent materials for the object (Mesh only)
-Object.draw_wire -> show_wire:    boolean    Adds the object's wireframe over solid drawing
-Object.duplis_used -> is_duplicator:    boolean, (read-only)
-Object.layers -> layers:    boolean    Layers the object is on
-Object.lock_location -> lock_location:    boolean    Lock editing of location in the interface
-Object.lock_rotation -> lock_rotation:    boolean    Lock editing of rotation in the interface
-Object.lock_rotation_w -> lock_rotation_w:    boolean    Lock editing of 'angle' component of four-component rotations in the interface
-Object.lock_rotations_4d -> lock_rotations_4d:    boolean    Lock editing of four component rotations by components (instead of as Eulers)
-Object.lock_scale -> lock_scale:    boolean    Lock editing of scale in the interface
-
-Object.shape_key_edit_mode -> use_shape_key_edit_mode:    boolean    Apply shape keys in edit mode (for Meshes only)
-Object.shape_key_lock -> show_shape_key:    boolean    Always show the current Shape for this Object
-Object.slow_parent -> use_slow_parent:    boolean    Create a delay in the parent relationship
-Object.time_offset_add_parent -> use_time_offset_add_parent:    boolean    Add the parents time offset value
-Object.time_offset_edit -> use_time_offset_edit:    boolean    Use time offset when inserting keys and display time offset for F-Curve and action views
-Object.time_offset_parent -> use_time_offset_parent:    boolean    Apply the time offset to this objects parent relationship
-Object.time_offset_particle -> use_time_offset_particle:    boolean    Let the time offset work on the particle effect
-Object.use_dupli_faces_scale -> use_dupli_faces_scale:    boolean    Scale dupli based on face size
-Object.use_dupli_frames_speed -> use_dupli_frames_speed:    boolean    Set dupliframes to use the frame
-Object.use_dupli_verts_rotation -> use_dupli_verts_rotation:    boolean    Rotate dupli according to vertex normal
-Object.x_ray -> show_x_ray:    boolean    Makes the object draw in front of others
-ObjectActuator.add_linear_velocity -> use_add_linear_velocity:    boolean    Toggles between ADD and SET linV
-ObjectActuator.local_angular_velocity -> use_local_angular_velocity:    boolean    Angular velocity is defined in local coordinates
-ObjectActuator.local_force -> use_local_force:    boolean    Force is defined in local coordinates
-ObjectActuator.local_linear_velocity -> use_local_linear_velocity:    boolean    Velocity is defined in local coordinates
-ObjectActuator.local_location -> use_local_location:    boolean    Location is defined in local coordinates
-ObjectActuator.local_rotation -> use_local_rotation:    boolean    Rotation is defined in local coordinates
-ObjectActuator.local_torque -> use_local_torque:    boolean    Torque is defined in local coordinates
-ObjectActuator.servo_limit_x -> use_servo_limit_x:    boolean    Set limit to force along the X axis
-ObjectActuator.servo_limit_y -> use_servo_limit_y:    boolean    Set limit to force along the Y axis
-ObjectActuator.servo_limit_z -> use_servo_limit_z:    boolean    Set limit to force along the Z axis
-ObjectBase.layers -> layers:    boolean    Layers the object base is on
-ObstacleFluidSettings.active -> use:    boolean    Object contributes to the fluid simulation
-ObstacleFluidSettings.export_animated_mesh -> use_animated_mesh:    boolean    Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it
-Operator.has_reports -> has_reports:    boolean, (read-only)    Operator has a set of reports (warnings and errors) from last execution
-OperatorStrokeElement.flip -> use_flip:    boolean
-OutflowFluidSettings.active -> use:    boolean    Object contributes to the fluid simulation
-OutflowFluidSettings.export_animated_mesh -> use_animated_mesh:    boolean    Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it
-Paint.fast_navigate -> show_low_resolution:    boolean    For multires, show low resolution while navigating the view
-Paint.show_brush -> show_brush:    boolean
-Panel.bl_default_closed -> bl_use_closed:    boolean
-Panel.bl_show_header -> bl_show_header:    boolean
-ParentActuator.compound -> use_compound:    boolean    Add this object shape to the parent shape (only if the parent shape is already compound)
-ParentActuator.ghost -> use_ghost:    boolean    Make this object ghost while parented (only if not compound)
-ParticleBrush.use_puff_volume -> use_puff_volume:    boolean    Apply puff to unselected end-points, (helps maintain hair volume when puffing root)
-ParticleEdit.add_interpolate -> use_add_interpolate:    boolean    Interpolate new particles from the existing ones
-ParticleEdit.auto_velocity -> use_auto_velocity:    boolean    Calculate point velocities automatically
-ParticleEdit.draw_particles -> show_particles:    boolean    Draw actual particles
-ParticleEdit.editable -> is_editable:    boolean, (read-only)    A valid edit mode exists
-ParticleEdit.emitter_deflect -> use_emitter_deflect:    boolean    Keep paths from intersecting the emitter
-ParticleEdit.fade_time -> use_fade_time:    boolean    Fade paths and keys further away from current frame
-ParticleEdit.hair -> is_hair:    boolean, (read-only)    Editing hair
-ParticleEdit.keep_lengths -> use_preserve_lengths:    boolean    Keep path lengths constant
-ParticleEdit.keep_root -> use_preserve_root:    boolean    Keep root keys unmodified
-ParticleFluidSettings.drops -> use_drops:    boolean    Show drop particles
-ParticleFluidSettings.floats -> use_floats:    boolean    Show floating foam particles
-ParticleFluidSettings.tracer -> use_tracer:    boolean    Show tracer particles
-ParticleInstanceModifier.alive -> use_alive:    boolean    Show instances when particles are alive
-ParticleInstanceModifier.children -> use_children:    boolean    Create instances from child particles
-ParticleInstanceModifier.dead -> use_dead:    boolean    Show instances when particles are dead
-ParticleInstanceModifier.keep_shape -> use_preserve_shape:    boolean    Don't stretch the object
-ParticleInstanceModifier.normal -> use_normal:    boolean    Create instances from normal particles
-ParticleInstanceModifier.size -> use_size:    boolean    Use particle size to scale the instances
-ParticleInstanceModifier.unborn -> use_unborn:    boolean    Show instances when particles are unborn
-ParticleInstanceModifier.use_path -> use_path:    boolean    Create instances along particle paths
-ParticleSettings.abs_path_time -> use_absolute_path_time:    boolean    Path timing is in absolute frames
-ParticleSettings.animate_branching -> use_animate_branching:    boolean    Animate branching
-ParticleSettings.billboard_lock -> lock_billboard:    boolean    Lock the billboards align axis
-ParticleSettings.boids_2d -> lock_boids_to_surface:    boolean    Constrain boids to a surface
-ParticleSettings.branching -> use_branching:    boolean    Branch child paths from each other
-ParticleSettings.child_effector -> apply_effector_to_children:    boolean    Apply effectors to children
-ParticleSettings.child_guide -> apply_guide_to_children:    boolean
-ParticleSettings.die_on_collision -> use_die_on_collision:    boolean    Particles die when they collide with a deflector object
-ParticleSettings.died -> use_died:    boolean    Show particles after they have died
-ParticleSettings.draw_health -> show_health:    boolean    Draw boid health
-ParticleSettings.emitter -> use_render_emitter:    boolean    Render emitter Object also
-ParticleSettings.enable_simplify -> use_simplify:    boolean    Remove child strands as the object becomes smaller on the screen
-ParticleSettings.even_distribution -> use_even_distribution:    boolean    Use even distribution from faces based on face areas or edge lengths
-ParticleSettings.grid_invert -> invert_grid:    boolean    Invert what is considered object and what is not
-ParticleSettings.hair_bspline -> use_hair_bspline:    boolean    Interpolate hair using B-Splines
-ParticleSettings.material_color -> show_material_color:    boolean    Draw particles using material's diffuse color
-ParticleSettings.num -> show_number:    boolean    Show particle number
-ParticleSettings.parent -> use_parents:    boolean    Render parent particles
-ParticleSettings.rand_group -> use_group_pick_random:    boolean    Pick objects from group randomly
-ParticleSettings.react_multiple -> use_react_multiple:    boolean    React multiple times
-ParticleSettings.react_start_end -> use_react_start_end:    boolean    Give birth to unreacted particles eventually
-ParticleSettings.render_adaptive -> use_render_adaptive:    boolean    Use adapative rendering for paths
-ParticleSettings.render_strand -> use_strand_primitive:    boolean    Use the strand primitive for rendering
-ParticleSettings.rotation_dynamic -> use_dynamic_rotation:    boolean    Sets rotation to dynamic/constant
-ParticleSettings.self_effect -> use_self_effect:    boolean    Particle effectors effect themselves
-ParticleSettings.show_size -> show_size:    boolean    Show particle size
-ParticleSettings.size_deflect -> use_size_deflect:    boolean    Use particle's size in deflection
-ParticleSettings.sizemass -> use_multiply_size_mass:    boolean    Multiply mass by particle size
-ParticleSettings.symmetric_branching -> use_symmetric_branching:    boolean    Start and end points are the same
-ParticleSettings.trand -> use_emit_random:    boolean    Emit in random order of elements
-ParticleSettings.unborn -> use_unborn:    boolean    Show particles before they are emitted
-ParticleSettings.use_global_dupli -> use_global_dupli:    boolean    Use object's global coordinates for duplication
-ParticleSettings.use_group_count -> use_group_count:    boolean    Use object multiple times in the same group
-ParticleSettings.velocity -> show_velocity:    boolean    Show particle velocity
-ParticleSettings.velocity_length -> use_velocity_length:    boolean    Multiply line length by particle speed
-ParticleSettings.viewport -> use_simplify_viewport:    boolean
-ParticleSettings.whole_group -> use_whole_group:    boolean    Use whole group at once
-ParticleSystem.editable -> is_editable:    boolean, (read-only)    Particle system can be edited in particle mode
-ParticleSystem.edited -> is_edited:    boolean, (read-only)    Particle system has been edited in particle mode
-ParticleSystem.global_hair -> is_global_hair:    boolean, (read-only)    Hair keys are in global coordinate space
-ParticleSystem.hair_dynamics -> use_hair_dynamics:    boolean    Enable hair dynamics using cloth simulation
-ParticleSystem.keyed_timing -> use_keyed_timing:    boolean    Use key times
-ParticleSystem.multiple_caches -> has_multiple_caches:    boolean, (read-only)    Particle system has multiple point caches
-ParticleSystem.vertex_group_clump_negate -> invert_vertex_group_clump:    boolean    Negate the effect of the clump vertex group
-ParticleSystem.vertex_group_density_negate -> invert_vertex_group_density:    boolean    Negate the effect of the density vertex group
-ParticleSystem.vertex_group_field_negate -> invert_vertex_group_field:    boolean    Negate the effect of the field vertex group
-ParticleSystem.vertex_group_kink_negate -> invert_vertex_group_kink:    boolean    Negate the effect of the kink vertex group
-ParticleSystem.vertex_group_length_negate -> invert_vertex_group_length:    boolean    Negate the effect of the length vertex group
-ParticleSystem.vertex_group_rotation_negate -> invert_vertex_group_rotation:    boolean    Negate the effect of the rotation vertex group
-ParticleSystem.vertex_group_roughness1_negate -> invert_vertex_group_roughness1:    boolean    Negate the effect of the roughness 1 vertex group
-ParticleSystem.vertex_group_roughness2_negate -> invert_vertex_group_roughness2:    boolean    Negate the effect of the roughness 2 vertex group
-ParticleSystem.vertex_group_roughness_end_negate -> invert_vertex_group_roughness_end:    boolean    Negate the effect of the roughness end vertex group
-ParticleSystem.vertex_group_size_negate -> invert_vertex_group_size:    boolean    Negate the effect of the size vertex group
-ParticleSystem.vertex_group_tangent_negate -> invert_vertex_group_tangent:    boolean    Negate the effect of the tangent vertex group
-ParticleSystem.vertex_group_velocity_negate -> invert_vertex_group_velocity:    boolean    Negate the effect of the velocity vertex group
-ParticleTarget.valid -> is_valid:    boolean    Keyed particles target is valid
-PivotConstraint.use_relative_position -> use_relative_location:    boolean    Offset will be an absolute point in space instead of relative to the target
-PointCache.baked -> is_baked:    boolean, (read-only)
-PointCache.baking -> is_baking:    boolean, (read-only)
-PointCache.disk_cache -> use_disk_cache:    boolean    Save cache files to disk (.blend file must be saved first)
-PointCache.external -> use_external:    boolean    Read cache from an external location
-PointCache.has_skipped_frames-> has_skipped_frames:    boolean, (read-only)
-PointCache.outdated -> is_outdated:    boolean, (read-only)
-PointCache.quick_cache -> use_quick_cache:    boolean    Update simulation with cache steps
-PointCache.use_library_path -> use_library_path:    boolean    Use this files path when library linked into another file.
-PointDensity.turbulence -> use_turbulence:    boolean    Add directed noise to the density at render-time
-PointLamp.only_shadow -> use_only_shadow:    boolean    Causes light to cast shadows only without illuminating objects
-PointLamp.shadow_layer -> use_shadow_layer:    boolean    Causes only objects on the same layer to cast shadows
-PointLamp.sphere -> use_sphere:    boolean    Sets light intensity to zero beyond lamp distance
-PoseBone.has_ik -> is_in_ik_chain:    boolean, (read-only)    Is part of an IK chain
-NEGATE *  PoseBone.ik_dof_x -> lock_ik_x:    boolean    Allow movement around the X axis
-NEGATE *  PoseBone.ik_dof_y -> lock_ik_y:    boolean    Allow movement around the Y axis
-NEGATE *  PoseBone.ik_dof_z -> lock_ik_z:    boolean    Allow movement around the Z axis
-PoseBone.ik_limit_x -> lock_ik_x:    boolean    Limit movement around the X axis
-PoseBone.ik_limit_y -> lock_ik_y:    boolean    Limit movement around the Y axis
-PoseBone.ik_limit_z -> lock_ik_z:    boolean    Limit movement around the Z axis
-PoseBone.ik_lin_control -> use_ik_lin_control:    boolean    Apply channel size as IK constraint if stretching is enabled
-PoseBone.ik_rot_control -> use_ik_rot_control:    boolean    Apply channel rotation as IK constraint
-PoseBone.lock_location -> lock_location:    boolean    Lock editing of location in the interface
-PoseBone.lock_rotation -> lock_rotation:    boolean    Lock editing of rotation in the interface
-PoseBone.lock_rotation_w -> lock_rotation_w:    boolean    Lock editing of 'angle' component of four-component rotations in the interface
-PoseBone.lock_rotations_4d -> lock_rotations_4d:    boolean    Lock editing of four component rotations by components (instead of as Eulers)
-PoseBone.lock_scale -> lock_scale:    boolean    Lock editing of scale in the interface
-
-PoseTemplateSettings.generate_def_rig -> use_generate_deform_rig:    boolean    Create a copy of the metarig, constrainted by the generated rig
-Property.is_never_none -> is_never_none:    boolean, (read-only)    True when this value can't be set to None
-Property.is_readonly -> is_readonly:    boolean, (read-only)    Property is editable through RNA
-Property.is_required -> is_required:    boolean, (read-only)    False when this property is an optional argument in an RNA function
-Property.registered -> is_registered:    boolean, (read-only)    Property is registered as part of type registration
-Property.registered_optional -> is_registered_optional:    boolean, (read-only)    Property is optionally registered as part of type registration
-Property.use_output -> is_output:    boolean, (read-only)    True when this property is an output value from an RNA function
-PythonConstraint.script_error -> has_script_error:    boolean, (read-only)    The linked Python script has thrown an error
-PythonConstraint.use_targets -> use_targets:    boolean    Use the targets indicated in the constraint panel
-PythonController.debug -> use_debug:    boolean    Continuously reload the module from disk for editing external modules without restarting
-RandomActuator.always_true -> use_always_true:    boolean    Always false or always true
-RaySensor.x_ray_mode -> use_x_ray:    boolean    See through objects that don't have the property
-RegionView3D.box_clip -> use_box_clip:    boolean    Clip objects based on what's visible in other side views
-RegionView3D.box_preview -> show_synced_view:    boolean    Sync view position between side views
-RegionView3D.lock_rotation -> lock_rotation:    boolean    Lock view rotation in side views
-RenderEngine.bl_postprocess -> bl_use_postprocess:    boolean
-RenderEngine.bl_preview -> bl_use_preview:    boolean
-RenderLayer.all_z -> use_all_z:    boolean, (read-only)    Fill in Z values for solid faces in invisible layers, for masking
-RenderLayer.edge -> use_edge_enhance:    boolean, (read-only)    Render Edge-enhance in this Layer (only works for Solid faces)
-RenderLayer.enabled -> use:    boolean, (read-only)    Disable or enable the render layer
-RenderLayer.halo -> use_halo:    boolean, (read-only)    Render Halos in this Layer (on top of Solid)
-RenderLayer.pass_ao -> use_pass_ambient_occlusion:    boolean, (read-only)    Deliver AO pass
-RenderLayer.pass_ao_exclude -> exclude_ambient_occlusion:    boolean, (read-only)    Exclude AO pass from combined
-RenderLayer.pass_color -> use_pass_color:    boolean, (read-only)    Deliver shade-less color pass
-RenderLayer.pass_combined -> use_pass_combined:    boolean, (read-only)    Deliver full combined RGBA buffer
-RenderLayer.pass_diffuse -> use_pass_diffuse:    boolean, (read-only)    Deliver diffuse pass
-RenderLayer.pass_emit -> use_pass_emit:    boolean, (read-only)    Deliver emission pass
-RenderLayer.pass_emit_exclude -> exclude_emit:    boolean, (read-only)    Exclude emission pass from combined
-RenderLayer.pass_environment -> use_pass_environment:    boolean, (read-only)    Deliver environment lighting pass
-RenderLayer.pass_environment_exclude -> exclude_environment:    boolean, (read-only)    Exclude environment pass from combined
-RenderLayer.pass_indirect -> use_pass_indirect:    boolean, (read-only)    Deliver indirect lighting pass
-RenderLayer.pass_indirect_exclude -> exclude_indirect:    boolean, (read-only)    Exclude indirect pass from combined
-RenderLayer.pass_mist -> use_pass_mist:    boolean, (read-only)    Deliver mist factor pass (0.0-1.0)
-RenderLayer.pass_normal -> use_pass_normal:    boolean, (read-only)    Deliver normal pass
-RenderLayer.pass_object_index -> use_pass_object_index:    boolean, (read-only)    Deliver object index pass
-RenderLayer.pass_reflection -> use_pass_reflection:    boolean, (read-only)    Deliver raytraced reflection pass
-RenderLayer.pass_reflection_exclude -> exclude_reflection:    boolean, (read-only)    Exclude raytraced reflection pass from combined
-RenderLayer.pass_refraction -> use_pass_refraction:    boolean, (read-only)    Deliver raytraced refraction pass
-RenderLayer.pass_refraction_exclude -> exclude_refraction:    boolean, (read-only)    Exclude raytraced refraction pass from combined
-RenderLayer.pass_shadow -> use_pass_shadow:    boolean, (read-only)    Deliver shadow pass
-RenderLayer.pass_shadow_exclude -> exclude_shadow:    boolean, (read-only)    Exclude shadow pass from combined
-RenderLayer.pass_specular -> use_pass_specular:    boolean, (read-only)    Deliver specular pass
-RenderLayer.pass_specular_exclude -> exclude_specular:    boolean, (read-only)    Exclude specular pass from combined
-RenderLayer.pass_uv -> use_pass_uv:    boolean, (read-only)    Deliver texture UV pass
-RenderLayer.pass_vector -> use_pass_vector:    boolean, (read-only)    Deliver speed vector pass
-RenderLayer.pass_z -> use_pass_z:    boolean, (read-only)    Deliver Z values pass
-RenderLayer.sky -> use_sky:    boolean, (read-only)    Render Sky in this Layer
-RenderLayer.solid -> use_solid:    boolean, (read-only)    Render Solid faces in this Layer
-RenderLayer.strand -> use_strand:    boolean, (read-only)    Render Strands in this Layer
-RenderLayer.visible_layers -> layers:    boolean, (read-only)    Scene layers included in this render layer
-RenderLayer.zmask -> use_zmask:    boolean, (read-only)    Only render what's in front of the solid z values
-RenderLayer.zmask_layers -> layers_zmask:    boolean, (read-only)    Zmask scene layers
-RenderLayer.zmask_negate -> invert_zmask:    boolean, (read-only)    For Zmask, only render what is behind solid z values instead of in front
-RenderLayer.ztransp -> use_ztransp:    boolean, (read-only)    Render Z-Transparent faces in this Layer (On top of Solid and Halos)
-RenderSettings.backbuf -> use_backbuf:    boolean    Render backbuffer image
-RenderSettings.bake_active -> use_bake_active_to_selected:    boolean    Bake shading on the surface of selected objects to the active object
-RenderSettings.bake_clear -> use_bake_clear:    boolean    Clear Images before baking
-RenderSettings.bake_enable_aa -> use_bake_antialiasing:    boolean    Enables Anti-aliasing
-RenderSettings.bake_normalized -> use_bake_normalized:    boolean    With displacement normalize to the distance, with ambient occlusion normalize without using material settings
-RenderSettings.cineon_log -> use_cineon_log:    boolean    Convert to logarithmic color space
-RenderSettings.color_management -> use_color_management:    boolean    Use color profiles and gamma corrected imaging pipeline
-RenderSettings.crop_to_border -> use_crop_to_border:    boolean    Crop the rendered frame to the defined border size
-RenderSettings.edge -> use_edge_enhance:    boolean    use_Create a toon outline around the edges of geometry
-RenderSettings.exr_half -> use_exr_half:    boolean    Use 16 bit floats instead of 32 bit floats per channel
-RenderSettings.exr_preview -> use_exr_preview:    boolean    When rendering animations, save JPG preview images in same directory
-RenderSettings.exr_zbuf -> use_exr_zbuf:    boolean    Save the z-depth per pixel (32 bit unsigned int zbuffer)
-RenderSettings.ffmpeg_autosplit -> use_ffmpeg_autosplit:    boolean    Autosplit output at 2GB boundary
-RenderSettings.fields -> use_fields:    boolean    Render image to two fields per frame, for interlaced TV output
-RenderSettings.fields_still -> use_fields_still:    boolean    Disable the time difference between fields
-RenderSettings.free_image_textures -> use_free_image_textures:    boolean    Free all image texture from memory after render, to save memory before compositing
-RenderSettings.free_unused_nodes -> use_free_unused_nodes:    boolean    Free Nodes that are not used while compositing, to save memory
-RenderSettings.full_sample -> use_full_sample:    boolean    Save for every anti-aliasing sample the entire RenderLayer results. This solves anti-aliasing issues with compositing
-RenderSettings.is_movie_format -> is_movie_format:    boolean, (read-only)    When true the format is a movie
-RenderSettings.jpeg2k_ycc -> use_jpeg2k_ycc:    boolean    Save luminance-chrominance-chrominance channels instead of RGB colors
-RenderSettings.motion_blur -> use_motion_blur:    boolean    Use multi-sampled 3D scene motion blur
-RenderSettings.multiple_engines -> has_multiple_engines:    boolean, (read-only)    More than one rendering engine is available
-RenderSettings.render_antialiasing -> use_antialiasing:    boolean    Render and combine multiple samples per pixel to prevent jagged edges
-RenderSettings.render_stamp -> use_stamp:    boolean    Render the stamp info text in the rendered image
-RenderSettings.save_buffers -> use_save_buffers:    boolean    Save tiles for all RenderLayers and SceneNodes to files in the temp directory (saves memory, required for Full Sample)
-RenderSettings.simplify_triangulate -> use_simplify_triangulate:    boolean    Disables non-planer quads being triangulated
-RenderSettings.single_layer -> use_single_layer:    boolean    Only render the active layer
-RenderSettings.stamp_camera -> use_stamp_camera:    boolean    Include the name of the active camera in image metadata
-RenderSettings.stamp_date -> use_stamp_date:    boolean    Include the current date in image metadata
-RenderSettings.stamp_filename -> use_stamp_filename:    boolean    Include the filename of the .blend file in image metadata
-RenderSettings.stamp_frame -> use_stamp_frame:    boolean    Include the frame number in image metadata
-RenderSettings.stamp_marker -> use_stamp_marker:    boolean    Include the name of the last marker in image metadata
-RenderSettings.stamp_note -> use_stamp_note:    boolean    Include a custom note in image metadata
-RenderSettings.stamp_render_time -> use_stamp_render_time:    boolean    Include the render time in the stamp image
-RenderSettings.stamp_scene -> use_stamp_scene:    boolean    Include the name of the active scene in image metadata
-RenderSettings.stamp_sequencer_strip -> use_stamp_sequencer_strip:    boolean    Include the name of the foreground sequence strip in image metadata
-RenderSettings.stamp_time -> use_stamp_time:    boolean    Include the render frame as HH:MM:SS.FF in image metadata
-RenderSettings.tiff_bit -> use_tiff_16bit:    boolean    Save TIFF with 16 bits per channel
-RenderSettings.use_border -> use_border:    boolean    Render a user-defined border region, within the frame size. Note, this disables save_buffers and full_sample
-RenderSettings.use_compositing -> use_compositing:    boolean    Process the render result through the compositing pipeline, if compositing nodes are enabled
-RenderSettings.use_envmaps -> use_envmaps:    boolean    Calculate environment maps while rendering
-RenderSettings.use_file_extension -> use_file_extension:    boolean    Add the file format extensions to the rendered file name (eg: filename + .jpg)
-RenderSettings.use_game_engine -> use_game_engine:    boolean, (read-only)    Current rendering engine is a game engine
-RenderSettings.use_instances -> use_instances:    boolean    Instance support leads to effective memory reduction when using duplicates
-RenderSettings.use_local_coords -> use_local_coords:    boolean    Vertex coordinates are stored localy on each primitive. Increases memory usage, but may have impact on speed
-RenderSettings.use_overwrite -> use_overwrite:    boolean    Overwrite existing files while rendering
-RenderSettings.use_placeholder -> use_placeholder:    boolean    Create empty placeholder files while rendering frames (similar to Unix 'touch')
-RenderSettings.use_radiosity -> use_radiosity:    boolean    Calculate radiosity in a pre-process before rendering
-RenderSettings.use_raytracing -> use_raytrace:    boolean    Pre-calculate the raytrace accelerator and render raytracing effects
-RenderSettings.use_sequencer -> use_sequencer:    boolean    Process the render (and composited) result through the video sequence editor pipeline, if sequencer strips exist
-RenderSettings.use_sequencer_gl_preview -> use_sequencer_gl_preview:    boolean
-RenderSettings.use_sequencer_gl_render -> use_sequencer_gl_render:    boolean
-RenderSettings.use_shadows -> use_shadows:    boolean    Calculate shadows while rendering
-RenderSettings.use_simplify -> use_simplify:    boolean    Enable simplification of scene for quicker preview renders
-RenderSettings.use_sss -> use_sss:    boolean    Calculate sub-surface scattering in materials rendering
-RenderSettings.use_textures -> use_textures:    boolean    Use textures to affect material properties
-NEGATE *  RigidBodyJointConstraint.disable_linked_collision -> use_linked_collision:    boolean    Disable collision between linked bodies
-RigidBodyJointConstraint.draw_pivot -> show_pivot:    boolean    Display the pivot point and rotation in 3D view
-Scene.frame_drop -> use_frame_drop:    boolean    Play back dropping frames if frame display is too slow
-Scene.layers -> layers:    boolean    Layers visible when rendering the scene
-Scene.mute_audio -> mute_audio:    boolean    Play back of audio from Sequence Editor will be muted
-Scene.nla_tweakmode_on -> use_nla_tweakmode:    boolean, (read-only)    Indicates whether there is any action referenced by NLA being edited. Strictly read-only
-Scene.pov_radio_always_sample -> use_pov_radio_always_sample:    boolean    Only use the data from the pretrace step and not gather any new samples during the final radiosity pass
-Scene.pov_radio_display_advanced -> show_pov_radio_advanced:    boolean    Show advanced options
-Scene.pov_radio_enable -> use_pov_radio:    boolean    Enable povrays radiosity calculation
-Scene.pov_radio_media -> use_pov_radio_media:    boolean    Radiosity estimation can be affected by media
-Scene.pov_radio_normal -> use_pov_radio_normal:    boolean    Radiosity estimation can be affected by normals
-Scene.scrub_audio -> use_audio_scrub:    boolean    Play audio from Sequence Editor while scrubbing
-Scene.sync_audio -> use_audio_sync:    boolean    Play back and sync with audio clock, dropping frames if frame display is too slow
-Scene.use_gravity -> use_gravity:    boolean    Use global gravity for all dynamics
-Scene.use_nodes -> use_nodes:    boolean    Enable the compositing node tree
-Scene.use_preview_range -> use_preview_range:    boolean    Use an alternative start/end frame for UI playback, rather than the scene start/end frame
-SceneGameData.activity_culling -> use_activity_culling:    boolean    Activity culling is enabled
-SceneGameData.auto_start -> use_auto_start:    boolean    Automatically start game at load time
-SceneGameData.fullscreen -> show_fullscreen:    boolean    Starts player in a new fullscreen display
-SceneGameData.glsl_extra_textures -> use_glsl_extra_textures:    boolean    Use extra textures like normal or specular maps for GLSL rendering
-SceneGameData.glsl_lights -> use_glsl_lights:    boolean    Use lights for GLSL rendering
-SceneGameData.glsl_nodes -> use_glsl_nodes:    boolean    Use nodes for GLSL rendering
-SceneGameData.glsl_ramps -> use_glsl_ramps:    boolean    Use ramps for GLSL rendering
-SceneGameData.glsl_shaders -> use_glsl_shaders:    boolean    Use shaders for GLSL rendering
-SceneGameData.glsl_shadows -> use_glsl_shadows:    boolean    Use shadows for GLSL rendering
-SceneGameData.show_debug_properties -> show_debug_properties:    boolean    Show properties marked for debugging while the game runs
-SceneGameData.show_framerate_profile -> show_framerate_profile:    boolean    Show framerate and profiling information while the game runs
-SceneGameData.show_physics_visualization -> show_physics_visualization:    boolean    Show a visualization of physics bounds and interactions
-SceneGameData.use_animation_record -> use_animation_record:    boolean    Record animation to fcurves
-SceneGameData.use_deprecation_warnings -> use_deprecation_warnings:    boolean    Print warnings when using deprecated features in the python API
-SceneGameData.use_display_lists -> use_display_lists:    boolean    Use display lists to speed up rendering by keeping geometry on the GPU
-SceneGameData.use_frame_rate -> use_frame_rate:    boolean    Respect the frame rate rather than rendering as many frames as possible
-SceneGameData.use_occlusion_culling -> use_occlusion_culling:    boolean    Use optimized Bullet DBVT tree for view frustum and occlusion culling
-SceneRenderLayer.all_z -> use_all_z:    boolean    Fill in Z values for solid faces in invisible layers, for masking
-SceneRenderLayer.edge -> use_edge_enhance:    boolean    Render Edge-enhance in this Layer (only works for Solid faces)
-SceneRenderLayer.enabled -> use:    boolean    Disable or enable the render layer
-SceneRenderLayer.halo -> use_halo:    boolean    Render Halos in this Layer (on top of Solid)
-SceneRenderLayer.pass_ao -> use_pass_ambient_occlusion:    boolean    Deliver AO pass
-SceneRenderLayer.pass_ao_exclude -> exclude_ambient_occlusion:    boolean    Exclude AO pass from combined
-SceneRenderLayer.pass_color -> use_pass_color:    boolean    Deliver shade-less color pass
-SceneRenderLayer.pass_combined -> use_pass_combined:    boolean    Deliver full combined RGBA buffer
-SceneRenderLayer.pass_diffuse -> use_pass_diffuse:    boolean    Deliver diffuse pass
-SceneRenderLayer.pass_emit -> use_pass_emit:    boolean    Deliver emission pass
-SceneRenderLayer.pass_emit_exclude -> exclude_emit:    boolean    Exclude emission pass from combined
-SceneRenderLayer.pass_environment -> use_pass_environment:    boolean    Deliver environment lighting pass
-SceneRenderLayer.pass_environment_exclude -> exclude_environment:    boolean    Exclude environment pass from combined
-SceneRenderLayer.pass_indirect -> use_pass_indirect:    boolean    Deliver indirect lighting pass
-SceneRenderLayer.pass_indirect_exclude -> exclude_indirect:    boolean    Exclude indirect pass from combined
-SceneRenderLayer.pass_mist -> use_pass_mist:    boolean    Deliver mist factor pass (0.0-1.0)
-SceneRenderLayer.pass_normal -> use_pass_normal:    boolean    Deliver normal pass
-SceneRenderLayer.pass_object_index -> use_pass_object_index:    boolean    Deliver object index pass
-SceneRenderLayer.pass_reflection -> use_pass_reflection:    boolean    Deliver raytraced reflection pass
-SceneRenderLayer.pass_reflection_exclude -> exclude_reflection:    boolean    Exclude raytraced reflection pass from combined
-SceneRenderLayer.pass_refraction -> use_pass_refraction:    boolean    Deliver raytraced refraction pass
-SceneRenderLayer.pass_refraction_exclude -> exclude_refraction:    boolean    Exclude raytraced refraction pass from combined
-SceneRenderLayer.pass_shadow -> use_pass_shadow:    boolean    Deliver shadow pass
-SceneRenderLayer.pass_shadow_exclude -> exclude_shadow:    boolean    Exclude shadow pass from combined
-SceneRenderLayer.pass_specular -> use_pass_specular:    boolean    Deliver specular pass
-SceneRenderLayer.pass_specular_exclude -> exclude_specular:    boolean    Exclude specular pass from combined
-SceneRenderLayer.pass_uv -> use_pass_uv:    boolean    Deliver texture UV pass
-SceneRenderLayer.pass_vector -> use_pass_vector:    boolean    Deliver speed vector pass
-SceneRenderLayer.pass_z -> use_pass_z:    boolean    Deliver Z values pass
-SceneRenderLayer.sky -> use_sky:    boolean    Render Sky in this Layer
-SceneRenderLayer.solid -> use_solid:    boolean    Render Solid faces in this Layer
-SceneRenderLayer.strand -> use_strand:    boolean    Render Strands in this Layer
-SceneRenderLayer.visible_layers -> layers:    boolean    Scene layers included in this render layer
-SceneRenderLayer.zmask -> use_zmask:    boolean    Only render what's in front of the solid z values
-SceneRenderLayer.zmask_layers -> layers_zmask:    boolean    Zmask scene layers
-SceneRenderLayer.zmask_negate -> invert_zmask:    boolean    For Zmask, only render what is behind solid z values instead of in front
-SceneRenderLayer.ztransp -> use_ztransp:    boolean    Render Z-Transparent faces in this Layer (On top of Solid and Halos)
-SceneSequence.convert_float -> use_float:    boolean    Convert input to float data
-SceneSequence.de_interlace -> use_deinterlace:    boolean    For video movies to remove fields
-SceneSequence.flip_x -> use_flip_x:    boolean    Flip on the X axis
-SceneSequence.flip_y -> use_flip_y:    boolean    Flip on the Y axis
-SceneSequence.premultiply -> use_premultiply:    boolean    Convert RGB from key alpha to premultiplied alpha
-SceneSequence.proxy_custom_directory -> use_proxy_custom_directory:    boolean    Use a custom directory to store data
-SceneSequence.proxy_custom_file -> use_proxy_custom_file:    boolean    Use a custom file to read proxy data from
-SceneSequence.reverse_frames -> use_reverse_frames:    boolean    Reverse frame order
-SceneSequence.use_color_balance -> use_color_balance:    boolean    (3-Way color correction) on input
-SceneSequence.use_crop -> use_crop:    boolean    Crop image before processing
-SceneSequence.use_proxy -> use_proxy:    boolean    Use a preview proxy for this strip
-SceneSequence.use_translation -> use_translation:    boolean    Translate image before processing
-Scopes.use_full_resolution -> use_full_resolution:    boolean    Sample every pixel of the image
-Screen.animation_playing -> is_animation_playing:    boolean, (read-only)    Animation playback is active
-Screen.fullscreen -> is_fullscreen:    boolean, (read-only)    An area is maximised, filling this screen
-ScrewModifier.use_normal_calculate -> use_normal_calculate:    boolean    Calculate the order of edges (needed for meshes, but not curves)
-ScrewModifier.use_normal_flip -> use_normal_flip:    boolean    Flip normals of lathed faces
-ScrewModifier.use_object_screw_offset -> use_object_screw_offset:    boolean    Use the distance between the objects to make a screw
-Sculpt.lock_x -> lock_x:    boolean    Disallow changes to the X axis of vertices
-Sculpt.lock_y -> lock_y:    boolean    Disallow changes to the Y axis of vertices
-Sculpt.lock_z -> lock_z:    boolean    Disallow changes to the Z axis of vertices
-Sculpt.symmetry_x -> use_symmetry_x:    boolean    Mirror brush across the X axis
-Sculpt.symmetry_y -> use_symmetry_y:    boolean    Mirror brush across the Y axis
-Sculpt.symmetry_z -> use_symmetry_z:    boolean    Mirror brush across the Z axis
-Sensor.expanded -> show_expanded:    boolean    Set sensor expanded in the user interface
-Sensor.invert -> invert:    boolean    Invert the level(output) of this sensor
-Sensor.level -> use_level:    boolean    Level detector, trigger controllers of new states (only applicable upon logic state transition)
-Sensor.pulse_false_level -> use_pulse_false_level:    boolean    Activate FALSE level triggering (pulse mode)
-Sensor.pulse_true_level -> use_pulse_true_level:    boolean    Activate TRUE level triggering (pulse mode)
-Sensor.tap -> use_tap:    boolean    Trigger controllers only for an instant, even while the sensor remains true
-Sequence.frame_locked -> use_frame_lock:    boolean    Lock the animation curve to the global frame counter
-Sequence.lock -> lock:    boolean    Lock strip so that it can't be transformed
-Sequence.mute -> mute:    boolean
-Sequence.use_effect_default_fade -> use_default_fade:    boolean    Fade effect using the built-in default (usually make transition as long as effect strip)
-SequenceColorBalance.inverse_gain -> invert_gain:    boolean
-SequenceColorBalance.inverse_gamma -> invert_gamma:    boolean
-SequenceColorBalance.inverse_lift -> invert_lift:    boolean
-ShaderNodeExtendedMaterial.diffuse -> use_diffuse:    boolean    Material Node outputs Diffuse
-ShaderNodeExtendedMaterial.invert_normal -> invert_normal:    boolean    Material Node uses inverted normal
-ShaderNodeExtendedMaterial.specular -> use_specular:    boolean    Material Node outputs Specular
-ShaderNodeMapping.clamp_maximum -> use_max:    boolean    Clamp the output coordinate to a maximum value
-ShaderNodeMapping.clamp_minimum -> use_min:    boolean    Clamp the output coordinate to a minimum value
-ShaderNodeMaterial.diffuse -> use_diffuse:    boolean    Material Node outputs Diffuse
-ShaderNodeMaterial.invert_normal -> invert_normal:    boolean    Material Node uses inverted normal
-ShaderNodeMaterial.specular -> use_specular:    boolean    Material Node outputs Specular
-ShaderNodeMixRGB.alpha -> use_alpha:    boolean    Include alpha of second input in this operation
-ShapeActionActuator.continue_last_frame -> use_continue_last_frame:    boolean    Restore last frame when switching on/off, otherwise play from the start each time
-ShapeKey.mute -> mute:    boolean    Mute this shape key
-ShrinkwrapModifier.cull_back_faces -> use_cull_back_faces:    boolean    Stop vertices from projecting to a back face on the target
-ShrinkwrapModifier.cull_front_faces -> use_cull_front_faces:    boolean    Stop vertices from projecting to a front face on the target
-ShrinkwrapModifier.keep_above_surface -> use_keep_above_surface:    boolean
-ShrinkwrapModifier.negative -> use_negative_direction:    boolean    Allow vertices to move in the negative direction of axis
-ShrinkwrapModifier.positive -> use_positive_direction:    boolean    Allow vertices to move in the positive direction of axis
-ShrinkwrapModifier.x -> use_project_x:    boolean
-ShrinkwrapModifier.y -> use_project_y:    boolean
-ShrinkwrapModifier.z -> use_project_z:    boolean
-SimpleDeformModifier.lock_x_axis -> lock_x:    boolean
-SimpleDeformModifier.lock_y_axis -> lock_y:    boolean
-SimpleDeformModifier.relative -> use_relative:    boolean    Sets the origin of deform space to be relative to the object
-SmokeDomainSettings.dissolve_smoke -> use_dissolve_smoke:    boolean    Enable smoke to disappear over time
-SmokeDomainSettings.dissolve_smoke_log -> use_dissolve_smoke_log:    boolean    Using 1/x
-SmokeDomainSettings.highres -> use_high_resolution:    boolean    Enable high resolution (using amplification)
-SmokeDomainSettings.initial_velocity -> use_initial_velocity:    boolean    Smoke inherits it's velocity from the emitter particle
-SmokeDomainSettings.viewhighres -> show_high_resolution:    boolean    Show high resolution (using amplification)
-NEGATE * SmokeFlowSettings.outflow -> use_outflow:    boolean    Deletes smoke from simulation
-SmoothModifier.x -> use_x:    boolean
-SmoothModifier.y -> use_y:    boolean
-SmoothModifier.z -> use_z:    boolean
-SoftBodySettings.auto_step -> use_auto_step:    boolean    Use velocities for automagic step sizes
-SoftBodySettings.diagnose -> use_diagnose:    boolean    Turn on SB diagnose console prints
-SoftBodySettings.edge_collision -> use_edge_collision:    boolean    Edges collide too
-SoftBodySettings.estimate_matrix -> use_estimate_matrix:    boolean    estimate matrix .. split to COM , ROT ,SCALE
-SoftBodySettings.face_collision -> use_face_collision:    boolean    Faces collide too, SLOOOOOW warning
-SoftBodySettings.new_aero -> use_new_aero:    boolean    New aero(uses angle and length)
-SoftBodySettings.self_collision -> use_self_collision:    boolean    Enable naive vertex ball self collision
-SoftBodySettings.stiff_quads -> use_stiff_quads:    boolean    Adds diagonal springs on 4-gons
-SoftBodySettings.use_edges -> use_edges:    boolean    Use Edges as springs
-SoftBodySettings.use_goal -> use_goal:    boolean    Define forces for vertices to stick to animated position
-SolidifyModifier.invert -> invert_vertex_group:    boolean    Invert the vertex group influence
-SolidifyModifier.use_even_offset -> use_even_offset:    boolean    Maintain thickness by adjusting for sharp corners (slow, disable when not needed)
-SolidifyModifier.use_quality_normals -> use_quality_normals:    boolean    Calculate normals which result in more even thickness (slow, disable when not needed)
-SolidifyModifier.use_rim -> use_rim:    boolean    Create edge loops between the inner and outer surfaces on face edges (slow, disable when not needed)
-SolidifyModifier.use_rim_material -> use_rim_material:    boolean    Use in the next material for rim faces
-Sound.caching -> use_ram_cache:    boolean    The sound file is decoded and loaded into RAM
-SoundActuator.enable_sound_3d -> use_3d_sound:    boolean    Enable/Disable 3D Sound
-SpaceConsole.show_report_debug -> show_report_debug:    boolean    Display debug reporting info
-SpaceConsole.show_report_error -> show_report_error:    boolean    Display error text
-SpaceConsole.show_report_info -> show_report_info:    boolean    Display general information
-SpaceConsole.show_report_operator -> show_report_operator:    boolean    Display the operator log
-SpaceConsole.show_report_warn -> show_report_warning:    boolean    Display warnings
-SpaceDopeSheetEditor.automerge_keyframes -> use_automerge_keyframes:    boolean    Automatically merge nearby keyframes
-SpaceDopeSheetEditor.realtime_updates -> use_realtime_updates:    boolean    When transforming keyframes, changes to the animation data are flushed to other views
-SpaceDopeSheetEditor.show_cframe_indicator -> show_frame_indicator:    boolean    Show frame number beside the current frame indicator line
-SpaceDopeSheetEditor.show_seconds -> show_seconds:    boolean, (read-only)    Show timing in seconds not frames
-SpaceDopeSheetEditor.show_sliders -> show_sliders:    boolean    Show sliders beside F-Curve channels
-SpaceDopeSheetEditor.use_marker_sync -> use_marker_sync:    boolean    Sync Markers with keyframe edits
-SpaceGraphEditor.automerge_keyframes -> use_automerge_keyframes:    boolean    Automatically merge nearby keyframes
-SpaceGraphEditor.has_ghost_curves -> has_ghost_curves:    boolean    Graph Editor instance has some ghost curves stored
-SpaceGraphEditor.only_selected_curves_handles -> use_only_selected_curves_handles:    boolean    Only keyframes of selected F-Curves are visible and editable
-SpaceGraphEditor.only_selected_keyframe_handles -> use_only_selected_keyframe_handles:    boolean    Only show and edit handles of selected keyframes
-SpaceGraphEditor.realtime_updates -> use_realtime_updates:    boolean    When transforming keyframes, changes to the animation data are flushed to other views
-SpaceGraphEditor.show_cframe_indicator -> show_frame_indicator:    boolean    Show frame number beside the current frame indicator line
-SpaceGraphEditor.show_cursor -> show_cursor:    boolean    Show 2D cursor
-SpaceGraphEditor.show_handles -> show_handles:    boolean    Show handles of Bezier control points
-SpaceGraphEditor.show_seconds -> show_seconds:    boolean, (read-only)    Show timing in seconds not frames
-SpaceGraphEditor.show_sliders -> show_sliders:    boolean    Show sliders beside F-Curve channels
-SpaceImageEditor.draw_repeated -> show_repeated:    boolean    Draw the image repeated outside of the main view
-SpaceImageEditor.image_painting -> use_image_paint:    boolean    Enable image painting mode
-SpaceImageEditor.image_pin -> use_image_pin:    boolean    Display current image regardless of object selection
-SpaceImageEditor.show_paint -> show_paint:    boolean, (read-only)    Show paint related properties
-SpaceImageEditor.show_render -> show_render:    boolean, (read-only)    Show render related properties
-SpaceImageEditor.show_uvedit -> show_uvedit:    boolean, (read-only)    Show UV editing related properties
-SpaceImageEditor.update_automatically -> use_realtime_updates:    boolean    Update other affected window spaces automatically to reflect changes during interactive operations such as transform
-SpaceImageEditor.use_grease_pencil -> use_grease_pencil:    boolean    Display and edit the grease pencil freehand annotations overlay
-SpaceLogicEditor.actuators_show_active_objects -> show_actuators_active_objects:    boolean    Show actuators of active object
-SpaceLogicEditor.actuators_show_active_states -> show_actuators_active_states:    boolean    Show only actuators connected to active states
-SpaceLogicEditor.actuators_show_linked_controller -> show_actuators_linked_controller:    boolean    Show linked objects to the actuator
-SpaceLogicEditor.actuators_show_selected_objects -> show_actuators_selected_objects:    boolean    Show actuators of all selected objects
-SpaceLogicEditor.controllers_show_active_objects -> show_controllers_active_objects:    boolean    Show controllers of active object
-SpaceLogicEditor.controllers_show_linked_controller -> show_controllers_linked_controller:    boolean    Show linked objects to sensor/actuator
-SpaceLogicEditor.controllers_show_selected_objects -> show_controllers_selected_objects:    boolean    Show controllers of all selected objects
-SpaceLogicEditor.sensors_show_active_objects -> show_sensors_active_objects:    boolean    Show sensors of active object
-SpaceLogicEditor.sensors_show_active_states -> show_sensors_active_states:    boolean    Show only sensors connected to active states
-SpaceLogicEditor.sensors_show_linked_controller -> show_sensors_linked_controller:    boolean    Show linked objects to the controller
-SpaceLogicEditor.sensors_show_selected_objects -> show_sensors_selected_objects:    boolean    Show sensors of all selected objects
-SpaceNLA.realtime_updates -> use_realtime_updates:    boolean    When transforming strips, changes to the animation data are flushed to other views
-SpaceNLA.show_cframe_indicator -> show_frame_indicator:    boolean    Show frame number beside the current frame indicator line
-SpaceNLA.show_seconds -> show_seconds:    boolean, (read-only)    Show timing in seconds not frames
-SpaceNLA.show_strip_curves -> show_strip_curves:    boolean    Show influence curves on strips
-SpaceNodeEditor.backdrop -> show_backdrop:    boolean    Use active Viewer Node output as backdrop for compositing nodes
-SpaceOutliner.match_case_sensitive -> use_match_case_sensitive:    boolean    Only use case sensitive matches of search string
-SpaceOutliner.match_complete -> use_match_complete:    boolean    Only use complete matches of search string
-SpaceOutliner.show_restriction_columns -> show_restriction_columns:    boolean    Show column
-SpaceProperties.brush_texture -> show_brush_texture:    boolean    Show brush textures
-SpaceProperties.use_pin_id -> use_pin_id:    boolean    Use the pinned context
-SpaceSequenceEditor.draw_frames -> show_frames:    boolean    Draw frames rather than seconds
-SpaceSequenceEditor.draw_safe_margin -> show_safe_margin:    boolean    Draw title safe margins in preview
-SpaceSequenceEditor.separate_color_preview -> show_separate_color:    boolean    Separate color channels in preview
-SpaceSequenceEditor.show_cframe_indicator -> show_frame_indicator:    boolean    Show frame number beside the current frame indicator line
-SpaceSequenceEditor.use_grease_pencil -> use_grease_pencil:    boolean    Display and edit the grease pencil freehand annotations overlay
-SpaceSequenceEditor.use_marker_sync -> use_marker_sync:    boolean    Transform markers as well as strips
-SpaceTextEditor.find_all -> use_find_all:    boolean    Search in all text datablocks, instead of only the active one
-SpaceTextEditor.find_wrap -> use_find_wrap:    boolean    Search again from the start of the file when reaching the end
-SpaceTextEditor.line_numbers -> show_line_numbers:    boolean    Show line numbers next to the text
-SpaceTextEditor.live_edit -> use_live_edit:    boolean    Run python while editing
-SpaceTextEditor.overwrite -> use_overwrite:    boolean    Overwrite characters when typing rather than inserting them
-SpaceTextEditor.syntax_highlight -> show_syntax_highlight:    boolean    Syntax highlight for scripting
-SpaceTextEditor.word_wrap -> use_word_wrap:    boolean    Wrap words if there is not enough horizontal space
-SpaceTimeline.only_selected -> show_only_selected:    boolean    Show keyframes for active Object and/or its selected channels only
-SpaceTimeline.play_all_3d -> use_play_3d_editors:    boolean
-SpaceTimeline.play_anim -> use_play_animation_editors:    boolean
-SpaceTimeline.play_buttons -> use_play_properties_editors:    boolean
-SpaceTimeline.play_image -> use_play_image_editors:    boolean
-SpaceTimeline.play_nodes -> use_play_node_editors:    boolean
-SpaceTimeline.play_sequencer -> use_play_sequence_editors:    boolean
-SpaceTimeline.play_top_left -> use_play_top_left_3d_editor:    boolean
-SpaceTimeline.show_cframe_indicator -> show_frame_indicator:    boolean    Show frame number beside the current frame indicator line
-SpaceUVEditor.constrain_to_image_bounds -> use_constrain_to_image_bounds:    boolean    Constraint to stay within the image bounds while editing
-SpaceUVEditor.draw_modified_edges -> show_modified_edges:    boolean    Draw edges after modifiers are applied
-SpaceUVEditor.draw_other_objects -> show_other_objects:    boolean    Draw other selected objects that share the same image
-SpaceUVEditor.draw_smooth_edges -> show_smooth_edges:    boolean    Draw UV edges anti-aliased
-SpaceUVEditor.draw_stretch -> show_stretch:    boolean    Draw faces colored according to the difference in shape between UVs and their 3D coordinates (blue for low distortion, red for high distortion)
-SpaceUVEditor.live_unwrap -> use_live_unwrap:    boolean    Continuously unwrap the selected UV island while transforming pinned vertices
-SpaceUVEditor.normalized_coordinates -> show_normalized_coordinates:    boolean    Display UV coordinates from 0.0 to 1.0 rather than in pixels
-SpaceUVEditor.snap_to_pixels -> use_snap_to_pixels:    boolean    Snap UVs to pixel locations while editing
-SpaceView3D.all_object_origins -> show_all_objects_origin:    boolean    Show the object origin center dot for all (selected and unselected) objects
-SpaceView3D.display_background_images -> show_background_images:    boolean    Display reference images behind objects in the 3D View
-SpaceView3D.display_floor -> show_floor:    boolean    Show the ground plane grid in perspective view
-SpaceView3D.display_render_override -> show_only_render:    boolean    Display only objects which will be rendered
-SpaceView3D.display_x_axis -> show_axis_x:    boolean    Show the X axis line in perspective view
-SpaceView3D.display_y_axis -> show_axis_y:    boolean    Show the Y axis line in perspective view
-SpaceView3D.display_z_axis -> show_axis_z:    boolean    Show the Z axis line in perspective view
-SpaceView3D.layers -> layers:    boolean    Layers visible in this 3D View
-SpaceView3D.lock_camera_and_layers -> lock_camera_and_layers:    boolean    Use the scene's active camera and layers in this view, rather than local layers
-SpaceView3D.manipulator -> use_manipulator:    boolean    Use a 3D manipulator widget for controlling transforms
-SpaceView3D.manipulator_rotate -> use_manipulator_rotate:    boolean    Use the manipulator for rotation transformations
-SpaceView3D.manipulator_scale -> use_manipulator_scale:    boolean    Use the manipulator for scale transformations
-SpaceView3D.manipulator_translate -> use_manipulator_translate:    boolean    Use the manipulator for movement transformations
-SpaceView3D.occlude_geometry -> use_occlude_geometry:    boolean    Limit selection to visible (clipped with depth buffer)
-SpaceView3D.outline_selected -> show_outline_selected:    boolean    Show an outline highlight around selected objects in non-wireframe views
-SpaceView3D.pivot_point_align -> use_pivot_point_align:    boolean    Manipulate object centers only
-SpaceView3D.relationship_lines -> show_relationship_lines:    boolean    Show dashed lines indicating parent or constraint relationships
-SpaceView3D.textured_solid -> show_textured_solid:    boolean    Display face-assigned textures in solid view
-SpaceView3D.used_layers -> layers_used:    boolean, (read-only)    Layers that contain something
-SpeedControlSequence.curve_compress_y -> use_curve_compress_y:    boolean    Scale F-Curve value to get the target frame number, F-Curve value runs from 0.0 to 1.0
-SpeedControlSequence.curve_velocity -> use_curve_velocity:    boolean    Interpret the F-Curve value as a velocity instead of a frame number
-SpeedControlSequence.frame_blending -> use_frame_blend:    boolean    Blend two frames into the target for a smoother result
-Spline.bezier_u -> use_bezier_u:    boolean    Make this nurbs curve or surface act like a bezier spline in the U direction (Order U must be 3 or 4, Cyclic U must be disabled)
-Spline.bezier_v -> use_bezier_v:    boolean    Make this nurbs surface act like a bezier spline in the V direction (Order V must be 3 or 4, Cyclic V must be disabled)
-Spline.cyclic_u -> use_cyclic_u:    boolean    Make this curve or surface a closed loop in the U direction
-Spline.cyclic_v -> use_cyclic_v:    boolean    Make this surface a closed loop in the V direction
-Spline.endpoint_u -> use_endpoint_u:    boolean    Make this nurbs curve or surface meet the endpoints in the U direction (Cyclic U must be disabled)
-Spline.endpoint_v -> use_endpoint_v:    boolean    Make this nurbs surface meet the endpoints in the V direction (Cyclic V must be disabled)
-Spline.hide -> hide:    boolean    Hide this curve in editmode
-Spline.smooth -> use_smooth:    boolean    Smooth the normals of the surface or beveled curve
-SplineIKConstraint.chain_offset -> use_chain_offset:    boolean    Offset the entire chain relative to the root joint
-SplineIKConstraint.even_divisions -> use_even_divisions:    boolean    Ignore the relative lengths of the bones when fitting to the curve
-SplineIKConstraint.use_curve_radius -> use_curve_radius:    boolean    Average radius of the endpoints is used to tweak the X and Z Scaling of the bones, on top of XZ Scale mode
-SplineIKConstraint.y_stretch -> use_y_stretch:    boolean    Stretch the Y axis of the bones to fit the curve
-
-SpotLamp.auto_clip_end -> use_auto_clip_end:    boolean    Automatic calculation of clipping-end, based on visible vertices
-SpotLamp.auto_clip_start -> use_auto_clip_start:    boolean    Automatic calculation of clipping-start, based on visible vertices
-SpotLamp.halo -> use_halo:    boolean    Renders spotlight with a volumetric halo (Buffer Shadows)
-SpotLamp.only_shadow -> use_only_shadow:    boolean    Causes light to cast shadows only without illuminating objects
-SpotLamp.shadow_layer -> use_shadow_layer:    boolean    Causes only objects on the same layer to cast shadows
-SpotLamp.show_cone -> show_cone:    boolean    Draw transparent cone in 3D view to visualize which objects are contained in it
-SpotLamp.sphere -> use_sphere:    boolean    Sets light intensity to zero beyond lamp distance
-SpotLamp.square -> use_square:    boolean    Casts a square spot light shape
-StateActuator.state -> states:    boolean
-SubsurfModifier.optimal_display -> show_only_control_edges:    boolean    Skip drawing/rendering of interior subdivided edges
-SubsurfModifier.subsurf_uv -> use_subsurf_uv:    boolean    Use subsurf to subdivide UVs
-SunLamp.only_shadow -> use_only_shadow:    boolean    Causes light to cast shadows only without illuminating objects
-SunLamp.shadow_layer -> use_shadow_layer:    boolean    Causes only objects on the same layer to cast shadows
-SurfaceCurve.map_along_length -> use_map_along_length:    boolean    Generate texture mapping coordinates following the curve direction, rather than the local bounding box
-SurfaceCurve.vertex_normal_flip -> use_vertex_normal_flip:    boolean    Flip vertex normals towards the camera during render
-TexMapping.has_maximum -> use_max:    boolean    Whether to use maximum clipping value
-TexMapping.has_minimum -> use_min:    boolean    Whether to use minimum clipping value
-Text.dirty -> is_dirty:    boolean, (read-only)    Text file has been edited since last save
-Text.memory -> is_in_memory:    boolean, (read-only)    Text file is in memory, without a corresponding file on disk
-Text.modified -> is_modified:    boolean, (read-only)    Text file on disk is different than the one in memory
-Text.tabs_as_spaces -> use_tabs_as_spaces:    boolean    Automatically converts all new tabs into spaces
-Text.use_module -> use_module:    boolean    Register this text as a module on loading, Text name must end with '.py'
-TextCharacterFormat.bold -> use_bold:    boolean
-TextCharacterFormat.italic -> use_italic:    boolean
-TextCharacterFormat.style -> use_style:    boolean
-TextCharacterFormat.underline -> use_underline:    boolean
-TextCharacterFormat.wrap -> use_wrap:    boolean
-TextCurve.fast -> use_fast_editing:    boolean    Don't fill polygons while editing
-TextCurve.map_along_length -> use_map_along_length:    boolean    Generate texture mapping coordinates following the curve direction, rather than the local bounding box
-TextCurve.vertex_normal_flip -> use_vertex_normal_flip:    boolean    Flip vertex normals towards the camera during render
-TextMarker.edit_all -> use_edit_all:    boolean, (read-only)    Edit all markers of the same group as one
-TextMarker.temporary -> is_temporary:    boolean, (read-only)    Marker is temporary
-Texture.use_color_ramp -> use_color_ramp:    boolean    Toggle color ramp operations
-Texture.use_nodes -> use_nodes:    boolean    Make this a node-based texture
-Texture.use_preview_alpha -> use_preview_alpha:    boolean    Show Alpha in Preview Render
-TextureNodeMixRGB.alpha -> use_alpha:    boolean    Include alpha of second input in this operation
-TextureSlot.negate -> invert:    boolean    Inverts the values of the texture to reverse its effect
-TextureSlot.rgb_to_intensity -> use_rgb_to_intensity:    boolean    Converts texture RGB values to intensity (gray) values
-TextureSlot.stencil -> use_stencil:    boolean    Use this texture as a blending value on the next texture
-ThemeBoneColorSet.colored_constraints -> show_colored_constraints:    boolean    Allow the use of colors indicating constraints/keyed status
-ThemeWidgetColors.shaded -> show_shaded:    boolean
-ToolSettings.auto_normalize -> use_auto_normalize:    boolean    Ensure all bone-deforming vertex groups add up to 1.0 while weight painting
-ToolSettings.automerge_editing -> use_automerge_editing:    boolean    Automatically merge vertices moved to the same location
-ToolSettings.bone_sketching -> use_bone_sketching:    boolean    DOC BROKEN
-ToolSettings.etch_autoname -> use_etch_autoname:    boolean    DOC BROKEN
-ToolSettings.etch_overdraw -> use_etch_overdraw:    boolean    DOC BROKEN
-ToolSettings.etch_quick -> use_etch_quick:    boolean    DOC BROKEN
-ToolSettings.mesh_selection_mode -> mesh_selection_mode:    boolean    Which mesh elements selection works on
-ToolSettings.record_with_nla -> use_record_with_nla:    boolean    Add a new NLA Track + Strip for every loop/pass made over the animation to allow non-destructive tweaking
-ToolSettings.snap -> use_snap:    boolean    Snap during transform
-ToolSettings.snap_align_rotation -> use_snap_align_rotation:    boolean    Align rotation with the snapping target
-ToolSettings.snap_peel_object -> use_snap_peel_object:    boolean    Consider objects as whole when finding volume center
-ToolSettings.snap_project -> use_snap_project:    boolean    Project vertices on the surface of other objects
-ToolSettings.use_auto_keying -> use_keyframe_insert_auto:    boolean    Automatic keyframe insertion for Objects and Bones
-ToolSettings.uv_local_view -> show_local_view:    boolean    Draw only faces with the currently displayed image assigned
-ToolSettings.uv_sync_selection -> use_uv_sync_selection:    boolean    Keep UV and edit mode mesh selection in sync
-TrackToConstraint.target_z -> use_target_z:    boolean    Target's Z axis, not World Z axis, will constraint the Up direction
-TransformConstraint.extrapolate_motion -> use_motion_extrapolate:    boolean    Extrapolate ranges
-TransformSequence.uniform_scale -> use_uniform_scale:    boolean    Scale uniformly, preserving aspect ratio
-UILayout.active -> show_active:    boolean
-UILayout.enabled -> show_enabled:    boolean
-UVProjectModifier.override_image -> use_image_override:    boolean    Override faces' current images with the given image
-UnitSettings.use_separate -> use_separate:    boolean    Display units in pairs
-UserPreferencesEdit.auto_keyframe_insert_available -> use_keyframe_insert_available:    boolean    Automatic keyframe insertion in available curves
-UserPreferencesEdit.auto_keyframe_insert_keyingset -> use_keyframe_insert_keyingset:    boolean    Automatic keyframe insertion using active Keying Set
-UserPreferencesEdit.drag_immediately -> use_drag_immediately:    boolean    Moving things with a mouse drag confirms when releasing the button
-UserPreferencesEdit.duplicate_action -> use_duplicate_action:    boolean    Causes actions to be duplicated with the object
-UserPreferencesEdit.duplicate_armature -> use_duplicate_armature:    boolean    Causes armature data to be duplicated with the object
-UserPreferencesEdit.duplicate_curve -> use_duplicate_curve:    boolean    Causes curve data to be duplicated with the object
-UserPreferencesEdit.duplicate_fcurve -> use_duplicate_fcurve:    boolean    Causes F-curve data to be duplicated with the object
-UserPreferencesEdit.duplicate_lamp -> use_duplicate_lamp:    boolean    Causes lamp data to be duplicated with the object
-UserPreferencesEdit.duplicate_material -> use_duplicate_material:    boolean    Causes material data to be duplicated with the object
-UserPreferencesEdit.duplicate_mesh -> use_duplicate_mesh:    boolean    Causes mesh data to be duplicated with the object
-UserPreferencesEdit.duplicate_metaball -> use_duplicate_metaball:    boolean    Causes metaball data to be duplicated with the object
-UserPreferencesEdit.duplicate_particle -> use_duplicate_particle:    boolean    Causes particle systems to be duplicated with the object
-UserPreferencesEdit.duplicate_surface -> use_duplicate_surface:    boolean    Causes surface data to be duplicated with the object
-UserPreferencesEdit.duplicate_text -> use_duplicate_text:    boolean    Causes text data to be duplicated with the object
-UserPreferencesEdit.duplicate_texture -> use_duplicate_texture:    boolean    Causes texture data to be duplicated with the object
-UserPreferencesEdit.enter_edit_mode -> use_enter_edit_mode:    boolean    Enter Edit Mode automatically after adding a new object
-UserPreferencesEdit.global_undo -> use_global_undo:    boolean    Global undo works by keeping a full copy of the file itself in memory, so takes extra memory
-UserPreferencesEdit.grease_pencil_simplify_stroke -> use_grease_pencil_simplify_stroke:    boolean    Simplify the final stroke
-UserPreferencesEdit.grease_pencil_smooth_stroke -> use_grease_pencil_smooth_stroke:    boolean    Smooth the final stroke
-UserPreferencesEdit.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:    boolean    Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis
-UserPreferencesEdit.keyframe_insert_needed -> use_keyframe_insert_needed:    boolean    Keyframe insertion only when keyframe needed
-UserPreferencesEdit.use_auto_keying -> use_auto_keying:    boolean    Automatic keyframe insertion for Objects and Bones
-UserPreferencesEdit.use_negative_frames -> use_negative_frames:    boolean    Current frame number can be manually set to a negative value
-UserPreferencesEdit.use_visual_keying -> use_visual_keying:    boolean    Use Visual keying automatically for constrained objects
-UserPreferencesFilePaths.auto_save_temporary_files -> use_auto_save_temporary_files:    boolean    Automatic saving of temporary files
-UserPreferencesFilePaths.compress_file -> use_file_compression:    boolean    Enable file compression when saving .blend files
-UserPreferencesFilePaths.filter_file_extensions -> use_filter_files:    boolean    Display only files with extensions in the image select window
-UserPreferencesFilePaths.hide_dot_files_datablocks -> show_hidden_files_datablocks:    boolean    Hide files/datablocks that start with a dot(.*)
-UserPreferencesFilePaths.load_ui -> use_load_ui:    boolean    Load user interface setup when loading .blend files
-UserPreferencesFilePaths.save_preview_images -> use_save_preview_images:    boolean    Enables automatic saving of preview images in the .blend file
-UserPreferencesFilePaths.use_relative_paths -> use_relative_paths:    boolean    Default relative path option for the file selector
-UserPreferencesInput.continuous_mouse -> use_continuous_mouse:    boolean    Allow moving the mouse outside the view on some manipulations (transform, ui control drag)
-UserPreferencesInput.emulate_3_button_mouse -> use_emulate_3_button_mouse:    boolean    Emulates Middle Mouse with Alt+LeftMouse (doesn't work with Left Mouse Select option)
-UserPreferencesInput.emulate_numpad -> use_emulate_numpad:    boolean    Causes the 1 to 0 keys to act as the numpad (useful for laptops)
-UserPreferencesInput.invert_zoom_direction -> invert_zoom_direction:    boolean    Invert the axis of mouse movement for zooming
-UserPreferencesSystem.auto_execute_scripts -> use_scripts_auto_execute:    boolean    Allow any .blend file to run scripts automatically (unsafe with blend files from an untrusted source)
-UserPreferencesSystem.enable_all_codecs -> use_preview_images:    boolean    Enables automatic saving of preview images in the .blend file (Windows only)
-UserPreferencesSystem.international_fonts -> use_international_fonts:    boolean    Use international fonts
-UserPreferencesSystem.tabs_as_spaces -> use_tabs_as_spaces:    boolean    Automatically converts all new tabs into spaces for new and loaded text files
-UserPreferencesSystem.translate_buttons -> use_translate_buttons:    boolean    Translate button labels
-UserPreferencesSystem.translate_toolbox -> use_translate_toolbox:    boolean    Translate toolbox menu
-UserPreferencesSystem.translate_tooltips -> use_translate_tooltips:    boolean    Translate Tooltips
-UserPreferencesSystem.use_antialiasing -> use_antialiasing:    boolean    Use anti-aliasing for the 3D view (may impact redraw performance)
-UserPreferencesSystem.use_mipmaps -> use_mipmaps:    boolean    Scale textures for the 3D View (looks nicer but uses more memory and slows image reloading)
-UserPreferencesSystem.use_textured_fonts -> use_textured_fonts:    boolean    Use textures for drawing international fonts
-UserPreferencesSystem.use_vbos -> use_vertex_buffer_objects:    boolean    Use Vertex Buffer Objects (or Vertex Arrays, if unsupported) for viewport rendering
-UserPreferencesSystem.use_weight_color_range -> use_weight_color_range:    boolean    Enable color range used for weight visualization in weight painting mode
-UserPreferencesView.auto_depth -> use_mouse_auto_depth:    boolean    Use the depth under the mouse to improve view pan/rotate/zoom functionality
-UserPreferencesView.auto_perspective -> use_auto_perspective:    boolean    Automatically switch between orthographic and perspective when changing from top/front/side views
-UserPreferencesView.directional_menus -> use_directional_menus:    boolean    Otherwise menus, etc will always be top to bottom, left to right, no matter opening direction
-UserPreferencesView.display_object_info -> show_object_info:    boolean    Display objects name and frame number in 3D view
-UserPreferencesView.global_pivot -> use_global_pivot:    boolean    Lock the same rotation/scaling pivot in all 3D Views
-UserPreferencesView.global_scene -> use_global_scene:    boolean    Forces the current Scene to be displayed in all Screens
-UserPreferencesView.open_mouse_over -> use_mouse_over_open:    boolean    Open menu buttons and pulldowns automatically when the mouse is hovering
-UserPreferencesView.rotate_around_selection -> use_rotate_around_selection:    boolean    Use selection as the pivot point
-UserPreferencesView.show_mini_axis -> show_mini_axis:    boolean    Show a small rotating 3D axis in the bottom left corner of the 3D View
-UserPreferencesView.show_playback_fps -> show_playback_fps:    boolean    Show the frames per second screen refresh rate, while animation is played back
-UserPreferencesView.show_splash -> show_splash:    boolean    Display splash screen on startup
-UserPreferencesView.show_view_name -> show_view_name:    boolean    Show the name of the view's direction in each 3D View
-UserPreferencesView.tooltips -> show_tooltips:    boolean    Display tooltips
-UserPreferencesView.use_column_layout -> show_column_layout:    boolean    Use a column layout for toolbox
-UserPreferencesView.use_large_cursors -> show_large_cursors:    boolean    Use large mouse cursors when available
-UserPreferencesView.use_manipulator -> show_manipulator:    boolean    Use 3D transform manipulator
-UserPreferencesView.use_middle_mouse_paste -> use_mouse_mmb_paste:    boolean    In text window, paste with middle mouse button instead of panning
-UserPreferencesView.wheel_invert_zoom -> invert_mouse_wheel_zoom:    boolean    Swap the Mouse Wheel zoom direction
-UserPreferencesView.zoom_to_mouse -> use_zoom_to_mouse:    boolean    Zoom in towards the mouse pointer's position in the 3D view, rather than the 2D window center
-UserSolidLight.enabled -> use:    boolean    Enable this OpenGL light in solid draw mode
-VertexPaint.all_faces -> use_all_faces:    boolean    Paint on all faces inside brush
-VertexPaint.normals -> use_normal:    boolean    Applies the vertex normal before painting
-VertexPaint.spray -> use_spray:    boolean    Keep applying paint effect while holding mouse
-VisibilityActuator.children -> apply_to_children:    boolean    Set all the children of this object to the same visibility/occlusion recursively
-VisibilityActuator.occlusion -> use_occlusion:    boolean    Set the object to occlude objects behind it. Initialized from the object type in physics button
-VisibilityActuator.visible -> use_visible:    boolean    Set the objects visible. Initialized from the objects render restriction toggle (access in the outliner)
-VoxelData.still -> use_still_frame:    boolean    Always render a still frame from the voxel data sequence
-WaveModifier.cyclic -> use_cyclic:    boolean    Cyclic wave effect
-WaveModifier.normals -> use_normal:    boolean    Displace along normal
-WaveModifier.x -> use_x:    boolean    X axis motion
-WaveModifier.x_normal -> use_normal_x:    boolean    Enable displacement along the X normal
-WaveModifier.y -> use_y:    boolean    Y axis motion
-WaveModifier.y_normal -> use_normal_y:    boolean    Enable displacement along the Y normal
-WaveModifier.z_normal -> use_normal_z:    boolean    Enable displacement along the Z normal
-World.blend_sky -> use_sky_blend:    boolean    Render background with natural progression from horizon to zenith
-World.paper_sky -> use_sky_paper:    boolean    Flatten blend or texture coordinates
-World.real_sky -> use_sky_real:    boolean    Render background with a real horizon, relative to the camera angle
-WorldLighting.falloff -> use_falloff:    boolean
-WorldLighting.pixel_cache -> use_cache:    boolean    Cache AO results in pixels and interpolate over neighbouring pixels for speedup (for Approximate)
-WorldLighting.use_ambient_occlusion -> use_ambient_occlusian:    boolean    Use Ambient Occlusion to add shadowing based on distance between objects
-WorldLighting.use_environment_lighting -> use_environment_lighting:    boolean    Add light coming from the environment
-WorldLighting.use_indirect_lighting -> use_indirect_lighting:    boolean    Add indirect light bouncing of surrounding objects
-WorldMistSettings.use_mist -> use_mist:    boolean    Occlude objects with the environment color as they are further away
-WorldStarsSettings.use_stars -> use_stars:    boolean    Enable starfield generation
-WorldTextureSlot.map_blend -> use_map_blend:    boolean    Affect the color progression of the background
-WorldTextureSlot.map_horizon -> use_map_horizon:    boolean    Affect the color of the horizon
-WorldTextureSlot.map_zenith_down -> use_map_zenith_down:    boolean    Affect the color of the zenith below
-WorldTextureSlot.map_zenith_up -> use_map_zenith_up:    boolean    Affect the color of the zenith above
diff --git a/source/blender/makesrna/rna_cleanup/rna_cleaner.py b/source/blender/makesrna/rna_cleanup/rna_cleaner.py
index a0ce76d261d..a2909923388 100755
--- a/source/blender/makesrna/rna_cleanup/rna_cleaner.py
+++ b/source/blender/makesrna/rna_cleanup/rna_cleaner.py
@@ -6,6 +6,9 @@ This script is used to help cleaning RNA api.
 Typical line in the input file (elements in [] are optional).
 
 [comment *] ToolSettings.snap_align_rotation -> use_snap_align_rotation:    boolean    [Align rotation with the snapping target]
+
+Geterate output format from blender run this:
+ ./blender.bin --background --python ./release/scripts/modules/rna_info.py > source/blender/makesrna/rna_cleanup/out.txt
 """
 
 
@@ -189,11 +192,14 @@ def sort(props_list, sort_priority):
     """
 
     # order based on the i-th element in lists
-    i = sort_choices.index(sort_priority)
-    if i == 0:
-        props_list = sorted(props_list, key=lambda p: p[i], reverse=True)
+    if sort_priority == "class.from":
+        props_list = sorted(props_list, key=lambda p: (p[2], p[3]))
     else:
-        props_list = sorted(props_list, key=lambda p: p[i])
+        i = sort_choices.index(sort_priority)
+        if i == 0:
+            props_list = sorted(props_list, key=lambda p: p[i], reverse=True)
+        else:
+            props_list = sorted(props_list, key=lambda p: p[i])
         
     print ('\nSorted by %s.' % font_bold(sort_priority))
     return props_list
@@ -266,8 +272,8 @@ def main():
     global sort_choices, default_sort_choice
     global kw_prefixes, kw
 
-    sort_choices = ['note','changed','class','from','to','kw']
-    default_sort_choice = sort_choices[0]
+    sort_choices = ['note','changed','class','from','to','kw', 'class.from']
+    default_sort_choice = sort_choices[-1]
     kw_prefixes = [ 'active','apply','bl','exclude','has','invert','is','lock', \
                     'pressed','show','show_only','use','use_only','layers','states']
     kw = ['active','hide','invert','select','layers','mute','states','use','lock']
diff --git a/source/blender/makesrna/rna_cleanup/rna_cleaner_merge.py b/source/blender/makesrna/rna_cleanup/rna_cleaner_merge.py
new file mode 100644
index 00000000000..9fcaa8be3f8
--- /dev/null
+++ b/source/blender/makesrna/rna_cleanup/rna_cleaner_merge.py
@@ -0,0 +1,56 @@
+#! /usr/bin/env python3.1
+
+import sys
+
+'''
+Example usage:
+ python3 rna_cleaner_merge.py out_work.py rna_booleans_work.py
+'''
+def main():
+	
+	def work_line_id(line):
+		return line[2], line[3] # class/from
+	
+	
+	if not (sys.argv[-1].endswith(".py") and sys.argv[-2].endswith(".py")):
+		print("Only accepts 2 py files as arguments.")
+	
+	sys.path.insert(0, ".")
+
+	mod_from = __import__(sys.argv[-1][:-3])
+	mod_to = __import__(sys.argv[-2][:-3])
+	
+	mod_to_dict = dict([(work_line_id(line), line) for line in mod_to.rna_api])
+	mod_from_dict = dict([(work_line_id(line), line) for line in mod_from.rna_api])
+	
+	rna_api_new = []
+	
+	for key, val_orig in mod_to_dict.items():
+		try:
+			val = mod_from_dict.pop(key)
+		except:
+			# print("not found", key)
+			val = val_orig
+
+		rna_api_new.append(val)
+	
+	def write_work_file(file_path, rna_api):
+		rna_api = list(rna_api)
+		rna_api.sort(key=work_line_id)
+		file_out = open(file_path, "w")
+		file_out.write("rna_api = [\n")
+		for line in rna_api:
+			file_out.write("    %s,\n" % (repr(line)))
+		file_out.write("]\n")
+		file_out.close()
+
+	file_path = sys.argv[-2][:-3] + "_merged.py"
+	write_work_file(file_path, rna_api_new)
+	
+	if mod_from_dict:
+		file_path = sys.argv[-2][:-3] + "_lost.py"
+		write_work_file(file_path, list(mod_from_dict.values()))
+		print("Warning '%s' contains lost %d items from module %s.py" % (file_path, len(mod_from_dict), mod_from.__name__))
+
+if __name__ == "__main__":
+	main()
\ No newline at end of file
diff --git a/source/blender/makesrna/rna_cleanup/rna_properties.txt b/source/blender/makesrna/rna_cleanup/rna_properties.txt
index 0c0b7e1070b..187f9e7bae1 100644
--- a/source/blender/makesrna/rna_cleanup/rna_properties.txt
+++ b/source/blender/makesrna/rna_cleanup/rna_properties.txt
@@ -1,3190 +1,4605 @@
-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 -> max:    float    Maximum value for target channel range
-ActionConstraint.minimum -> min:    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_blend_type:    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_skin_frames:    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_sample_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 -> handle_left:    float    Coordinates of the first handle
-BezierSplinePoint.handle1_type -> handle_left_type:    enum    Handle types
-BezierSplinePoint.handle2 -> handle_right:    float    Coordinates of the second handle
-BezierSplinePoint.handle2_type -> handle_right_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_acc_max:    float    Maximum acceleration in air (relative to maximum speed)
-BoidSettings.air_max_ave -> air_ave_max:    float    Maximum angular velocity in air (relative to 180 degrees)
-BoidSettings.air_max_speed -> air_speed_max:    float    Maximum speed in air
-BoidSettings.air_min_speed -> air_speed_min:    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 -> bank:    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_acc_max:    float    Maximum acceleration on land (relative to maximum speed)
-BoidSettings.land_max_ave -> land_ave_max:    float    Maximum angular velocity on land (relative to 180 degrees)
-BoidSettings.land_max_speed -> land_speed_max:    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 -> land_smooth:    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_fuzzy:    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 -> distance_min:    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_distance_min:    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 -> size_x:    int    
-CompositorNodeBlur.sizey -> size_y:    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 -> blur_max:    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 -> speed_max:    int    Maximum speed, or zero for none
-CompositorNodeVecBlur.min_speed -> speed_min:    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 -> angle_max:    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 -> rotation_max:    float    Reference Direction
-ConstraintActuator.min_angle -> angle_min:    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_smooth:    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 -> color_multiply:    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_max:    float    Upper distance from Reference Value for 1:1 default influence
-FModifierEnvelope.default_minimum -> default_min:    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 -> max:    float    Upper bound of envelope at this control-point
-FModifierEnvelopeControlPoint.minimum -> min:    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 -> max_x:    float    Highest X value to allow
-FModifierLimits.maximum_y -> max_y:    float    Highest Y value to allow
-FModifierLimits.minimum_x -> min_x:    float    Lowest X value to allow
-FModifierLimits.minimum_y -> min_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 -> distance_max:    float    Maximum distance for the field to work
-FieldSettings.minimum_distance -> distance_min:    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_max:    float    Maximum radial distance for the field to work
-FieldSettings.radial_minimum -> radial_min:    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_width:    int    Thickness of strokes (in pixels)
-GPencilLayer.max_ghost_range -> ghost_range_max:    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 -> velocity_max:    float    Clamp velocity to this maximum speed
-GameObjectSettings.minimum_velocity -> velocity_min:    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 -> linear_stiffness:    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 -> weld_threshold:    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 -> step_max:    float    Higher bound for timestep in second in case of automatic substeps
-Itasc.max_velocity -> velocity_max:    float    Maximum joint velocity in rad/s. Default=50
-Itasc.min_step -> step_min:    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 -> handle_left:    float    Coordinates of the first handle
-Keyframe.handle1_type -> handle_left_type:    enum    Handle types
-Keyframe.handle2 -> handle_right:    float    Coordinates of the second handle
-Keyframe.handle2_type -> handle_right_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 -> group_method:    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_intensity:    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_intensity:    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 -> max_x:    float    Highest X value to allow
-LimitLocationConstraint.maximum_y -> max_y:    float    Highest Y value to allow
-LimitLocationConstraint.maximum_z -> max_z:    float    Highest Z value to allow
-LimitLocationConstraint.minimum_x -> min_x:    float    Lowest X value to allow
-LimitLocationConstraint.minimum_y -> min_y:    float    Lowest Y value to allow
-LimitLocationConstraint.minimum_z -> min_z:    float    Lowest Z value to allow
-LimitRotationConstraint.maximum_x -> max_x:    float    Highest X value to allow
-LimitRotationConstraint.maximum_y -> max_y:    float    Highest Y value to allow
-LimitRotationConstraint.maximum_z -> max_z:    float    Highest Z value to allow
-LimitRotationConstraint.minimum_x -> min_x:    float    Lowest X value to allow
-LimitRotationConstraint.minimum_y -> min_y:    float    Lowest Y value to allow
-LimitRotationConstraint.minimum_z -> min_z:    float    Lowest Z value to allow
-LimitScaleConstraint.maximum_x -> max_x:    float    Highest X value to allow
-LimitScaleConstraint.maximum_y -> max_y:    float    Highest Y value to allow
-LimitScaleConstraint.maximum_z -> max_z:    float    Highest Z value to allow
-LimitScaleConstraint.minimum_x -> min_x:    float    Lowest X value to allow
-LimitScaleConstraint.minimum_y -> min_y:    float    Lowest Y value to allow
-LimitScaleConstraint.minimum_z -> min_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 -> rough:    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_cast_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_hard:    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 -> hard:    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 -> size_min:    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 -> hard_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 -> light_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 -> blend_type:    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 -> 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_rough1:    string    Vertex group to control roughness 1
-ParticleSystem.vertex_group_roughness2 -> vertex_group_rough2:    string    Vertex group to control roughness 2
-ParticleSystem.vertex_group_roughness_end -> vertex_group_rough_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_soft:    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_sample_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 -> value_max:    string    Specify maximum value in Interval type
-PropertySensor.min_value -> value_min:    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_intensity:    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 -> frame_color:    float    Set colour of the bars
-SceneGameData.framing_type -> frame_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_type:    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 -> max:    float    Maximum value to clamp coordinate to
-ShaderNodeMapping.minimum -> min:    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 -> bend:    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 -> step_max:    int    Maximal # solver steps/frame
-SoftBodySettings.minstep -> step_min:    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 -> distance_3d_max:    float    The maximum distance at which you can hear the sound
-SoundActuator.maximum_gain_3d -> gain_3d_max:    float    The maximum gain of the sound, no matter how near it is
-SoundActuator.minimum_gain_3d -> gain_3d_min:    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_shade:    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_scale_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_sample_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 -> length_max:    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 -> max:    float    Maximum value for clipping
-TexMapping.minimum -> min:    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_distance:    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 -> intensity:    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 -> select:    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 -> shadow_offset_x:    int    Shadow offset in pixels
-ThemeFontStyle.shady -> shadow_offset_y:    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_edit:    enum    Proportional editing mode
-ToolSettings.proportional_editing_falloff -> proportional_edit_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_spacing_min:    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 -> color_mode:    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_type:    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 -> distance_min:    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
+NOTE * CLASS.FROM -> TO:   TYPE  DESCRIPTION
+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  'NO DESCRIPTION'
+ActionActuator.blendin -> blendin:   int  'Number of frames of motion blending'
+ActionActuator.continue_last_frame -> use_continue_last_frame:   boolean  'Restore last frame when switching on/off, otherwise play from the start each time'
+ActionActuator.frame_end -> frame_end:   int  'NO DESCRIPTION'
+ActionActuator.frame_property -> frame_property:   string  "Assign the action's current frame number to this property"
+ActionActuator.frame_start -> frame_start:   int  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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 -> max:   float  'Maximum value for target channel range'
+ActionConstraint.minimum -> min:   float  'Minimum value for target channel range'
+ActionConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
+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.expanded -> show_expanded:   boolean  'Action Group is expanded'
+ActionGroup.lock -> lock:   boolean  'Action Group is locked'
+ActionGroup.name -> name:   string  'NO DESCRIPTION'
+ActionGroup.select -> select:   boolean  'Action Group is selected'
+Actuator.expanded -> show_expanded:   boolean  'Set actuator expanded in the user interface'
+Actuator.name -> name:   string  'NO DESCRIPTION'
+Actuator.pinned -> pinned:   boolean  'Display when not linked to a visible states controller'
+Actuator.type -> type:   enum  'NO DESCRIPTION'
+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_blend_type:   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_enabled -> use_nla:   boolean  'NLA stack is evaluated when evaluating this block'
+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_skin_frames:   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.highlight_keyframes -> show_keyframe_highlight:   boolean  'Emphasize position of keyframes on Motion Paths'
+AnimVizMotionPaths.search_all_action_keyframes -> show_keyframe_action_all:   boolean  'For bone motion paths, search whole Action for keyframes instead of in group with matching name only (is slower)'
+AnimVizMotionPaths.show_frame_numbers -> show_frame_numbers:   boolean  'Show frame numbers on Motion Paths'
+AnimVizMotionPaths.show_keyframe_numbers -> show_keyframe_numbers:   boolean  'Show frame numbers of Keyframes on Motion Paths'
+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.only_selected -> show_only_selected:   boolean  'For Pose-Mode drawing, only draw ghosts for selected bones'
+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.show_menus -> show_menus:   boolean  'Show menus in the header'
+Area.spaces -> spaces:   collection,  '(read-only)    Spaces contained in this area, the first space is active'
+Area.type -> type:   enum  'Space type'
+AreaLamp.dither -> use_dither:   boolean  'Use 2x2 dithering for sampling  (Constant Jittered sampling)'
+AreaLamp.gamma -> gamma:   float  'Light gamma correction value'
+AreaLamp.jitter -> use_jitter:   boolean  'Use noise for sampling  (Constant Jittered sampling)'
+AreaLamp.only_shadow -> use_only_shadow:   boolean  'Causes light to cast shadows only without illuminating objects'
+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_layer -> use_shadow_layer:   boolean  'Causes only objects on the same layer to cast shadows'
+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_sample_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'
+AreaLamp.umbra -> use_umbra:   boolean  'Emphasize parts that are fully shadowed (Constant Jittered sampling)'
+Armature.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
+Armature.auto_ik -> use_auto_ik:   boolean  'Add temporaral IK constraints while grabbing bones in Pose Mode'
+Armature.bones -> bones:   collection,  '(read-only)'
+Armature.deform_envelope -> use_deform_envelopes:   boolean  'Enable Bone Envelopes when defining deform'
+Armature.deform_quaternion -> use_deform_preserve_volume:   boolean  'Deform rotation interpolation with quaternions'
+Armature.deform_vertexgroups -> use_deform_vertex_groups:   boolean  'Enable Vertex Groups when defining deform'
+Armature.delay_deform -> use_deform_delay:   boolean  "Don't deform children when manipulating bones in Pose Mode"
+Armature.draw_axes -> show_axes:   boolean  'Draw bone axes'
+Armature.draw_custom_bone_shapes -> show_bone_custom_shapes:   boolean  'Draw bones with their custom shapes'
+Armature.draw_group_colors -> show_group_colors:   boolean  'Draw bone group colors'
+Armature.draw_names -> show_names:   boolean  'Draw bone names'
+Armature.drawtype -> drawtype:   enum  'NO DESCRIPTION'
+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_only_selected -> show_only_ghost_selected:   boolean  'NO DESCRIPTION'
+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.layer -> layers:   boolean  'Armature layer visibility'
+Armature.layer_protection -> layers_protected:   boolean  'Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo'
+Armature.pose_position -> pose_position:   enum  'Show armature in binding pose or final posed state'
+Armature.x_axis_mirror -> use_mirror_x:   boolean  'Apply changes to matching bone on opposite side of X-Axis'
+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  'NO DESCRIPTION'
+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.invert -> invert_vertex_group:   boolean  'Invert vertex group influence'
+ArmatureModifier.multi_modifier -> use_multi_modifier:   boolean  'Use same input as previous modifier, and mix results using overall vgroup'
+ArmatureModifier.object -> object:   pointer  'Armature object to deform with'
+ArmatureModifier.quaternion -> use_deform_preserve_volume:   boolean  'Deform rotation interpolation with quaternions'
+ArmatureModifier.use_bone_envelopes -> use_bone_envelopes:   boolean  'NO DESCRIPTION'
+ArmatureModifier.use_vertex_groups -> use_vertex_groups:   boolean  'NO DESCRIPTION'
+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.add_offset_object -> use_object_offset:   boolean  "Add another object's transformation to the total offset"
+ArrayModifier.constant_offset -> use_constant_offset:   boolean  'Add a constant offset'
+ArrayModifier.constant_offset_displacement -> constant_offset_displacement:   float  'NO DESCRIPTION'
+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_adjacent_vertices -> use_merge_adjacent_vertices:   boolean  'Merge vertices in adjacent duplicates'
+ArrayModifier.merge_distance -> merge_distance:   float  'Limit below which to merge vertices'
+ArrayModifier.merge_end_vertices -> use_merge_end_vertices:   boolean  'Merge vertices in first and last duplicates'
+ArrayModifier.offset_object -> offset_object:   pointer  'NO DESCRIPTION'
+ArrayModifier.relative_offset -> use_relative_offset:   boolean  "Add an offset relative to the object's bounding box"
+ArrayModifier.relative_offset_displacement -> relative_offset_displacement:   float  'NO DESCRIPTION'
+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.show_expanded -> show_expanded:   boolean  'Show the expanded in the user interface'
+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  'NO DESCRIPTION'
+BevelModifier.only_vertices -> use_only_vertices:   boolean  'Bevel verts/corners, not edges'
+BevelModifier.width -> width:   float  'Bevel value/amount'
+BezierSplinePoint.co -> co:   float  'Coordinates of the control point'
+BezierSplinePoint.handle1 -> handle_left:   float  'Coordinates of the first handle'
+BezierSplinePoint.handle1_type -> handle_left_type:   enum  'Handle types'
+BezierSplinePoint.handle2 -> handle_right:   float  'Coordinates of the second handle'
+BezierSplinePoint.handle2_type -> handle_right_type:   enum  'Handle types'
+BezierSplinePoint.hide -> hide:   boolean  'Visibility status'
+BezierSplinePoint.radius -> radius:   float,  '(read-only)    Radius for bevelling'
+BezierSplinePoint.select_control_point -> select_control_point:   boolean  'Control point selection status'
+BezierSplinePoint.select_left_handle -> select_left_handle:   boolean  'Handle 1 selection status'
+BezierSplinePoint.select_right_handle -> select_right_handle:   boolean  'Handle 2 selection status'
+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.in_air -> use_in_air:   boolean  'Use rule when boid is flying'
+BoidRule.name -> name:   string  'Boid rule name'
+BoidRule.on_land -> use_on_land:   boolean  'Use rule when boid is on land'
+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'
+BoidRuleAvoid.predict -> use_predict:   boolean  'Predict target movement'
+BoidRuleAvoidCollision.boids -> use_avoid:   boolean  'Avoid collision with other boids'
+BoidRuleAvoidCollision.deflectors -> use_avoid_collision:   boolean  'Avoid collision with deflector objects'
+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.line -> use_line:   boolean  'Follow leader in a line'
+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'
+BoidRuleGoal.predict -> use_predict:   boolean  'Predict target movement'
+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  'NO DESCRIPTION'
+BoidSettings.aggression -> aggression:   float  'Boid will fight this times stronger enemy'
+BoidSettings.air_max_acc -> air_acc_max:   float  'Maximum acceleration in air (relative to maximum speed)'
+BoidSettings.air_max_ave -> air_ave_max:   float  'Maximum angular velocity in air (relative to 180 degrees)'
+BoidSettings.air_max_speed -> air_speed_max:   float  'Maximum speed in air'
+BoidSettings.air_min_speed -> air_speed_min:   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.allow_climb -> use_climb:   boolean  'Allow boids to climb goal objects'
+BoidSettings.allow_flight -> use_flight:   boolean  'Allow boids to move in air'
+BoidSettings.allow_land -> use_land:   boolean  'Allow boids to move on land'
+BoidSettings.banking -> bank:   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_acc_max:   float  'Maximum acceleration on land (relative to maximum speed)'
+BoidSettings.land_max_ave -> land_ave_max:   float  'Maximum angular velocity on land (relative to 180 degrees)'
+BoidSettings.land_max_speed -> land_speed_max:   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 -> land_smooth:   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  'NO DESCRIPTION'
+BoidState.falloff -> falloff:   float  'NO DESCRIPTION'
+BoidState.name -> name:   string  'Boid state name'
+BoidState.rule_fuzziness -> rule_fuzzy:   float  'NO DESCRIPTION'
+BoidState.rules -> rules:   collection,  '(read-only)'
+BoidState.ruleset_type -> ruleset_type:   enum  'How the rules in the list are evaluated'
+BoidState.volume -> volume:   float  'NO DESCRIPTION'
+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.connected -> use_connect:   boolean,  "(read-only)    When bone has a parent, bone's head is struck to the parent's tail"
+Bone.cyclic_offset -> use_cyclic_offset:   boolean  "When bone doesn't have a parent, it receives cyclic offset effects"
+Bone.deform -> use_deform:   boolean  'Bone does not deform any geometry'
+Bone.draw_wire -> show_wire:   boolean  'Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes'
+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.hide -> hide:   boolean  'Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)'
+Bone.hide_select -> hide_select:   boolean  'Bone is able to be selected'
+Bone.hinge -> use_hinge:   boolean  'Bone inherits rotation or scale from parent bone'
+Bone.inherit_scale -> use_inherit_scale:   boolean  'Bone inherits scaling from parent bone'
+Bone.layer -> layers:   boolean  'Layers bone exists in'
+Bone.local_location -> use_local_location:   boolean  'Bone location is set in local space'
+Bone.matrix -> matrix:   float  '3x3 bone matrix'
+Bone.matrix_local -> matrix_local:   float  '4x4 bone matrix relative to armature'
+Bone.multiply_vertexgroup_with_envelope -> use_envelope_multiply:   boolean  'When deforming bone, multiply effects of Vertex Group weights with Envelope influence'
+Bone.name -> name:   string  'NO DESCRIPTION'
+Bone.parent -> parent:   pointer,  '(read-only)    Parent bone (in same Armature)'
+Bone.select -> select:   boolean  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+BooleanModifier.object -> object:   pointer  'Mesh object to use for Boolean operation'
+BooleanModifier.operation -> operation:   enum  'NO DESCRIPTION'
+BooleanProperty.array_length -> array_length:   int,  '(read-only)    Maximum length of the array, 0 means unlimited'
+BooleanProperty.default -> default:   boolean,  '(read-only)    Default value for this number'
+BooleanProperty.default_array -> default_array:   boolean,  '(read-only)    Default value for this array'
+Brush.add_col -> add_col:   float  'Color of cursor when adding'
+Brush.autosmooth_factor -> autosmooth_factor:   float  'Amount of smoothing to automatically apply to each stroke'
+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  'NO DESCRIPTION'
+Brush.color -> color:   float  'NO DESCRIPTION'
+Brush.crease_pinch_factor -> crease_pinch_factor:   float  'How much the crease brush pinches'
+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.edge_to_edge -> edge_to_edge:   boolean  'Drag anchor brush from edge-to-edge'
+Brush.icon_filepath -> icon_filepath:   string  'File path to brush icon'
+Brush.imagepaint_tool -> imagepaint_tool:   enum  'NO DESCRIPTION'
+Brush.jitter -> jitter:   float  'Jitter the position of the brush while painting'
+Brush.normal_weight -> normal_weight:   float  'How much grab will pull vertexes out of surface during a grab'
+Brush.plane_offset -> plane_offset:   float  'Adjusts plane on which the brush acts towards or away from the object surface'
+Brush.plane_trim -> plane_trim:   float  'If a vertex is further from offset plane than this then it is not affected'
+Brush.rate -> rate:   float  'Interval between paints for Airbrush'
+Brush.restore_mesh -> restore_mesh:   boolean  'Allows a single dot to be carefully positioned'
+Brush.sculpt_plane -> sculpt_plane:   enum  'NO DESCRIPTION'
+Brush.sculpt_tool -> sculpt_tool:   enum  'NO DESCRIPTION'
+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.stroke_method -> stroke_method:   enum  'NO DESCRIPTION'
+Brush.sub_col -> sub_col:   float  'Color of cursor when subtracting'
+Brush.texture -> texture:   pointer  'NO DESCRIPTION'
+Brush.texture_angle_source -> texture_angle_source:   enum  'NO DESCRIPTION'
+Brush.texture_angle_source_no_random -> texture_angle_source_no_random:   enum  'NO DESCRIPTION'
+Brush.texture_overlay_alpha -> texture_overlay_alpha:   int  'NO DESCRIPTION'
+Brush.texture_sample_bias -> texture_sample_bias:   float  'Value added to texture samples'
+Brush.texture_slot -> texture_slot:   pointer,  '(read-only)'
+Brush.unprojected_radius -> unprojected_radius:   float  'Radius of brush in Blender units'
+Brush.use_accumulate -> use_accumulate:   boolean  'Accumulate stroke dabs on top of each other'
+Brush.use_adaptive_space -> use_adaptive_space:   boolean  'Space daubs according to surface orientation instead of screen space'
+Brush.use_airbrush -> use_airbrush:   boolean  'Keep applying paint effect while holding mouse (spray)'
+Brush.use_alpha -> use_alpha:   boolean  'When this is disabled, lock alpha while painting'
+Brush.use_anchor -> use_anchor:   boolean  'Keep the brush anchored to the initial location'
+Brush.use_custom_icon -> use_custom_icon:   boolean  'Set the brush icon from an image file'
+Brush.use_frontface -> use_frontface:   boolean  'Brush only affects vertexes that face the viewer'
+Brush.use_inverse_smooth_pressure -> use_inverse_smooth_pressure:   boolean  'Lighter pressure causes more smoothing to be applied'
+Brush.use_jitter_pressure -> use_pressure_jitter:   boolean  'Enable tablet pressure sensitivity for jitter'
+Brush.use_locked_size -> use_locked_size:   boolean  'When locked brush stays same size relative to object; when unlocked brush size is given in pixels'
+Brush.use_offset_pressure -> use_offset_pressure:   boolean  'Enable tablet pressure sensitivity for offset'
+Brush.use_original_normal -> use_original_normal:   boolean  'When locked keep using normal of surface where stroke was initiated'
+Brush.use_paint_sculpt -> use_paint_sculpt:   boolean  'Use this brush in sculpt mode'
+Brush.use_paint_texture -> use_paint_texture:   boolean  'Use this brush in texture paint mode'
+Brush.use_paint_vertex -> use_paint_vertex:   boolean  'Use this brush in vertex paint mode'
+Brush.use_paint_weight -> use_paint_weight:   boolean  'Use this brush in weight paint mode'
+Brush.use_persistent -> use_persistent:   boolean  'Sculpts on a persistent layer of the mesh'
+Brush.use_plane_trim -> use_plane_trim:   boolean  'Enable Plane Trim'
+Brush.use_rake -> use_rake:   boolean  'Rotate the brush texture to match the stroke direction'
+Brush.use_random_rotation -> use_random_rotation:   boolean  'Rotate the brush texture at random'
+Brush.use_size_pressure -> use_pressure_size:   boolean  'Enable tablet pressure sensitivity for size'
+Brush.use_smooth_stroke -> use_smooth_stroke:   boolean  'Brush lags behind mouse and follows a smoother path'
+Brush.use_space -> use_space:   boolean  'Limit brush application to the distance specified by spacing'
+Brush.use_space_atten -> use_space_atten:   boolean  'Automatically adjusts strength to give consistent results for different spacings'
+Brush.use_spacing_pressure -> use_pressure_spacing:   boolean  'Enable tablet pressure sensitivity for spacing'
+Brush.use_strength_pressure -> use_pressure_strength:   boolean  'Enable tablet pressure sensitivity for strength'
+Brush.use_texture_overlay -> use_texture_overlay:   boolean  'Show texture in viewport'
+Brush.use_wrap -> use_wrap:   boolean  'Enable torus wrapping while painting'
+Brush.vertexpaint_tool -> vertexpaint_tool:   enum  'NO DESCRIPTION'
+BrushTextureSlot.angle -> angle:   float  'Defines brush texture rotation'
+BrushTextureSlot.map_mode -> map_mode:   enum  'NO DESCRIPTION'
+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.randomize -> use_random_order:   boolean  'Randomize the faces or edges during build'
+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.panorama -> use_panorama:   boolean  'Render the scene with a cylindrical camera for pseudo-fisheye lens effects'
+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.show_limits -> show_limits:   boolean  'Draw the clipping range and focus point on the camera'
+Camera.show_mist -> show_mist:   boolean  'Draw a line from the Camera to indicate the mist area'
+Camera.show_name -> show_name:   boolean  "Show the active Camera's name in Camera view"
+Camera.show_passepartout -> show_passepartout:   boolean  'Show a darkened overlay outside the image area in Camera view'
+Camera.show_title_safe -> show_title_safe:   boolean  'Show indicators for the title safe zone in Camera view'
+Camera.type -> type:   enum  'Camera types'
+CameraActuator.axis -> axis:   enum  'Specify the axis the Camera will try to get behind'
+CameraActuator.height -> height:   float  'NO DESCRIPTION'
+CameraActuator.max -> max:   float  'NO DESCRIPTION'
+CameraActuator.min -> min:   float  'NO DESCRIPTION'
+CameraActuator.object -> object:   pointer  'Look at this Object'
+CastModifier.cast_type -> cast_type:   enum  'NO DESCRIPTION'
+CastModifier.factor -> factor:   float  'NO DESCRIPTION'
+CastModifier.from_radius -> use_radius_as_size:   boolean  'Use radius as size of projection shape (0 = auto)'
+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.use_transform -> use_transform:   boolean  'Use object transform to control projection shape'
+CastModifier.vertex_group -> vertex_group:   string  'Vertex group name'
+CastModifier.x -> use_x:   boolean  'NO DESCRIPTION'
+CastModifier.y -> use_y:   boolean  'NO DESCRIPTION'
+CastModifier.z -> use_z:   boolean  'NO DESCRIPTION'
+ChildOfConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
+ChildOfConstraint.target -> target:   pointer  'Target Object'
+ChildOfConstraint.use_location_x -> use_location_x:   boolean  'Use X Location of Parent'
+ChildOfConstraint.use_location_y -> use_location_y:   boolean  'Use Y Location of Parent'
+ChildOfConstraint.use_location_z -> use_location_z:   boolean  'Use Z Location of Parent'
+ChildOfConstraint.use_rotation_x -> use_rotation_x:   boolean  'Use X Rotation of Parent'
+ChildOfConstraint.use_rotation_y -> use_rotation_y:   boolean  'Use Y Rotation of Parent'
+ChildOfConstraint.use_rotation_z -> use_rotation_z:   boolean  'Use Z Rotation of Parent'
+ChildOfConstraint.use_scale_x -> use_scale_x:   boolean  'Use X Scale of Parent'
+ChildOfConstraint.use_scale_y -> use_scale_y:   boolean  'Use Y Scale of Parent'
+ChildOfConstraint.use_scale_z -> use_scale_z:   boolean  'Use Z Scale of Parent'
+ClampToConstraint.cyclic -> use_cyclic:   boolean  'Treat curve as cyclic curve (no clamping to curve bounding box'
+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.enable_collision -> use_collision:   boolean  'Enable collisions with other objects'
+ClothCollisionSettings.enable_self_collision -> use_self_collision:   boolean  'Enable self collisions'
+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 -> distance_min:   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_distance_min:   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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+ClothSettings.mass -> mass:   float  'Mass of cloth material'
+ClothSettings.mass_vertex_group -> mass_vertex_group:   string  'Vertex Group for pinning of vertices'
+ClothSettings.pin_cloth -> use_pin_cloth:   boolean  'Enable pinning of cloth vertices to other objects/positions'
+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.stiffness_scaling -> use_stiffness_scale:   boolean  'If enabled, stiffness can be scaled along a weight painted vertex group'
+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  'NO DESCRIPTION'
+CloudsTexture.stype -> stype:   enum  'NO DESCRIPTION'
+CollectionProperty.fixed_type -> fixed_type:   pointer,  '(read-only)    Fixed pointer type, empty if variable type'
+CollisionModifier.settings -> settings:   pointer,  '(read-only)'
+CollisionSensor.collision_type -> use_material:   boolean  'Use material instead of property'
+CollisionSensor.material -> material:   string  'Only look for Objects with this material'
+CollisionSensor.property -> property:   string  'Only look for Objects with this property'
+CollisionSensor.pulse -> use_pulse:   boolean  'Changes to the set of colliding objects generates pulse'
+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.enabled -> use:   boolean  'Enable this objects as a collider for physics systems'
+CollisionSettings.friction_factor -> friction_factor:   float  'Amount of friction during particle collision'
+CollisionSettings.inner_thickness -> inner_thickness:   float  'Inner face thickness'
+CollisionSettings.kill_particles -> use_particle_kill:   boolean  'Kill colliding particles'
+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  'NO DESCRIPTION'
+ColorRamp.total -> total:   int,  '(read-only)    Total number of elements'
+ColorRampElement.color -> color:   float  'NO DESCRIPTION'
+ColorRampElement.position -> position:   float  'NO DESCRIPTION'
+ColorSequence.color -> color:   float  'NO DESCRIPTION'
+CompositorNode.type -> type:   enum,  '(read-only)'
+CompositorNodeAlphaOver.convert_premul -> use_premultiply:   boolean  'NO DESCRIPTION'
+CompositorNodeAlphaOver.premul -> premul:   float  'Mix Factor'
+CompositorNodeBilateralblur.iterations -> iterations:   int  'NO DESCRIPTION'
+CompositorNodeBilateralblur.sigma_color -> sigma_color:   float  'NO DESCRIPTION'
+CompositorNodeBilateralblur.sigma_space -> sigma_space:   float  'NO DESCRIPTION'
+CompositorNodeBlur.bokeh -> use_bokeh:   boolean  'NO DESCRIPTION'
+CompositorNodeBlur.factor -> factor:   float  'NO DESCRIPTION'
+CompositorNodeBlur.factor_x -> factor_x:   float  'NO DESCRIPTION'
+CompositorNodeBlur.factor_y -> factor_y:   float  'NO DESCRIPTION'
+CompositorNodeBlur.filter_type -> filter_type:   enum  'NO DESCRIPTION'
+CompositorNodeBlur.gamma -> use_gamma_correction:   boolean  'NO DESCRIPTION'
+CompositorNodeBlur.relative -> use_relative:   boolean  'NO DESCRIPTION'
+CompositorNodeBlur.sizex -> size_x:   int  'NO DESCRIPTION'
+CompositorNodeBlur.sizey -> size_y:   int  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+CompositorNodeColorSpill.channel -> channel:   enum  'NO DESCRIPTION'
+CompositorNodeColorSpill.limit_channel -> limit_channel:   enum  'NO DESCRIPTION'
+CompositorNodeColorSpill.ratio -> ratio:   float  'Scale limit by value'
+CompositorNodeColorSpill.unspill -> use_unspill:   boolean  'Compensate all channels (diffenrently) by hand'
+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.crop_size -> use_crop_size:   boolean  'Whether to crop the size of the input image'
+CompositorNodeCrop.x1 -> x1:   int  'NO DESCRIPTION'
+CompositorNodeCrop.x2 -> x2:   int  'NO DESCRIPTION'
+CompositorNodeCrop.y1 -> y1:   int  'NO DESCRIPTION'
+CompositorNodeCrop.y2 -> y2:   int  'NO DESCRIPTION'
+CompositorNodeCurveRGB.mapping -> mapping:   pointer,  '(read-only)'
+CompositorNodeCurveVec.mapping -> mapping:   pointer,  '(read-only)'
+CompositorNodeDBlur.angle -> angle:   float  'NO DESCRIPTION'
+CompositorNodeDBlur.center_x -> center_x:   float  'NO DESCRIPTION'
+CompositorNodeDBlur.center_y -> center_y:   float  'NO DESCRIPTION'
+CompositorNodeDBlur.distance -> distance:   float  'NO DESCRIPTION'
+CompositorNodeDBlur.iterations -> iterations:   int  'NO DESCRIPTION'
+CompositorNodeDBlur.spin -> spin:   float  'NO DESCRIPTION'
+CompositorNodeDBlur.wrap -> use_wrap:   boolean  'NO DESCRIPTION'
+CompositorNodeDBlur.zoom -> zoom:   float  'NO DESCRIPTION'
+CompositorNodeDefocus.angle -> angle:   int  'Bokeh shape rotation offset in degrees'
+CompositorNodeDefocus.bokeh -> bokeh:   enum  'NO DESCRIPTION'
+CompositorNodeDefocus.f_stop -> f_stop:   float  'Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius'
+CompositorNodeDefocus.gamma_correction -> use_gamma_correction:   boolean  'Enable gamma correction before and after main process'
+CompositorNodeDefocus.max_blur -> blur_max:   float  'blur limit, maximum CoC radius, 0=no limit'
+CompositorNodeDefocus.preview -> use_preview:   boolean  'Enable sampling mode, useful for preview when using low samplecounts'
+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.use_zbuffer -> use_zbuffer:   boolean  'Disable when using an image as input instead of actual zbuffer (auto enabled if node not image based, eg. time node)'
+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  'NO DESCRIPTION'
+CompositorNodeFlip.axis -> axis:   enum  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+CompositorNodeGlare.iterations -> iterations:   int  'NO DESCRIPTION'
+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.rotate_45 -> use_rotate_45:   boolean  'Simple star filter: add 45 degree rotation offset'
+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  'NO DESCRIPTION'
+CompositorNodeHueSat.sat -> sat:   float  'NO DESCRIPTION'
+CompositorNodeHueSat.val -> val:   float  'NO DESCRIPTION'
+CompositorNodeIDMask.index -> index:   int  'Pass index number to convert to alpha'
+CompositorNodeImage.auto_refresh -> use_auto_refresh:   boolean  'NO DESCRIPTION'
+CompositorNodeImage.cyclic -> use_cyclic:   boolean  'NO DESCRIPTION'
+CompositorNodeImage.frames -> frames:   int  'Number of images used in animation'
+CompositorNodeImage.image -> image:   pointer  'NO DESCRIPTION'
+CompositorNodeImage.layer -> layer:   enum  'NO DESCRIPTION'
+CompositorNodeImage.offset -> offset:   int  'Offsets the number of the frame to use in the animation'
+CompositorNodeImage.start -> start:   int  'NO DESCRIPTION'
+CompositorNodeInvert.alpha -> invert_alpha:   boolean  'NO DESCRIPTION'
+CompositorNodeInvert.rgb -> invert_rgb:   boolean  'NO DESCRIPTION'
+CompositorNodeLensdist.fit -> use_fit:   boolean  'For positive distortion factor only: scale image such that black areas are not visible'
+CompositorNodeLensdist.jitter -> use_jitter:   boolean  'Enable/disable jittering; faster, but also noisier'
+CompositorNodeLensdist.projector -> use_projector:   boolean  'Enable/disable projector mode. Effect is applied in horizontal direction only'
+CompositorNodeLevels.channel -> channel:   enum  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+CompositorNodeMapValue.max -> max:   float  'NO DESCRIPTION'
+CompositorNodeMapValue.min -> min:   float  'NO DESCRIPTION'
+CompositorNodeMapValue.offset -> offset:   float  'NO DESCRIPTION'
+CompositorNodeMapValue.size -> size:   float  'NO DESCRIPTION'
+CompositorNodeMapValue.use_max -> use_max:   boolean  'NO DESCRIPTION'
+CompositorNodeMapValue.use_min -> use_min:   boolean  'NO DESCRIPTION'
+CompositorNodeMath.operation -> operation:   enum  'NO DESCRIPTION'
+CompositorNodeMixRGB.alpha -> use_alpha:   boolean  'Include alpha of second input in this operation'
+CompositorNodeMixRGB.blend_type -> blend_type:   enum  'NO DESCRIPTION'
+CompositorNodeOutputFile.exr_codec -> exr_codec:   enum  'NO DESCRIPTION'
+CompositorNodeOutputFile.exr_half -> use_exr_half:   boolean  'NO DESCRIPTION'
+CompositorNodeOutputFile.filepath -> filepath:   string  'Output path for the image, same functionality as render output.'
+CompositorNodeOutputFile.frame_end -> frame_end:   int  'NO DESCRIPTION'
+CompositorNodeOutputFile.frame_start -> frame_start:   int  'NO DESCRIPTION'
+CompositorNodeOutputFile.image_type -> image_type:   enum  'NO DESCRIPTION'
+CompositorNodeOutputFile.quality -> quality:   int  'NO DESCRIPTION'
+CompositorNodePremulKey.mapping -> mapping:   enum  'Conversion between premultiplied alpha and key alpha'
+CompositorNodeRLayers.layer -> layer:   enum  'NO DESCRIPTION'
+CompositorNodeRLayers.scene -> scene:   pointer  'NO DESCRIPTION'
+CompositorNodeRotate.filter -> filter:   enum  'Method to use to filter rotation'
+CompositorNodeScale.space -> space:   enum  'Coordinate space to scale relative to'
+CompositorNodeSplitViewer.axis -> axis:   enum  'NO DESCRIPTION'
+CompositorNodeSplitViewer.factor -> factor:   int  'NO DESCRIPTION'
+CompositorNodeTexture.node_output -> node_output:   int  'For node-based textures, which output node to use'
+CompositorNodeTexture.texture -> texture:   pointer  'NO DESCRIPTION'
+CompositorNodeTime.curve -> curve:   pointer,  '(read-only)'
+CompositorNodeTime.end -> end:   int  'NO DESCRIPTION'
+CompositorNodeTime.start -> start:   int  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+CompositorNodeValToRGB.color_ramp -> color_ramp:   pointer,  '(read-only)'
+CompositorNodeVecBlur.curved -> use_curved:   boolean  'Interpolate between frames in a bezier curve, rather than linearly'
+CompositorNodeVecBlur.factor -> factor:   float  "Scaling factor for motion vectors; actually 'shutter speed' in frames"
+CompositorNodeVecBlur.max_speed -> speed_max:   int  'Maximum speed, or zero for none'
+CompositorNodeVecBlur.min_speed -> speed_min:   int  'Minimum speed for a pixel to be blurred; used to separate background from foreground'
+CompositorNodeVecBlur.samples -> samples:   int  'NO DESCRIPTION'
+ConsoleLine.current_character -> current_character:   int  'NO DESCRIPTION'
+ConsoleLine.line -> line:   string  'Text in the line'
+Constraint.active -> active:   boolean  'Constraint is the one being edited'
+Constraint.disabled -> is_valid:   boolean,  '(read-only)    Constraint has invalid settings and will not be evaluated'
+Constraint.enabled -> enabled:   boolean  'Enable/Disable Constraint'
+Constraint.expanded -> show_expanded:   boolean  "Constraint's panel is expanded in UI"
+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.proxy_local -> is_proxy_local:   boolean  'Constraint was added in this proxy instance (i.e. did not belong to source Armature)'
+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.detect_material -> use_material_detect:   boolean  'Detect material instead of property'
+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.fh_normal -> use_fh_normal:   boolean  'Add a horizontal spring force on slopes'
+ConstraintActuator.fh_paralel_axis -> use_fh_paralel_axis:   boolean  'Keep object axis parallel to normal'
+ConstraintActuator.force_distance -> use_force_distance:   boolean  'Force distance of object to point of impact of ray'
+ConstraintActuator.limit -> limit:   enum  'NO DESCRIPTION'
+ConstraintActuator.limit_max -> limit_max:   float  'NO DESCRIPTION'
+ConstraintActuator.limit_min -> limit_min:   float  'NO DESCRIPTION'
+ConstraintActuator.local -> use_local:   boolean  "Set ray along object's axis or global axis"
+ConstraintActuator.material -> material:   string  'Ray detects only Objects with this material'
+ConstraintActuator.max_angle -> angle_max:   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 -> rotation_max:   float  'Reference Direction'
+ConstraintActuator.min_angle -> angle_min:   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.normal -> use_normal:   boolean  'Set object axis along (local axis) or parallel (global axis) to the normal at hit position'
+ConstraintActuator.persistent -> use_persistent:   boolean  'Persistent actuator: stays active even if ray does not reach target'
+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  'NO DESCRIPTION'
+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.region_data -> region_data:   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.active -> use:   boolean  'Object contributes to the fluid simulation'
+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.reverse_frames -> use_reverse_frames:   boolean  'Reverse control object movement'
+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.expanded -> show_expanded:   boolean  'Set controller expanded in the user interface'
+Controller.name -> name:   string  'NO DESCRIPTION'
+Controller.priority -> use_priority:   boolean  'Mark controller for execution before all non-marked controllers (good for startup scripts)'
+Controller.state -> states:   boolean,  '(read-only)    Set Controller state index (1 to 30)'
+Controller.type -> type:   enum  'NO DESCRIPTION'
+CopyLocationConstraint.head_tail -> head_tail:   float  'Target along length of bone: Head=0, Tail=1'
+CopyLocationConstraint.invert_x -> invert_x:   boolean  'Invert the X location'
+CopyLocationConstraint.invert_y -> invert_y:   boolean  'Invert the Y location'
+CopyLocationConstraint.invert_z -> invert_z:   boolean  'Invert the Z location'
+CopyLocationConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
+CopyLocationConstraint.target -> target:   pointer  'Target Object'
+CopyLocationConstraint.use_offset -> use_offset:   boolean  'Add original location into copied location'
+CopyLocationConstraint.use_x -> use_x:   boolean  "Copy the target's X location"
+CopyLocationConstraint.use_y -> use_y:   boolean  "Copy the target's Y location"
+CopyLocationConstraint.use_z -> use_z:   boolean  "Copy the target's Z location"
+CopyRotationConstraint.invert_x -> invert_x:   boolean  'Invert the X rotation'
+CopyRotationConstraint.invert_y -> invert_y:   boolean  'Invert the Y rotation'
+CopyRotationConstraint.invert_z -> invert_z:   boolean  'Invert the Z rotation'
+CopyRotationConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
+CopyRotationConstraint.target -> target:   pointer  'Target Object'
+CopyRotationConstraint.use_offset -> use_offset:   boolean  'Add original rotation into copied rotation'
+CopyRotationConstraint.use_x -> use_x:   boolean  "Copy the target's X rotation"
+CopyRotationConstraint.use_y -> use_y:   boolean  "Copy the target's Y rotation"
+CopyRotationConstraint.use_z -> use_z:   boolean  "Copy the target's Z rotation"
+CopyScaleConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
+CopyScaleConstraint.target -> target:   pointer  'Target Object'
+CopyScaleConstraint.use_offset -> use_offset:   boolean  'Add original scale into copied scale'
+CopyScaleConstraint.use_x -> use_x:   boolean  "Copy the target's X scale"
+CopyScaleConstraint.use_y -> use_y:   boolean  "Copy the target's Y scale"
+CopyScaleConstraint.use_z -> use_z:   boolean  "Copy the target's Z scale"
+CopyTransformsConstraint.head_tail -> head_tail:   float  'Target along length of bone: Head=0, Tail=1'
+CopyTransformsConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
+CopyTransformsConstraint.target -> target:   pointer  'Target Object'
+Curve.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
+Curve.auto_texspace -> use_auto_texspace:   boolean  "Adjusts active object's texture space automatically when transforming object"
+Curve.back -> use_fill_back:   boolean  'Draw filled back for extruded/beveled curves'
+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.draw_handles -> show_handles:   boolean  'Display bezier handles in editmode'
+Curve.draw_normals -> show_normals:   boolean  'Display 3D curve normals in editmode'
+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.front -> use_fill_front:   boolean  'Draw filled front for extruded/beveled curves'
+Curve.map_along_length -> use_map_along_length:   boolean  'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'
+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.use_deform_bounds -> use_deform_bounds:   boolean  'Use the mesh bounds to clamp the deformation'
+Curve.use_deform_fill -> use_fill_deform:   boolean  'Fill curve after applying deformation'
+Curve.use_path -> use_path:   boolean  'Enable the curve to become a translation path'
+Curve.use_path_follow -> use_path_follow:   boolean  'Make curve path children to rotate along the path'
+Curve.use_radius -> use_radius:   boolean  'Option for paths: apply the curve radius with path following it and deforming'
+Curve.use_stretch -> use_stretch:   boolean  'Option for curve-deform: makes deformed child to stretch along entire path'
+Curve.use_time_offset -> use_time_offset:   boolean  'Children will use Time Offset value as path distance offset'
+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'
+CurveMapPoint.select -> select:   boolean  'Selection state of the curve point'
+CurveMapping.black_level -> black_level:   float  'For RGB curves, the color that black is mapped to'
+CurveMapping.clip -> use_clip:   boolean  'Force the curve view to fit a defined boundary'
+CurveMapping.clip_max_x -> clip_max_x:   float  'NO DESCRIPTION'
+CurveMapping.clip_max_y -> clip_max_y:   float  'NO DESCRIPTION'
+CurveMapping.clip_min_x -> clip_min_x:   float  'NO DESCRIPTION'
+CurveMapping.clip_min_y -> clip_min_y:   float  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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'
+DelaySensor.repeat -> use_repeat:   boolean  'Toggle repeat option. If selected, the sensor restarts after Delay+Dur logic tics'
+DisplaceModifier.direction -> direction:   enum  'NO DESCRIPTION'
+DisplaceModifier.midlevel -> midlevel:   float  'Material value that gives no displacement'
+DisplaceModifier.strength -> strength:   float  'NO DESCRIPTION'
+DisplaceModifier.texture -> texture:   pointer  'NO DESCRIPTION'
+DisplaceModifier.texture_coordinate_object -> texture_coordinate_object:   pointer  'NO DESCRIPTION'
+DisplaceModifier.texture_coordinates -> texture_coordinates:   enum  'NO DESCRIPTION'
+DisplaceModifier.uv_layer -> uv_layer:   string  'UV layer name'
+DisplaceModifier.vertex_group -> vertex_group:   string  'Vertex group name'
+DistortedNoiseTexture.distortion -> distortion:   float  'NO DESCRIPTION'
+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.generate_speed_vectors -> use_speed_vectors:   boolean  'Generate speed vectors for vector blur'
+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.override_time -> use_time_override:   boolean  "Use a custom start and end time (in seconds) instead of the scene's timeline"
+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.reverse_frames -> use_reverse_frames:   boolean  'Reverse fluid frames'
+DomainFluidSettings.slip_type -> slip_type:   enum  'NO DESCRIPTION'
+DomainFluidSettings.start_time -> start_time:   float  'Simulation time of the first blender frame'
+DomainFluidSettings.surface_smoothing -> surface_smooth:   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'
+NEGATE * DopeSheet.collapse_summary -> show_expanded_summary:   boolean  'Collapse summary when shown, so all other channels get hidden. (DopeSheet Editors Only)'
+DopeSheet.display_armature -> show_armatures:   boolean  'Include visualization of Armature related Animation data'
+DopeSheet.display_camera -> show_cameras:   boolean  'Include visualization of Camera related Animation data'
+DopeSheet.display_curve -> show_curves:   boolean  'Include visualization of Curve related Animation data'
+DopeSheet.display_hidden -> display_hidden:   boolean  "Include channels from objects/bone that aren't visible"
+DopeSheet.display_lamp -> show_lamps:   boolean  'Include visualization of Lamp related Animation data'
+DopeSheet.display_material -> show_materials:   boolean  'Include visualization of Material related Animation data'
+DopeSheet.display_mesh -> show_meshes:   boolean  'Include visualization of Mesh related Animation data'
+DopeSheet.display_metaball -> show_metaballs:   boolean  'Include visualization of Metaball related Animation data'
+DopeSheet.display_node -> show_nodes:   boolean  'Include visualization of Node related Animation data'
+DopeSheet.display_particle -> show_particles:   boolean  'Include visualization of Particle related Animation data'
+DopeSheet.display_scene -> show_scenes:   boolean  'Include visualization of Scene related Animation data'
+DopeSheet.display_shapekeys -> show_shapekeys:   boolean  'Include visualization of ShapeKey related Animation data'
+DopeSheet.display_summary -> show_summary:   boolean  "Display an additional 'summary' line. (DopeSheet Editors only)"
+DopeSheet.display_texture -> show_textures:   boolean  'Include visualization of Texture related Animation data'
+DopeSheet.display_transforms -> show_transforms:   boolean  'Include visualization of Object-level Animation data (mostly Transforms)'
+DopeSheet.display_world -> show_worlds:   boolean  'Include visualization of World related Animation data'
+DopeSheet.filtering_group -> filtering_group:   pointer  'Group that included Object should be a member of'
+DopeSheet.include_missing_nla -> show_missing_nla:   boolean  'Include Animation Data blocks with no NLA data. (NLA Editor only)'
+DopeSheet.only_group_objects -> show_only_group_objects:   boolean  'Only include channels from Objects in the specified Group'
+DopeSheet.only_selected -> show_only_selected:   boolean  'Only include channels relating to selected objects and data'
+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.invalid -> is_valid:   boolean  'Driver could not be evaluated in past, so should be skipped'
+Driver.show_debug_info -> show_debug_info:   boolean  'Show intermediate values for the driver calculations to allow debugging of drivers'
+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'
+DriverTarget.use_local_space_transforms -> use_local_space_transform:   boolean  'Use transforms in Local Space (as opposed to the worldspace default)'
+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'
+EdgeSplitModifier.use_edge_angle -> use_edge_angle:   boolean  'Split edges with high angle between faces'
+EdgeSplitModifier.use_sharp -> use_edge_sharp:   boolean  'Split edges that are marked as sharp'
+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.connected -> use_connect:   boolean  "When bone has a parent, bone's head is struck to the parent's tail"
+EditBone.cyclic_offset -> use_cyclic_offset:   boolean  "When bone doesn't have a parent, it receives cyclic offset effects"
+EditBone.deform -> use_deform:   boolean  'Bone does not deform any geometry'
+EditBone.draw_wire -> show_wire:   boolean  'Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes'
+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.hide -> hide:   boolean  'Bone is not visible when in Edit Mode'
+EditBone.hide_select -> hide_select:   boolean  'Bone is able to be selected'
+EditBone.hinge -> use_hinge:   boolean  'Bone inherits rotation or scale from parent bone'
+EditBone.inherit_scale -> use_inherit_scale:   boolean  'Bone inherits scaling from parent bone'
+EditBone.layer -> layers:   boolean  'Layers bone exists in'
+EditBone.local_location -> use_local_location:   boolean  'Bone location is set in local space'
+EditBone.lock -> lock:   boolean  'Bone is not able to be transformed when in Edit Mode'
+EditBone.matrix -> matrix:   float,  '(read-only)    Read-only matrix calculated from the roll (armature space)'
+EditBone.multiply_vertexgroup_with_envelope -> use_envelope_multiply:   boolean  'When deforming bone, multiply effects of Vertex Group weights with Envelope influence'
+EditBone.name -> name:   string  'NO DESCRIPTION'
+EditBone.parent -> parent:   pointer  'Parent edit bone (in same Armature)'
+EditBone.roll -> roll:   float  'Bone rotation around head-tail axis'
+EditBone.select -> select:   boolean  'NO DESCRIPTION'
+EditBone.select_head -> select_head:   boolean  'NO DESCRIPTION'
+EditBone.select_tail -> select_tail:   boolean  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+EditObjectActuator.enable_3d_tracking -> use_3d_tracking:   boolean  'Enable 3D tracking'
+EditObjectActuator.linear_velocity -> linear_velocity:   float  'Velocity upon creation'
+EditObjectActuator.local_angular_velocity -> use_local_angular_velocity:   boolean  'Apply the rotation locally'
+EditObjectActuator.local_linear_velocity -> use_local_linear_velocity:   boolean  'Apply the transformation locally'
+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.replace_display_mesh -> use_replace_display_mesh:   boolean  'Replace the display mesh'
+EditObjectActuator.replace_physics_mesh -> use_replace_physics_mesh:   boolean  'Replace the physics mesh (triangle bounds only - compound shapes not supported)'
+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.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
+EffectSequence.convert_float -> use_float:   boolean  'Convert input to float data'
+EffectSequence.crop -> crop:   pointer,  '(read-only)'
+EffectSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
+EffectSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
+EffectSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
+EffectSequence.multiply_colors -> color_multiply:   float  'NO DESCRIPTION'
+EffectSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
+EffectSequence.proxy -> proxy:   pointer,  '(read-only)'
+EffectSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
+EffectSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
+EffectSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
+EffectSequence.strobe -> strobe:   float  'Only display every nth frame'
+EffectSequence.transform -> transform:   pointer,  '(read-only)'
+EffectSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
+EffectSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
+EffectSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
+EffectSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
+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.do_growing_hair -> apply_to_hair_growing:   boolean  'Use force fields when growing hair'
+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.ignore_layers -> layers_ignore:   boolean  'Hide objects on these layers when generating the Environment Map'
+EnvironmentMap.mapping -> mapping:   enum  'NO DESCRIPTION'
+EnvironmentMap.resolution -> resolution:   int  'Pixel resolution of the rendered environment map'
+EnvironmentMap.source -> source:   enum  'NO DESCRIPTION'
+EnvironmentMap.viewpoint_object -> viewpoint_object:   pointer  "Object to use as the environment map's viewpoint location"
+EnvironmentMap.zoom -> zoom:   float  'NO DESCRIPTION'
+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.filter_size_minimum -> use_filter_size_min:   boolean  'Use Filter Size as a minimal filter value in pixels'
+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'
+EnvironmentMapTexture.mipmap -> use_mipmap:   boolean  'Uses auto-generated MIP maps for the image'
+EnvironmentMapTexture.mipmap_gauss -> use_mipmap_gauss:   boolean  'Uses Gauss filter to sample down MIP maps'
+Event.alt -> is_pressed_alt:   boolean,  '(read-only)    True when the Alt/Option key is held'
+Event.ascii -> ascii:   string,  '(read-only)    Single ASCII character for this event'
+Event.ctrl -> is_pressed_ctrl:   boolean,  '(read-only)    True when the Ctrl key is held'
+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.oskey -> is_pressed_cmd:   boolean,  '(read-only)    True when the Cmd key is held'
+Event.shift -> is_pressed_shift:   boolean,  '(read-only)    True when the Shift key is held'
+Event.type -> type:   enum,  '(read-only)'
+Event.value -> value:   enum,  '(read-only)    The type of event, only applies to some'
+ExplodeModifier.alive -> show_alive:   boolean  'Show mesh when particles are alive'
+ExplodeModifier.dead -> show_dead:   boolean  'Show mesh when particles are dead'
+ExplodeModifier.protect -> protect:   float  'Clean vertex group edges'
+ExplodeModifier.size -> use_size:   boolean  'Use particle size for the shrapnel'
+ExplodeModifier.split_edges -> use_edge_split:   boolean  'Split face edges for nicer shrapnel'
+ExplodeModifier.unborn -> show_unborn:   boolean  'Show mesh when particles are unborn'
+ExplodeModifier.vertex_group -> vertex_group:   string  'NO DESCRIPTION'
+ExpressionController.expression -> expression:   string  'NO DESCRIPTION'
+FCurve.array_index -> array_index:   int  'Index to the specific property affected by F-Curve if applicable'
+FCurve.auto_clamped_handles -> use_auto_handle_clamp:   boolean  'All auto-handles for F-Curve are clamped'
+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.enabled -> enabled:   boolean  'False when F-Curve could not be evaluated in past, so should be skipped when evaluating'
+FCurve.extrapolation -> extrapolation:   enum  'NO DESCRIPTION'
+FCurve.group -> group:   pointer  'Action Group that this F-Curve belongs to'
+FCurve.hide -> hide:   boolean  'F-Curve and its keyframes are hidden in the Graph Editor graphs'
+FCurve.keyframe_points -> keyframe_points:   collection,  '(read-only)    User-editable keyframes'
+FCurve.lock -> lock:   boolean  "F-Curve's settings cannot be edited"
+FCurve.modifiers -> modifiers:   collection,  '(read-only)    Modifiers affecting the shape of the F-Curve'
+FCurve.mute -> mute:   boolean  'F-Curve is not evaluated'
+FCurve.sampled_points -> sampled_points:   collection,  '(read-only)    Sampled animation data'
+FCurve.select -> select:   boolean  'F-Curve is selected for editing'
+FCurveModifiers.active -> active:   pointer  'Active F-Curve Modifier'
+FCurveSample.co -> co:   float  'Point coordinates'
+FCurveSample.select -> select:   boolean  'Selection status'
+FModifier.active -> active:   boolean  'F-Curve Modifier is the one being edited'
+NEGATE * FModifier.disabled -> use:   boolean,  '(read-only)    F-Curve Modifier has invalid settings and will not be evaluated'
+FModifier.expanded -> show_expanded:   boolean  "F-Curve Modifier's panel is expanded in UI"
+FModifier.mute -> mute:   boolean  'F-Curve Modifier will not be evaluated'
+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_max:   float  'Upper distance from Reference Value for 1:1 default influence'
+FModifierEnvelope.default_minimum -> default_min:   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 -> max:   float  'Upper bound of envelope at this control-point'
+FModifierEnvelopeControlPoint.minimum -> min:   float  'Lower bound of envelope at this control-point'
+FModifierFunctionGenerator.additive -> use_additive:   boolean  'Values generated by this modifier are applied on top of the existing values instead of overwriting them'
+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.additive -> use_additive:   boolean  'Values generated by this modifier are applied on top of the existing values instead of overwriting them'
+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 -> max_x:   float  'Highest X value to allow'
+FModifierLimits.maximum_y -> max_y:   float  'Highest Y value to allow'
+FModifierLimits.minimum_x -> min_x:   float  'Lowest X value to allow'
+FModifierLimits.minimum_y -> min_y:   float  'Lowest Y value to allow'
+FModifierLimits.use_maximum_x -> use_max_x:   boolean  'Use the maximum X value'
+FModifierLimits.use_maximum_y -> use_max_y:   boolean  'Use the maximum Y value'
+FModifierLimits.use_minimum_x -> use_min_x:   boolean  'Use the minimum X value'
+FModifierLimits.use_minimum_y -> use_min_y:   boolean  'Use the minimum Y value'
+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'
+FModifierStepped.use_frame_end -> use_frame_end:   boolean  "Restrict modifier to only act before its 'end' frame"
+FModifierStepped.use_frame_start -> use_frame_start:   boolean  "Restrict modifier to only act after its 'start' frame"
+FcurveActuator.add -> use_add:   boolean  'F-Curve is added to the current loc/rot/scale in global or local coordinate according to Local flag'
+FcurveActuator.child -> apply_to_children:   boolean  'Update F-Curve on all children Objects as well'
+FcurveActuator.force -> use_force:   boolean  'Apply F-Curve as a global or local force depending on the local option (dynamic objects only)'
+FcurveActuator.frame_end -> frame_end:   int  'NO DESCRIPTION'
+FcurveActuator.frame_property -> frame_property:   string  "Assign the action's current frame number to this property"
+FcurveActuator.frame_start -> frame_start:   int  'NO DESCRIPTION'
+FcurveActuator.local -> use_local:   boolean  'Let the F-Curve act in local coordinates, used in Force and Add mode'
+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.do_absorption -> use_absorption:   boolean  'Force gets absorbed by collision objects'
+FieldSettings.do_location -> apply_to_location:   boolean  "Effect particles' location"
+FieldSettings.do_rotation -> apply_to_rotation:   boolean  "Effect particles' dynamic rotation"
+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.force_2d -> use_2d_force:   boolean  'Apply force only in 2d'
+FieldSettings.global_coordinates -> use_global_coordinates:   boolean  'Use effector/global coordinates for turbulence'
+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.guide_path_add -> use_guide_path_add:   boolean  'Based on distance/falloff it adds a portion of the entire path'
+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 -> distance_max:   float  'Maximum distance for the field to work'
+FieldSettings.minimum_distance -> distance_min:   float  "Minimum distance for the field's fall-off"
+FieldSettings.multiple_springs -> use_multiple_springs:   boolean  'Every point is effected by multiple springs'
+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_max:   float  'Maximum radial distance for the field to work'
+FieldSettings.radial_minimum -> radial_min:   float  "Minimum radial distance for the field's fall-off"
+FieldSettings.rest_length -> rest_length:   float  'Rest length of the harmonic force'
+FieldSettings.root_coordinates -> use_root_coordinates:   boolean  'Texture coordinates from root particle locations'
+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.use_coordinates -> use_object_coordinates:   boolean  'Use object/global coordinates for texture'
+FieldSettings.use_guide_path_weight -> use_guide_path_weight:   boolean  'Use curve weights to influence the particle influence along the curve'
+FieldSettings.use_max_distance -> use_max_distance:   boolean  'Use a maximum distance for the field to work'
+FieldSettings.use_min_distance -> use_min_distance:   boolean  "Use a minimum distance for the field's fall-off"
+FieldSettings.use_radial_max -> use_radial_max:   boolean  'Use a maximum radial distance for the field to work'
+FieldSettings.use_radial_min -> use_radial_min:   boolean  "Use a minimum radial distance for the field's fall-off"
+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.do_filter -> use_filter:   boolean  'Enable filtering of files'
+FileSelectParams.file -> file:   string  'Active file in the file browser'
+FileSelectParams.filter_blender -> use_filter_blender:   boolean  'Show .blend files'
+FileSelectParams.filter_folder -> use_filter_folder:   boolean  'Show folders'
+FileSelectParams.filter_font -> use_filter_font:   boolean  'Show font files'
+FileSelectParams.filter_image -> use_filter_image:   boolean  'Show image files'
+FileSelectParams.filter_movie -> use_filter_movie:   boolean  'Show movie files'
+FileSelectParams.filter_script -> use_filter_script:   boolean  'Show script files'
+FileSelectParams.filter_sound -> use_filter_sound:   boolean  'Show sound files'
+FileSelectParams.filter_text -> use_filter_text:   boolean  'Show text files'
+NEGATE * FileSelectParams.hide_dot -> show_hidden:   boolean  'Hide hidden dot files'
+FileSelectParams.sort -> sort:   enum  'NO DESCRIPTION'
+FileSelectParams.title -> title:   string,  '(read-only)    Title for the file browser'
+Filter2DActuator.enable_motion_blur -> use_motion_blur:   boolean  'Enable/Disable Motion Blur'
+Filter2DActuator.filter_pass -> filter_pass:   int  'Set filter order'
+Filter2DActuator.glsl_shader -> glsl_shader:   pointer  'NO DESCRIPTION'
+Filter2DActuator.mode -> mode:   enum  'NO DESCRIPTION'
+Filter2DActuator.motion_blur_factor -> motion_blur_factor:   float  'Set motion blur factor'
+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.sticky -> use_sticky:   boolean  'Immobilize object while constrained'
+FloorConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
+FloorConstraint.target -> target:   pointer  'Target Object'
+FloorConstraint.use_rotation -> use_rotation:   boolean  "Use the target's rotation to determine floor"
+FluidFluidSettings.active -> use:   boolean  'Object contributes to the fluid simulation'
+FluidFluidSettings.export_animated_mesh -> use_animated_mesh:   boolean  'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
+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'
+FollowPathConstraint.use_curve_follow -> use_curve_follow:   boolean  'Object will follow the heading and banking of the curve'
+FollowPathConstraint.use_curve_radius -> use_curve_radius:   boolean  'Objects scale by the curve radius'
+FollowPathConstraint.use_fixed_position -> use_fixed_location:   boolean  'Object will stay locked to a single point somewhere along the length of the curve regardless of time'
+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'
+Function.registered -> is_registered:   boolean,  '(read-only)    Function is registered as callback as part of type registration'
+Function.registered_optional -> is_registered_optional:   boolean,  '(read-only)    Function is optionally registered as callback part of type registration'
+GPencilFrame.frame_number -> frame_number:   int  'The frame on which this sketch appears'
+GPencilFrame.paint_lock -> is_edited:   boolean  'Frame is being edited (painted on)'
+GPencilFrame.select -> select:   boolean  'Frame is selected for editing in the DopeSheet'
+GPencilFrame.strokes -> strokes:   collection,  '(read-only)    Freehand curves defining the sketch on this frame'
+GPencilLayer.active -> active:   boolean  'Set active layer for editing'
+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.frame_lock -> lock_frame:   boolean  'Lock current frame displayed by layer'
+GPencilLayer.frames -> frames:   collection,  '(read-only)    Sketches for this layer on different frames'
+GPencilLayer.hide -> hide:   boolean  'Set layer Visibility'
+GPencilLayer.info -> info:   string  'Layer name'
+GPencilLayer.line_thickness -> line_width:   int  'Thickness of strokes (in pixels)'
+GPencilLayer.lock -> lock:   boolean  'Protect layer from further editing and/or frame changes'
+GPencilLayer.max_ghost_range -> ghost_range_max:   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'
+GPencilLayer.select -> select:   boolean  'Layer is selected for editing in the DopeSheet'
+GPencilLayer.show_points -> show_points:   boolean  'Draw the points which make up the strokes (for debugging purposes)'
+GPencilLayer.use_onion_skinning -> use_onion_skinning:   boolean  'Ghost frames on either side of frame'
+GPencilStroke.points -> points:   collection,  '(read-only)    Stroke data points'
+GPencilStrokePoint.co -> co:   float  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+GameBooleanProperty.value -> value:   boolean  'Property value'
+GameFloatProperty.value -> value:   float  'Property value'
+GameIntProperty.value -> value:   int  'Property value'
+GameObjectSettings.actor -> use_actor:   boolean  'Object is detected by the Near and Radar sensor'
+GameObjectSettings.actuators -> actuators:   collection,  '(read-only)    Game engine actuators to act on events'
+GameObjectSettings.all_states -> use_all_states:   boolean  'Set all state bits'
+GameObjectSettings.anisotropic_friction -> use_anisotropic_friction:   boolean  'Enable anisotropic friction'
+GameObjectSettings.collision_bounds -> collision_bounds:   enum  'Selects the collision type'
+GameObjectSettings.collision_compound -> use_collision_compound:   boolean  'Add children to form a compound collision object'
+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.debug_state -> show_debug_state:   boolean  'Print state debug info in the game engine'
+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.ghost -> use_ghost:   boolean  'Object does not restitute collisions, like a ghost'
+GameObjectSettings.initial_state -> states_initial:   boolean  'Initial state when the game starts'
+GameObjectSettings.lock_x_axis -> lock_location_x:   boolean  'Disable simulation of linear motion along the X axis'
+GameObjectSettings.lock_x_rot_axis -> lock_rotation_x:   boolean  'Disable simulation of angular  motion along the X axis'
+GameObjectSettings.lock_y_axis -> lock_location_y:   boolean  'Disable simulation of linear motion along the Y axis'
+GameObjectSettings.lock_y_rot_axis -> lock_rotation_y:   boolean  'Disable simulation of angular  motion along the Y axis'
+GameObjectSettings.lock_z_axis -> lock_location_z:   boolean  'Disable simulation of linear motion along the Z axis'
+GameObjectSettings.lock_z_rot_axis -> lock_rotation_z:   boolean  'Disable simulation of angular  motion along the Z axis'
+GameObjectSettings.mass -> mass:   float  'Mass of the object'
+GameObjectSettings.material_physics -> use_material_physics:   boolean  'Use physics settings in materials'
+GameObjectSettings.maximum_velocity -> velocity_max:   float  'Clamp velocity to this maximum speed'
+GameObjectSettings.minimum_velocity -> velocity_min:   float  'Clamp velocity to this minimum speed (except when totally still)'
+NEGATE * GameObjectSettings.no_sleeping -> use_sleep:   boolean  'Disable auto (de)activation in physics simulation'
+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.rotate_from_normal -> use_rotate_from_normal:   boolean  'Use face normal to rotate object, so that it points away from the surface'
+GameObjectSettings.rotation_damping -> rotation_damping:   float  'General rotation damping'
+GameObjectSettings.sensors -> sensors:   collection,  '(read-only)    Game engine sensor to detect events'
+GameObjectSettings.show_actuators -> show_actuators:   boolean  'Shows actuators for this object in the user interface'
+GameObjectSettings.show_controllers -> show_controllers:   boolean  'Shows controllers for this object in the user interface'
+GameObjectSettings.show_sensors -> show_sensors:   boolean  'Shows sensors for this object in the user interface'
+GameObjectSettings.show_state_panel -> show_state_panel:   boolean  'Show state panel'
+GameObjectSettings.soft_body -> soft_body:   pointer,  '(read-only)    Settings for Bullet soft body simulation'
+GameObjectSettings.use_activity_culling -> use_activity_culling:   boolean  'Disable simulation of angular  motion along the Z axis'
+GameObjectSettings.use_collision_bounds -> use_collision_bounds:   boolean  'Specify a collision bounds type other than the default'
+GameObjectSettings.used_state -> states_used:   boolean,  '(read-only)    States which are being used by controllers'
+GameObjectSettings.visible_state -> states_visible:   boolean  'State determining which controllers are displayed'
+GameProperty.debug -> show_debug:   boolean  'Print debug information for this property'
+GameProperty.name -> name:   string  "Available as GameObject attributes in the game engine's python API"
+GameProperty.type -> type:   enum  'NO DESCRIPTION'
+GameSoftBodySettings.bending_const -> use_bending_constraints:   boolean  'Enable bending constraints'
+GameSoftBodySettings.cluster_iterations -> cluster_iterations:   int  'Specify the number of cluster iterations'
+GameSoftBodySettings.cluster_rigid_to_softbody -> use_cluster_rigid_to_softbody:   boolean  'Enable cluster collision between soft and rigid body'
+GameSoftBodySettings.cluster_soft_to_softbody -> use_cluster_soft_to_softbody:   boolean  'Enable cluster collision between soft and soft body'
+GameSoftBodySettings.dynamic_friction -> dynamic_friction:   float  'Dynamic Friction'
+GameSoftBodySettings.linstiff -> linear_stiffness:   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.shape_match -> use_shape_match:   boolean  'Enable soft body shape matching goal'
+GameSoftBodySettings.threshold -> threshold:   float  'Shape matching threshold'
+GameSoftBodySettings.welding -> weld_threshold:   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.only_boost -> use_only_boost:   boolean  'Show the glow buffer only'
+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  'NO DESCRIPTION'
+GreasePencil.layers -> layers:   collection,  '(read-only)'
+GreasePencil.use_stroke_endpoints -> use_stroke_endpoints:   boolean  'Only use the first and last parts of the stroke for snapping'
+Group.dupli_offset -> dupli_offset:   float  'Offset from the origin to use when instancing as DupliGroup'
+Group.layer -> layers:   boolean  'Layers visible when this groups is instanced as a dupli'
+Group.objects -> objects:   collection,  '(read-only)    A collection of this groups objects'
+Header.bl_idname -> bl_idname:   string  'NO DESCRIPTION'
+Header.bl_space_type -> bl_space_type:   enum  'NO DESCRIPTION'
+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.fake_user -> use_fake_user:   boolean  'Saves this datablock even if it has no users'
+ID.library -> library:   pointer,  '(read-only)    Library file the datablock is linked from'
+ID.name -> name:   string  'Unique datablock ID name'
+ID.tag -> tag:   boolean  'Tools can use this to tag data, (initial state is undefined)'
+ID.users -> users:   int,  '(read-only)    Number of times this datablock is referenced'
+IDProperty.collection -> collection:   collection,  '(read-only)'
+IDProperty.double -> double:   float  'NO DESCRIPTION'
+IDProperty.double_array -> double_array:   float  'NO DESCRIPTION'
+IDProperty.float -> float:   float  'NO DESCRIPTION'
+IDProperty.float_array -> float_array:   float  'NO DESCRIPTION'
+IDProperty.group -> group:   pointer,  '(read-only)'
+IDProperty.int -> int:   int  'NO DESCRIPTION'
+IDProperty.int_array -> int_array:   int  'NO DESCRIPTION'
+IDProperty.string -> string:   string  'NO DESCRIPTION'
+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.animated -> use_animation:   boolean  'Use as animated texture in the game engine'
+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.clamp_x -> use_clamp_x:   boolean  'Disable texture repeating horizontally'
+Image.clamp_y -> use_clamp_y:   boolean  'Disable texture repeating vertically'
+Image.depth -> depth:   int,  '(read-only)    Image bit depth'
+Image.dirty -> is_dirty:   boolean,  '(read-only)    Image has changed and is not saved'
+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.fields -> use_fields:   boolean  'Use fields of the image'
+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.has_data -> has_data:   boolean,  '(read-only)    True if this image has data'
+Image.mapping -> mapping:   enum  'Mapping type to use for this image in the game engine'
+Image.packed_file -> packed_file:   pointer,  '(read-only)'
+Image.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
+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 -> use_tiles:   boolean  'Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)'
+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.invert_stencil -> invert_stencil:   boolean  'Invert the stencil layer'
+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)'
+ImagePaint.show_brush -> show_brush:   boolean  'Enables brush shape while not drawing'
+ImagePaint.show_brush_draw -> show_brush_draw:   boolean  'Enables brush shape while drawing'
+ImagePaint.use_backface_cull -> use_backface_culling:   boolean  'Ignore faces pointing away from the view (faster)'
+ImagePaint.use_clone_layer -> use_clone_layer:   boolean  'Use another UV layer as clone source, otherwise use 3D the cursor as the source'
+ImagePaint.use_normal_falloff -> use_normal_falloff:   boolean  'Paint most on faces pointing towards the view'
+ImagePaint.use_occlude -> use_occlude:   boolean  'Only paint onto the faces directly under the brush (slower)'
+ImagePaint.use_projection -> use_projection:   boolean  'Use projection painting for improved consistency in the brush strokes'
+ImagePaint.use_stencil_layer -> use_stencil_layer:   boolean  'Set the mask layer from the UV layer buttons'
+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.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
+ImageSequence.convert_float -> use_float:   boolean  'Convert input to float data'
+ImageSequence.crop -> crop:   pointer,  '(read-only)'
+ImageSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
+ImageSequence.directory -> directory:   string  'NO DESCRIPTION'
+ImageSequence.elements -> elements:   collection,  '(read-only)'
+ImageSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
+ImageSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
+ImageSequence.multiply_colors -> multiply_colors:   float  'NO DESCRIPTION'
+ImageSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
+ImageSequence.proxy -> proxy:   pointer,  '(read-only)'
+ImageSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
+ImageSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
+ImageSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
+ImageSequence.strobe -> strobe:   float  'Only display every nth frame'
+ImageSequence.transform -> transform:   pointer,  '(read-only)'
+ImageSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
+ImageSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
+ImageSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
+ImageSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
+ImageTexture.calculate_alpha -> use_calculate_alpha:   boolean  'Calculates an alpha channel based on RGB values in the image'
+ImageTexture.checker_distance -> checker_distance:   float  'Sets distance between checker tiles'
+ImageTexture.checker_even -> use_checker_even:   boolean  'Sets even checker tiles'
+ImageTexture.checker_odd -> use_checker_odd:   boolean  'Sets odd 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.filter_size_minimum -> use_minimum_filter_size:   boolean  'Use Filter Size as a minimal filter value in pixels'
+ImageTexture.flip_axis -> use_flip_axis:   boolean  "Flips the texture's X and Y axis"
+ImageTexture.image -> image:   pointer  'NO DESCRIPTION'
+ImageTexture.image_user -> image_user:   pointer,  '(read-only)    Parameters defining which layer, pass and frame of the image is displayed'
+ImageTexture.interpolation -> use_interpolation:   boolean  'Interpolates pixels using Area filter'
+ImageTexture.invert_alpha -> invert_alpha:   boolean  'Inverts all the alpha values in the image'
+ImageTexture.mipmap -> use_mipmap:   boolean  'Uses auto-generated MIP maps for the image'
+ImageTexture.mipmap_gauss -> use_mipmap_gauss:   boolean  'Uses Gauss filter to sample down MIP maps'
+ImageTexture.mirror_x -> use_mirror_x:   boolean  'Mirrors the image repetition on the X direction'
+ImageTexture.mirror_y -> use_mirror_y:   boolean  'Mirrors the image repetition on the Y direction'
+ImageTexture.normal_map -> use_normal_map:   boolean  'Uses image RGB values for normal mapping'
+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'
+ImageTexture.use_alpha -> use_alpha:   boolean  'Uses the alpha channel information in the image'
+ImageUser.auto_refresh -> use_auto_refresh:   boolean  'Always refresh image on frame changes'
+ImageUser.cyclic -> use_cyclic:   boolean  'Cycle the images in the movie'
+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.active -> use:   boolean  'Object contributes to the fluid simulation'
+InflowFluidSettings.export_animated_mesh -> use_animated_mesh:   boolean  'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
+InflowFluidSettings.inflow_velocity -> inflow_velocity:   float  'Initial velocity of fluid'
+InflowFluidSettings.local_coordinates -> use_local_coordinates:   boolean  'Use local coordinates for inflow. (e.g. for rotating objects)'
+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.auto_step -> use_auto_step:   boolean  'Automatically determine the optimal number of steps for best performance/accuracy trade off'
+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 -> step_max:   float  'Higher bound for timestep in second in case of automatic substeps'
+Itasc.max_velocity -> velocity_max:   float  'Maximum joint velocity in rad/s. Default=50'
+Itasc.min_step -> step_min:   float  'Lower bound for timestep in second in case of automatic substeps'
+Itasc.mode -> mode:   enum  'NO DESCRIPTION'
+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.all_events -> use_all_events:   boolean  'Triggered by all events on this joysticks current type (axis/button/hat)'
+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.relative -> use_relative:   boolean  'Makes shape keys relative'
+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'
+KeyConfig.user_defined -> is_user_defined:   boolean,  '(read-only)    Indicates that a keyconfig was defined by the user'
+KeyMap.children_expanded -> show_expanded_children:   boolean  'Children expanded in the user interface'
+KeyMap.items -> items:   collection,  '(read-only)    Items in the keymap, linking an operator to an input event'
+KeyMap.items_expanded -> show_expanded_items:   boolean  'Expanded in the user interface'
+KeyMap.modal -> is_modal:   boolean,  '(read-only)    Indicates that a keymap is used for translate modal events for an operator'
+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'
+KeyMap.user_defined -> is_user_defined:   boolean  'Keymap is defined by the user'
+KeyMapItem.active -> active:   boolean  'Activate or deactivate item'
+KeyMapItem.alt -> pressed_alt:   boolean  'Alt key pressed'
+KeyMapItem.any -> pressed_any:   boolean  'Any modifier keys pressed'
+KeyMapItem.ctrl -> pressed_ctrl:   boolean  'Control key pressed'
+KeyMapItem.expanded -> show_expanded:   boolean  'Show key map event and property details in the user interface'
+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.oskey -> pressed_cmd:   boolean  'Operating system key pressed'
+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.shift -> pressed_shift:   boolean  'Shift key pressed'
+KeyMapItem.type -> type:   enum  'Type of event'
+KeyMapItem.value -> value:   enum  'NO DESCRIPTION'
+KeyboardSensor.all_keys -> use_all_keys:   boolean  'Trigger this sensor on any keystroke'
+KeyboardSensor.key -> key:   enum  'NO DESCRIPTION'
+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 -> handle_left:   float  'Coordinates of the first handle'
+Keyframe.handle1_type -> handle_left_type:   enum  'Handle types'
+Keyframe.handle2 -> handle_right:   float  'Coordinates of the second handle'
+Keyframe.handle2_type -> handle_right_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.select_control_point -> select_control_point:   boolean  'Control point selection status'
+Keyframe.select_left_handle -> select_left_handle:   boolean  'Handle 1 selection status'
+Keyframe.select_right_handle -> select_right_handle:   boolean  'Handle 2 selection status'
+Keyframe.type -> type:   enum  'The type of keyframe'
+KeyingSet.absolute -> use_absolute:   boolean  'Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)'
+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.insertkey_needed -> use_insertkey_needed:   boolean  "Only insert keyframes where they're needed in the relevant F-Curves"
+KeyingSet.insertkey_visual -> use_insertkey_visual:   boolean  "Insert keyframes based on 'visual transforms'"
+KeyingSet.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:   boolean  'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
+KeyingSet.name -> name:   string  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+KeyingSetInfo.bl_label -> bl_label:   string  'NO DESCRIPTION'
+KeyingSetInfo.insertkey_needed -> use_insertkey_needed:   boolean  "Only insert keyframes where they're needed in the relevant F-Curves"
+KeyingSetInfo.insertkey_visual -> use_insertkey_visual:   boolean  "Insert keyframes based on 'visual transforms'"
+KeyingSetInfo.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:   boolean  'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
+KeyingSetPath.array_index -> array_index:   int  'Index to the specific setting if applicable'
+KeyingSetPath.data_path -> data_path:   string  'Path to property setting'
+KeyingSetPath.entire_array -> use_entire_array:   boolean  "When an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used"
+KeyingSetPath.group -> group:   string  'Name of Action Group to assign setting(s) for this path to'
+KeyingSetPath.grouping -> group_method:   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'
+KeyingSetPath.insertkey_needed -> use_insertkey_needed:   boolean  "Only insert keyframes where they're needed in the relevant F-Curves"
+KeyingSetPath.insertkey_visual -> use_insertkey_visual:   boolean  "Insert keyframes based on 'visual transforms'"
+KeyingSetPath.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:   boolean  'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+KinematicConstraint.pole_target -> pole_target:   pointer  'Object for pole rotation'
+KinematicConstraint.pos_lock_x -> lock_location_x:   boolean  'Constraint position along X axis'
+KinematicConstraint.pos_lock_y -> lock_location_y:   boolean  'Constraint position along Y axis'
+KinematicConstraint.pos_lock_z -> lock_location_z:   boolean  'Constraint position along Z axis'
+KinematicConstraint.rot_lock_x -> lock_rotation_x:   boolean  'Constraint rotation along X axis'
+KinematicConstraint.rot_lock_y -> lock_rotation_y:   boolean  'Constraint rotation along Y axis'
+KinematicConstraint.rot_lock_z -> lock_rotation_z:   boolean  'Constraint rotation along Z axis'
+KinematicConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
+KinematicConstraint.target -> target:   pointer  'Target Object'
+KinematicConstraint.use_position -> use_location:   boolean  'Chain follows position of target'
+KinematicConstraint.use_rotation -> use_rotation:   boolean  'Chain follows rotation of target'
+KinematicConstraint.use_stretch -> use_stretch:   boolean  'Enable IK Stretching'
+KinematicConstraint.use_tail -> use_tail:   boolean  "Include bone's tail as last element in chain"
+KinematicConstraint.use_target -> use_target:   boolean  'Disable for targetless IK'
+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.diffuse -> use_diffuse:   boolean  'Lamp does diffuse shading'
+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.layer -> use_own_layer:   boolean  'Illuminates objects only on the same layer the lamp is on'
+Lamp.negative -> use_negative:   boolean  'Lamp casts negative light'
+Lamp.specular -> use_specular:   boolean  'Lamp creates specular highlights'
+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_intensity:   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_intensity:   float  'Sun brightness'
+LampSkySettings.sun_intensity -> sun_intensity:   float  'Sun intensity'
+LampSkySettings.sun_size -> sun_size:   float  'Sun size'
+LampSkySettings.use_atmosphere -> use_atmosphere:   boolean  'Apply sun effect on atmosphere'
+LampSkySettings.use_sky -> use_sky:   boolean  'Apply sun effect on sky'
+LampTextureSlot.color_factor -> color_factor:   float  'Amount texture affects color values'
+LampTextureSlot.map_color -> use_map_color:   boolean  'Lets the texture affect the basic color of the lamp'
+LampTextureSlot.map_shadow -> use_map_shadow:   boolean  'Lets the texture affect the shadow color of the lamp'
+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  'NO DESCRIPTION'
+Lattice.interpolation_type_u -> interpolation_type_u:   enum  'NO DESCRIPTION'
+Lattice.interpolation_type_v -> interpolation_type_v:   enum  'NO DESCRIPTION'
+Lattice.interpolation_type_w -> interpolation_type_w:   enum  'NO DESCRIPTION'
+Lattice.outside -> use_outside:   boolean  'Only draw, and take into account, the outer vertices'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+LimitDistanceConstraint.target -> target:   pointer  'Target Object'
+LimitLocationConstraint.limit_transform -> limit_transform:   boolean  'Transforms are affected by this constraint as well'
+LimitLocationConstraint.maximum_x -> max_x:   float  'Highest X value to allow'
+LimitLocationConstraint.maximum_y -> max_y:   float  'Highest Y value to allow'
+LimitLocationConstraint.maximum_z -> max_z:   float  'Highest Z value to allow'
+LimitLocationConstraint.minimum_x -> min_x:   float  'Lowest X value to allow'
+LimitLocationConstraint.minimum_y -> min_y:   float  'Lowest Y value to allow'
+LimitLocationConstraint.minimum_z -> min_z:   float  'Lowest Z value to allow'
+LimitLocationConstraint.use_maximum_x -> use_max_x:   boolean  'Use the maximum X value'
+LimitLocationConstraint.use_maximum_y -> use_max_y:   boolean  'Use the maximum Y value'
+LimitLocationConstraint.use_maximum_z -> use_max_z:   boolean  'Use the maximum Z value'
+LimitLocationConstraint.use_minimum_x -> use_min_x:   boolean  'Use the minimum X value'
+LimitLocationConstraint.use_minimum_y -> use_min_y:   boolean  'Use the minimum Y value'
+LimitLocationConstraint.use_minimum_z -> use_min_z:   boolean  'Use the minimum Z value'
+LimitRotationConstraint.limit_transform -> limit_transform:   boolean  'Transforms are affected by this constraint as well'
+LimitRotationConstraint.maximum_x -> max_x:   float  'Highest X value to allow'
+LimitRotationConstraint.maximum_y -> max_y:   float  'Highest Y value to allow'
+LimitRotationConstraint.maximum_z -> max_z:   float  'Highest Z value to allow'
+LimitRotationConstraint.minimum_x -> min_x:   float  'Lowest X value to allow'
+LimitRotationConstraint.minimum_y -> min_y:   float  'Lowest Y value to allow'
+LimitRotationConstraint.minimum_z -> min_z:   float  'Lowest Z value to allow'
+LimitRotationConstraint.use_limit_x -> use_limit_x:   boolean  'Use the minimum X value'
+LimitRotationConstraint.use_limit_y -> use_limit_y:   boolean  'Use the minimum Y value'
+LimitRotationConstraint.use_limit_z -> use_limit_z:   boolean  'Use the minimum Z value'
+LimitScaleConstraint.limit_transform -> limit_transform:   boolean  'Transforms are affected by this constraint as well'
+LimitScaleConstraint.maximum_x -> max_x:   float  'Highest X value to allow'
+LimitScaleConstraint.maximum_y -> max_y:   float  'Highest Y value to allow'
+LimitScaleConstraint.maximum_z -> max_z:   float  'Highest Z value to allow'
+LimitScaleConstraint.minimum_x -> min_x:   float  'Lowest X value to allow'
+LimitScaleConstraint.minimum_y -> min_y:   float  'Lowest Y value to allow'
+LimitScaleConstraint.minimum_z -> min_z:   float  'Lowest Z value to allow'
+LimitScaleConstraint.use_maximum_x -> use_max_x:   boolean  'Use the maximum X value'
+LimitScaleConstraint.use_maximum_y -> use_max_y:   boolean  'Use the maximum Y value'
+LimitScaleConstraint.use_maximum_z -> use_max_z:   boolean  'Use the maximum Z value'
+LimitScaleConstraint.use_minimum_x -> use_min_x:   boolean  'Use the minimum X value'
+LimitScaleConstraint.use_minimum_y -> use_min_y:   boolean  'Use the minimum Y value'
+LimitScaleConstraint.use_minimum_z -> use_min_z:   boolean  'Use the minimum Z value'
+LockedTrackConstraint.lock -> lock:   enum  'Axis that points upward'
+LockedTrackConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
+LockedTrackConstraint.target -> target:   pointer  'Target Object'
+LockedTrackConstraint.track -> track:   enum  'Axis that points to the target object'
+Macro.bl_description -> bl_description:   string  'NO DESCRIPTION'
+Macro.bl_idname -> bl_idname:   string  'NO DESCRIPTION'
+Macro.bl_label -> bl_label:   string  'NO DESCRIPTION'
+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.debug -> show_debug:   boolean  'Print debugging information in console'
+Main.file_is_saved -> is_saved:   boolean,  '(read-only)    Has the current session been saved to disk as a .blend file'
+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  'NO DESCRIPTION'
+MarbleTexture.noisebasis2 -> noisebasis2:   enum  'NO DESCRIPTION'
+MarbleTexture.stype -> stype:   enum  'NO DESCRIPTION'
+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.invert -> invert_vertex_group:   boolean  'Use vertices that are not part of region defined'
+MaskModifier.mode -> mode:   enum  'NO DESCRIPTION'
+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.cast_approximate -> use_cast_approximate:   boolean  'Allow this material to cast shadows when using approximate ambient occlusion.'
+Material.cast_buffer_shadows -> use_cast_buffer_shadows:   boolean  'Allow this material to cast shadows from shadow buffer lamps'
+Material.cast_shadows_only -> use_cast_shadows_only:   boolean  'Makes objects with this material appear invisible, only casting shadows (not rendered)'
+Material.cubic -> use_cubic:   boolean  'Use cubic interpolation for diffuse values, for smoother transitions'
+Material.darkness -> darkness:   float  'Minnaert darkness'
+Material.diffuse_color -> diffuse_color:   float  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+Material.diffuse_ramp_factor -> diffuse_ramp_factor:   float  'Blending factor (also uses alpha in Colorband)'
+Material.diffuse_ramp_input -> diffuse_ramp_input:   enum  'NO DESCRIPTION'
+Material.diffuse_shader -> diffuse_shader:   enum  'NO DESCRIPTION'
+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'
+NEGATE * Material.exclude_mist -> use_mist:   boolean  'Excludes this material from mist effects (in world settings)'
+Material.face_texture -> use_face_texture:   boolean  "Replaces the object's base color with color from face assigned image textures"
+Material.face_texture_alpha -> use_face_texture_alpha:   boolean  "Replaces the object's base alpha value with alpha from face assigned image textures"
+Material.full_oversampling -> use_full_oversampling:   boolean  'Force this material to render full shading/textures for all anti-aliasing samples'
+Material.halo -> halo:   pointer,  '(read-only)    Halo settings for the material'
+Material.invert_z -> invert_z:   boolean  "Renders material's faces with an inverted Z buffer (scanline only)"
+Material.light_group -> light_group:   pointer  'Limit lighting to lamps in this Group'
+Material.light_group_exclusive -> use_light_group_exclusive:   boolean  'Material uses the light group exclusively - these lamps are excluded from other scene lighting'
+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.object_color -> use_object_color:   boolean  'Modulate the result with a per-object color'
+Material.only_shadow -> use_only_shadow:   boolean  "Renders shadows as the material's alpha value, making materials transparent except for shadowed areas"
+Material.physics -> physics:   pointer,  '(read-only)    Game physics settings'
+Material.preview_render_type -> preview_render_type:   enum  'Type of preview render'
+Material.ray_shadow_bias -> use_ray_shadow_bias:   boolean  'Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)'
+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.receive_transparent_shadows -> use_transparent_shadows:   boolean  'Allow this object to receive transparent shadows casted through other objects'
+Material.roughness -> rough:   float  'Oren-Nayar Roughness'
+Material.shadeless -> use_shadeless:   boolean  'Makes this material insensitive to light or shadow'
+Material.shadow_buffer_bias -> shadow_buffer_bias:   float  'Factor to multiply shadow buffer bias with (0 is ignore.)'
+Material.shadow_casting_alpha -> shadow_cast_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.shadows -> use_shadows:   boolean  'Allows this material to receive shadows'
+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_hard:   int  'NO DESCRIPTION'
+Material.specular_intensity -> specular_intensity:   float  'NO DESCRIPTION'
+Material.specular_ior -> specular_ior:   float  'NO DESCRIPTION'
+Material.specular_ramp -> specular_ramp:   pointer,  '(read-only)    Color ramp used to affect specular shading'
+Material.specular_ramp_blend -> specular_ramp_blend:   enum  'NO DESCRIPTION'
+Material.specular_ramp_factor -> specular_ramp_factor:   float  'Blending factor (also uses alpha in Colorband)'
+Material.specular_ramp_input -> specular_ramp_input:   enum  'NO DESCRIPTION'
+Material.specular_shader -> specular_shader:   enum  'NO DESCRIPTION'
+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.tangent_shading -> use_tangent_shading:   boolean  "Use the material's tangent vector instead of the normal for shading - for anisotropic shading effects"
+Material.texture_slots -> texture_slots:   collection,  '(read-only)    Texture slots defining the mapping and influence of textures'
+Material.traceable -> use_traceable:   boolean  'Include this material and geometry that uses it in ray tracing calculations'
+Material.translucency -> translucency:   float  'Amount of diffuse shading on the back side'
+Material.transparency -> use_transparency:   boolean  'Render material as transparent'
+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.use_diffuse_ramp -> use_diffuse_ramp:   boolean  'Toggle diffuse ramp operations'
+Material.use_nodes -> use_nodes:   boolean  'Use shader nodes to render the material'
+Material.use_sky -> use_sky:   boolean  'Renders this material with zero alpha, with sky background in place (scanline only)'
+Material.use_specular_ramp -> use_specular_ramp:   boolean  'Toggle specular ramp operations'
+Material.use_textures -> use_textures:   boolean  'Enable/Disable each texture'
+Material.vertex_color_light -> use_vertex_color_light:   boolean  'Add vertex colors as additional lighting'
+Material.vertex_color_paint -> use_vertex_color_paint:   boolean  "Replaces object base color with vertex colors (multiplies with 'texture face' face assigned textures)"
+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_mode -> use_flare_mode:   boolean  'Renders halo as a lensflare'
+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 -> hard:   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.lines -> use_lines:   boolean  'Renders star shaped lines over halo'
+MaterialHalo.ring -> use_ring:   boolean  'Renders rings over 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.shaded -> use_shading:   boolean  'Lets halo receive light and shadows from external objects'
+MaterialHalo.size -> size:   float  'Sets the dimension of the halo'
+MaterialHalo.soft -> use_soft:   boolean  'Softens the edges of halos at intersections with other geometry'
+MaterialHalo.star -> use_star:   boolean  'Renders halo as a star'
+MaterialHalo.star_tips -> star_tips:   int  'Sets the number of points on the star shaped halo'
+MaterialHalo.texture -> use_texture:   boolean  'Gives halo a texture'
+MaterialHalo.vertex_normal -> use_vertex_normal:   boolean  'Uses the vertex normal to specify the dimension of the halo'
+MaterialHalo.xalpha -> use_extreme_alpha:   boolean  'Uses extreme alpha'
+MaterialPhysics.align_to_normal -> use_align_to_normal:   boolean  'Align dynamic game objects along the surface normal, when inside the physics distance area'
+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.enabled -> use:   boolean  'Enable raytraced reflections'
+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.blender_units -> use_blender_units:   boolean  'Use Blender units for widths instead of pixels'
+MaterialStrand.min_size -> size_min:   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.surface_diffuse -> use_surface_diffuse:   boolean  'Make diffuse shading more similar to shading the surface'
+MaterialStrand.tangent_shading -> use_tangent_shading:   boolean  'Uses direction of strands as normal for tangent-shading'
+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.enabled -> use:   boolean  'Enable diffuse subsurface scatting effects in a material'
+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.enabled -> use:   boolean  'Enable this material texture slot'
+MaterialTextureSlot.from_dupli -> use_from_dupli:   boolean  "Dupli's instanced from verts, faces or particles, inherit texture coordinate from their parent"
+MaterialTextureSlot.from_original -> use_from_original:   boolean  "Dupli's derive their object coordinates from the original objects transformation"
+MaterialTextureSlot.hardness_factor -> hard_factor:   float  'Amount texture affects hardness'
+MaterialTextureSlot.map_alpha -> use_map_alpha:   boolean  'Causes the texture to affect the alpha value'
+MaterialTextureSlot.map_ambient -> use_map_ambient:   boolean  'Causes the texture to affect the value of ambient'
+MaterialTextureSlot.map_colordiff -> use_map_colordiff:   boolean  'Causes the texture to affect basic color of the material'
+MaterialTextureSlot.map_coloremission -> use_map_coloremission:   boolean  'Causes the texture to affect the color of emission'
+MaterialTextureSlot.map_colorreflection -> use_map_colorreflection:   boolean  'Causes the texture to affect the color of scattered light'
+MaterialTextureSlot.map_colorspec -> use_map_colorspec:   boolean  'Causes the texture to affect the specularity color'
+MaterialTextureSlot.map_colortransmission -> use_map_colortransmission:   boolean  'Causes the texture to affect the result color after other light has been scattered/absorbed'
+MaterialTextureSlot.map_density -> use_map_density:   boolean  "Causes the texture to affect the volume's density"
+MaterialTextureSlot.map_diffuse -> use_map_diffuse:   boolean  'Causes the texture to affect the value of the materials diffuse reflectivity'
+MaterialTextureSlot.map_displacement -> use_map_displacement:   boolean  'Let the texture displace the surface'
+MaterialTextureSlot.map_emission -> use_map_emission:   boolean  "Causes the texture to affect the volume's emission"
+MaterialTextureSlot.map_emit -> use_map_emit:   boolean  'Causes the texture to affect the emit value'
+MaterialTextureSlot.map_hardness -> use_map_hardness:   boolean  'Causes the texture to affect the hardness value'
+MaterialTextureSlot.map_mirror -> use_map_mirror:   boolean  'Causes the texture to affect the mirror color'
+MaterialTextureSlot.map_normal -> use_map_normal:   boolean  'Causes the texture to affect the rendered normal'
+MaterialTextureSlot.map_raymir -> use_map_raymir:   boolean  'Causes the texture to affect the ray-mirror value'
+MaterialTextureSlot.map_reflection -> use_map_reflect:   boolean  "Causes the texture to affect the reflected light's brightness"
+MaterialTextureSlot.map_scattering -> use_map_scatter:   boolean  "Causes the texture to affect the volume's scattering"
+MaterialTextureSlot.map_specular -> use_map_specular:   boolean  'Causes the texture to affect the value of specular reflectivity'
+MaterialTextureSlot.map_translucency -> use_map_translucency:   boolean  'Causes the texture to affect the translucency value'
+MaterialTextureSlot.map_warp -> use_map_warp:   boolean  'Let the texture warp texture coordinates of next channels'
+MaterialTextureSlot.mapping -> mapping:   enum  'NO DESCRIPTION'
+MaterialTextureSlot.mirror_factor -> mirror_factor:   float  'Amount texture affects mirror color'
+MaterialTextureSlot.new_bump -> use_new_bump:   boolean  'Use new, corrected bump mapping code (backwards compatibility option)'
+MaterialTextureSlot.normal_factor -> normal_factor:   float  'Amount texture affects normal values'
+MaterialTextureSlot.normal_map_space -> normal_map_space:   enum  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+MaterialTextureSlot.y_mapping -> y_mapping:   enum  'NO DESCRIPTION'
+MaterialTextureSlot.z_mapping -> z_mapping:   enum  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+MaterialVolume.external_shadows -> use_external_shadows:   boolean  'Receive shadows from sources outside the volume (temporary)'
+MaterialVolume.light_cache -> use_light_cache:   boolean  'Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy'
+MaterialVolume.lighting_mode -> light_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  'NO DESCRIPTION'
+Menu.bl_label -> bl_label:   string  'NO DESCRIPTION'
+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.all_edges -> show_all_edges:   boolean  'Displays all edges for wireframe in all view modes in the 3D view'
+Mesh.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
+Mesh.auto_texspace -> use_auto_texspace:   boolean  "Adjusts active object's texture space automatically when transforming object"
+Mesh.autosmooth -> use_autosmooth:   boolean  "Treats all set-smoothed faces with angles less than the specified angle as 'smooth' during render"
+Mesh.autosmooth_angle -> autosmooth_angle:   int  "Defines maximum angle between face normals that 'Auto Smooth' will operate on"
+Mesh.double_sided -> show_double_sided:   boolean  'Render/display the mesh with double or single sided lighting'
+Mesh.draw_bevel_weights -> show_bevel_weights:   boolean  'Displays weights created for the Bevel modifier'
+Mesh.draw_creases -> show_creases:   boolean  'Displays creases created for subsurf weighting'
+Mesh.draw_edge_angle -> show_edge_angle:   boolean  'Displays the angles in the selected edges in degrees'
+Mesh.draw_edge_length -> show_edge_length:   boolean  'Displays selected edge lengths, Using global values when set in the transform panel'
+Mesh.draw_edges -> show_edges:   boolean  'Displays selected edges using highlights in the 3D view and UV editor'
+Mesh.draw_face_area -> show_face_area:   boolean  'Displays the area of selected faces'
+Mesh.draw_faces -> show_faces:   boolean  'Displays all faces as shades in the 3D view and UV editor'
+Mesh.draw_normals -> show_normals:   boolean  'Displays face normals as lines'
+Mesh.draw_seams -> show_seams:   boolean  'Displays UV unwrapping seams'
+Mesh.draw_sharp -> show_sharp:   boolean  'Displays sharp edges, used with the EdgeSplit modifier'
+Mesh.draw_vertex_normals -> show_vertex_normals:   boolean  'Displays vertex normals as lines'
+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.use_mirror_topology -> use_mirror_topology:   boolean  'Use topology based mirroring'
+Mesh.use_mirror_x -> use_mirror_x:   boolean  'X Axis mirror editing'
+Mesh.use_paint_mask -> use_paint_mask:   boolean  'Face selection masking for painting'
+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  'NO DESCRIPTION'
+MeshColor.color2 -> color2:   float  'NO DESCRIPTION'
+MeshColor.color3 -> color3:   float  'NO DESCRIPTION'
+MeshColor.color4 -> color4:   float  'NO DESCRIPTION'
+MeshColorLayer.active -> active:   boolean  'Sets the layer as active for display and editing'
+MeshColorLayer.active_render -> active_render:   boolean  'Sets the layer as active for rendering'
+MeshColorLayer.data -> data:   collection,  '(read-only)'
+MeshColorLayer.name -> name:   string  'NO DESCRIPTION'
+MeshDeformModifier.dynamic -> use_dynamic_bind:   boolean  'Recompute binding dynamically on top of other deformers (slower and more memory consuming.)'
+MeshDeformModifier.invert -> invert_vertex_group:   boolean  'Invert vertex group influence'
+MeshDeformModifier.is_bound -> is_bound:   boolean,  '(read-only)    Whether geometry has been bound to control cage'
+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.fgon -> is_fgon:   boolean,  '(read-only)    Fgon edge'
+MeshEdge.hide -> hide:   boolean  'NO DESCRIPTION'
+MeshEdge.index -> index:   int,  '(read-only)    Index number of the vertex'
+MeshEdge.loose -> is_loose:   boolean,  '(read-only)    Loose edge'
+MeshEdge.seam -> use_seam:   boolean  'Seam edge for UV unwrapping'
+MeshEdge.select -> select:   boolean  'NO DESCRIPTION'
+MeshEdge.sharp -> use_sharp:   boolean  'Sharp edge for the EdgeSplit modifier'
+MeshEdge.verts -> verts:   int  'Vertex indices'
+MeshFace.area -> area:   float,  '(read-only)    read only area of the face'
+MeshFace.hide -> hide:   boolean  'NO DESCRIPTION'
+MeshFace.index -> index:   int,  '(read-only)    Index number of the vertex'
+MeshFace.material_index -> material_index:   int  'NO DESCRIPTION'
+MeshFace.normal -> normal:   float,  '(read-only)    local space unit length normal vector for this face'
+MeshFace.select -> select:   boolean  'NO DESCRIPTION'
+MeshFace.smooth -> use_smooth:   boolean  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+MeshFloatPropertyLayer.data -> data:   collection,  '(read-only)'
+MeshFloatPropertyLayer.name -> name:   string  'NO DESCRIPTION'
+MeshIntProperty.value -> value:   int  'NO DESCRIPTION'
+MeshIntPropertyLayer.data -> data:   collection,  '(read-only)'
+MeshIntPropertyLayer.name -> name:   string  'NO DESCRIPTION'
+MeshSticky.co -> co:   float  'Sticky texture coordinate location'
+MeshStringProperty.value -> value:   string  'NO DESCRIPTION'
+MeshStringPropertyLayer.data -> data:   collection,  '(read-only)'
+MeshStringPropertyLayer.name -> name:   string  'NO DESCRIPTION'
+MeshTextureFace.alpha_sort -> use_alpha_sort:   boolean  'Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible)'
+MeshTextureFace.billboard -> use_billboard:   boolean  'Billboard with Z-axis constraint'
+MeshTextureFace.collision -> use_collision:   boolean  'Use face for collision and ray-sensor detection'
+MeshTextureFace.halo -> use_halo:   boolean  'Screen aligned billboard'
+MeshTextureFace.image -> image:   pointer  'NO DESCRIPTION'
+MeshTextureFace.invisible -> hide:   boolean  'Make face invisible'
+MeshTextureFace.light -> use_light:   boolean  'Use light for face'
+MeshTextureFace.object_color -> use_object_color:   boolean  'Use ObColor instead of vertex colors'
+MeshTextureFace.select_uv -> select_uv:   boolean  'NO DESCRIPTION'
+MeshTextureFace.shadow -> use_shadow_face:   boolean  'Face is used for shadow'
+MeshTextureFace.shared -> use_blend_shared:   boolean  'Blend vertex colors across face when vertices are shared'
+MeshTextureFace.tex -> use_texture:   boolean  'Render face with texture'
+MeshTextureFace.text -> use_bitmap_text:   boolean  'Enable bitmap text on face'
+MeshTextureFace.transp -> transp:   enum  'Transparency blending mode'
+MeshTextureFace.twoside -> use_twoside:   boolean  'Render face two-sided'
+MeshTextureFace.uv -> uv:   float  'NO DESCRIPTION'
+MeshTextureFace.uv1 -> uv1:   float  'NO DESCRIPTION'
+MeshTextureFace.uv2 -> uv2:   float  'NO DESCRIPTION'
+MeshTextureFace.uv3 -> uv3:   float  'NO DESCRIPTION'
+MeshTextureFace.uv4 -> uv4:   float  'NO DESCRIPTION'
+MeshTextureFace.uv_pinned -> pin_uv:   boolean  'NO DESCRIPTION'
+MeshTextureFace.uv_raw -> uv_raw:   float  'Fixed size UV coordinates array'
+MeshTextureFaceLayer.active -> active:   boolean  'Sets the layer as active for display and editing'
+MeshTextureFaceLayer.active_clone -> active_clone:   boolean  'Sets the layer as active for cloning'
+MeshTextureFaceLayer.active_render -> active_render:   boolean  'Sets the layer as active for rendering'
+MeshTextureFaceLayer.data -> data:   collection,  '(read-only)'
+MeshTextureFaceLayer.name -> name:   string  'NO DESCRIPTION'
+MeshVertex.bevel_weight -> bevel_weight:   float  "Weight used by the Bevel modifier 'Only Vertices' option"
+MeshVertex.co -> co:   float  'NO DESCRIPTION'
+MeshVertex.groups -> groups:   collection,  '(read-only)    Weights for the vertex groups this vertex is member of'
+MeshVertex.hide -> hide:   boolean  'NO DESCRIPTION'
+MeshVertex.index -> index:   int,  '(read-only)    Index number of the vertex'
+MeshVertex.normal -> normal:   float  'Vertex Normal'
+MeshVertex.select -> select:   boolean  'NO DESCRIPTION'
+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.auto_texspace -> use_auto_texspace:   boolean  "Adjusts active object's texture space automatically when transforming object"
+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.hide -> hide:   boolean  'Hide element'
+MetaElement.location -> location:   float  'NO DESCRIPTION'
+MetaElement.negative -> use_negative:   boolean  'Set metaball as negative one'
+MetaElement.radius -> radius:   float  'NO DESCRIPTION'
+MetaElement.rotation -> rotation:   float  'NO DESCRIPTION'
+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.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
+MetaSequence.convert_float -> use_float:   boolean  'Convert input to float data'
+MetaSequence.crop -> crop:   pointer,  '(read-only)'
+MetaSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
+MetaSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
+MetaSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
+MetaSequence.multiply_colors -> multiply_colors:   float  'NO DESCRIPTION'
+MetaSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
+MetaSequence.proxy -> proxy:   pointer,  '(read-only)'
+MetaSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
+MetaSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
+MetaSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
+MetaSequence.sequences -> sequences:   collection,  '(read-only)'
+MetaSequence.strobe -> strobe:   float  'Only display every nth frame'
+MetaSequence.transform -> transform:   pointer,  '(read-only)'
+MetaSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
+MetaSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
+MetaSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
+MetaSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
+MirrorModifier.clip -> use_clip:   boolean  'Prevents vertices from going through the mirror during transform'
+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'
+MirrorModifier.mirror_u -> use_mirror_u:   boolean  'Mirror the U texture coordinate around the 0.5 point'
+MirrorModifier.mirror_v -> use_mirror_v:   boolean  'Mirror the V texture coordinate around the 0.5 point'
+MirrorModifier.mirror_vertex_groups -> use_mirror_vertex_groups:   boolean  'Mirror vertex groups (e.g. .R->.L)'
+MirrorModifier.x -> use_x:   boolean  'Enable X axis mirror'
+MirrorModifier.y -> use_y:   boolean  'Enable Y axis mirror'
+MirrorModifier.z -> use_z:   boolean  'Enable Z axis mirror'
+Modifier.editmode -> show_in_editmode:   boolean  'Use modifier while in the edit mode'
+Modifier.expanded -> show_expanded:   boolean  'Set modifier expanded in the user interface'
+Modifier.name -> name:   string  'Modifier name'
+Modifier.on_cage -> show_on_cage:   boolean  'Enable direct editing of modifier control cage'
+Modifier.realtime -> show_realtime:   boolean  'Realtime display of a modifier'
+Modifier.render -> use_render:   boolean  'Use modifier during rendering'
+Modifier.type -> type:   enum,  '(read-only)'
+MotionPath.editing -> is_edited:   boolean  'Path is being edited'
+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'
+MotionPath.use_bone_head -> use_bone_head:   boolean,  '(read-only)    For PoseBone paths, use the bone head location when calculating this path'
+MotionPathVert.co -> co:   float  'NO DESCRIPTION'
+MotionPathVert.select -> select:   boolean  'Path point is selected for editing'
+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.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
+MovieSequence.convert_float -> use_float:   boolean  'Convert input to float data'
+MovieSequence.crop -> crop:   pointer,  '(read-only)'
+MovieSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
+MovieSequence.filepath -> filepath:   string  'NO DESCRIPTION'
+MovieSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
+MovieSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
+MovieSequence.mpeg_preseek -> mpeg_preseek:   int  'For MPEG movies, preseek this many frames'
+MovieSequence.multiply_colors -> multiply_colors:   float  'NO DESCRIPTION'
+MovieSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
+MovieSequence.proxy -> proxy:   pointer,  '(read-only)'
+MovieSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
+MovieSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
+MovieSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
+MovieSequence.strobe -> strobe:   float  'Only display every nth frame'
+MovieSequence.transform -> transform:   pointer,  '(read-only)'
+MovieSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
+MovieSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
+MovieSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
+MovieSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
+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.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
+MulticamSequence.convert_float -> use_float:   boolean  'Convert input to float data'
+MulticamSequence.crop -> crop:   pointer,  '(read-only)'
+MulticamSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
+MulticamSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
+MulticamSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
+MulticamSequence.multicam_source -> multicam_source:   int  'NO DESCRIPTION'
+MulticamSequence.multiply_colors -> multiply_colors:   float  'NO DESCRIPTION'
+MulticamSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
+MulticamSequence.proxy -> proxy:   pointer,  '(read-only)'
+MulticamSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
+MulticamSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
+MulticamSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
+MulticamSequence.strobe -> strobe:   float  'Only display every nth frame'
+MulticamSequence.transform -> transform:   pointer,  '(read-only)'
+MulticamSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
+MulticamSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
+MulticamSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
+MulticamSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
+MultiresModifier.external -> is_external:   boolean,  '(read-only)    Store multires displacements outside the .blend file, to save memory'
+MultiresModifier.filepath -> filepath:   string  'Path to external displacements file'
+MultiresModifier.levels -> levels:   int  'Number of subdivisions to use in the viewport'
+MultiresModifier.optimal_display -> show_only_control_edges:   boolean  'Skip drawing/rendering of interior subdivided edges'
+MultiresModifier.render_levels -> render_levels:   int  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+NetRenderJob.name -> name:   string  'NO DESCRIPTION'
+NetRenderSettings.active_blacklisted_slave_index -> active_blacklisted_slave_index:   int  'NO DESCRIPTION'
+NetRenderSettings.active_job_index -> active_job_index:   int  'NO DESCRIPTION'
+NetRenderSettings.active_slave_index -> active_slave_index:   int  'NO DESCRIPTION'
+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.master_broadcast -> use_master_broadcast:   boolean  'broadcast master server address on local network'
+NetRenderSettings.master_clear -> use_master_clear:   boolean  'delete saved files on exit'
+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.slave_clear -> use_slave_clear:   boolean  'delete downloaded files on exit'
+NetRenderSettings.slave_outputlog -> use_slave_output_log:   boolean  'Output render text log to console as well as sending it to the master'
+NetRenderSettings.slave_thumb -> use_slave_thumb:   boolean  'Generate thumbnails on slaves instead of master'
+NetRenderSettings.slaves -> slaves:   collection,  '(read-only)'
+NetRenderSettings.slaves_blacklist -> slaves_blacklist:   collection,  '(read-only)'
+NetRenderSlave.name -> name:   string  'NO DESCRIPTION'
+NlaStrip.action -> action:   pointer  'Action referenced by this strip'
+NlaStrip.action_frame_end -> action_frame_end:   float  'NO DESCRIPTION'
+NlaStrip.action_frame_start -> action_frame_start:   float  'NO DESCRIPTION'
+NlaStrip.active -> active:   boolean,  '(read-only)    NLA Strip is active'
+NlaStrip.animated_influence -> use_animated_influence:   boolean  'Influence setting is controlled by an F-Curve rather than automatically determined'
+NlaStrip.animated_time -> use_animated_time:   boolean  'Strip time is controlled by an F-Curve rather than automatically determined'
+NlaStrip.animated_time_cyclic -> use_animated_time_cyclic:   boolean  'Cycle the animated time within the action start & end'
+NlaStrip.auto_blending -> use_auto_blend:   boolean  'Number of frames for Blending In/Out is automatically determined from overlapping strips'
+NlaStrip.blend_in -> blend_in:   float  'Number of frames at start of strip to fade in influence'
+NlaStrip.blend_out -> blend_out:   float  'NO DESCRIPTION'
+NlaStrip.blending -> blend_type:   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  'NO DESCRIPTION'
+NlaStrip.frame_start -> frame_start:   float  'NO DESCRIPTION'
+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.mute -> mute:   boolean  'NLA Strip is not evaluated'
+NlaStrip.name -> name:   string  'NO DESCRIPTION'
+NlaStrip.repeat -> repeat:   float  'Number of times to repeat the action range'
+NlaStrip.reversed -> use_reverse:   boolean  'NLA Strip is played back in reverse order (only when timing is automatically determined)'
+NlaStrip.scale -> scale:   float  'Scaling factor for action'
+NlaStrip.select -> select:   boolean  'NLA Strip is selected'
+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.active -> active:   boolean,  '(read-only)    NLA Track is active'
+NlaTrack.lock -> lock:   boolean  'NLA Track is locked'
+NlaTrack.mute -> mute:   boolean  'NLA Track is not evaluated'
+NlaTrack.name -> name:   string  'NO DESCRIPTION'
+NlaTrack.select -> select:   boolean  'NLA Track is selected'
+NlaTrack.solo -> is_solo:   boolean,  '(read-only)    NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)'
+NlaTrack.strips -> strips:   collection,  '(read-only)    NLA Strips on this NLA-track'
+Node.inputs -> inputs:   collection,  '(read-only)'
+Node.location -> location:   float  'NO DESCRIPTION'
+Node.name -> name:   string  'Node name'
+Node.outputs -> outputs:   collection,  '(read-only)'
+NodeGroup.nodetree -> nodetree:   pointer  'NO DESCRIPTION'
+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_axis -> show_axis:   boolean  "Displays the object's origin and axis"
+Object.draw_bounds -> show_bounds:   boolean  "Displays the object's bounds"
+Object.draw_bounds_type -> draw_bounds_type:   enum  'Object boundary display type'
+Object.draw_name -> show_name:   boolean  "Displays the object's name"
+Object.draw_texture_space -> show_texture_space:   boolean  "Displays the object's texture space"
+Object.draw_transparent -> show_transparent:   boolean  'Enables transparent materials for the object (Mesh only)'
+Object.draw_wire -> show_wire:   boolean  "Adds the object's wireframe over solid drawing"
+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.duplis_used -> is_duplicator:   boolean,  '(read-only)'
+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.hide -> hide:   boolean  'Restrict visibility in the viewport'
+Object.hide_render -> hide_render:   boolean  'Restrict renderability'
+Object.hide_select -> hide_select:   boolean  'Restrict selection in the viewport'
+Object.layers -> layers:   boolean  'Layers the object is on'
+Object.location -> location:   float  'Location of the object'
+Object.lock_location -> lock_location:   boolean  'Lock editing of location in the interface'
+Object.lock_rotation -> lock_rotation:   boolean  'Lock editing of rotation in the interface'
+Object.lock_rotation_w -> lock_rotation_w:   boolean  "Lock editing of 'angle' component of four-component rotations in the interface"
+Object.lock_rotations_4d -> lock_rotations_4d:   boolean  'Lock editing of four component rotations by components (instead of as Eulers)'
+Object.lock_scale -> lock_scale:   boolean  'Lock editing of scale in the interface'
+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 -> 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  'NO DESCRIPTION'
+Object.rotation_quaternion -> rotation_quaternion:   float  'Rotation in Quaternions'
+Object.scale -> scale:   float  'Scaling of the object'
+Object.select -> select:   boolean  'Object selection state'
+Object.shape_key_edit_mode -> use_shape_key_edit_mode:   boolean  'Apply shape keys in edit mode (for Meshes only)'
+Object.shape_key_lock -> show_shape_key:   boolean  'Always show the current Shape for this Object'
+Object.slow_parent -> use_slow_parent:   boolean  'Create a delay in the parent relationship'
+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.time_offset_add_parent -> use_time_offset_add_parent:   boolean  'Add the parents time offset value'
+Object.time_offset_edit -> use_time_offset_edit:   boolean  'Use time offset when inserting keys and display time offset for F-Curve and action views'
+Object.time_offset_parent -> use_time_offset_parent:   boolean  'Apply the time offset to this objects parent relationship'
+Object.time_offset_particle -> use_time_offset_particle:   boolean  'Let the time offset work on the particle effect'
+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.use_dupli_faces_scale -> use_dupli_faces_scale:   boolean  'Scale dupli based on face size'
+Object.use_dupli_frames_speed -> use_dupli_frames_speed:   boolean  'Set dupliframes to use the frame'
+Object.use_dupli_verts_rotation -> use_dupli_verts_rotation:   boolean  'Rotate dupli according to vertex normal'
+Object.vertex_groups -> vertex_groups:   collection,  '(read-only)    Vertex groups of the object'
+Object.x_ray -> show_x_ray:   boolean  'Makes the object draw in front of others'
+ObjectActuator.add_linear_velocity -> use_add_linear_velocity:   boolean  'Toggles between ADD and SET linV'
+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.local_angular_velocity -> use_local_angular_velocity:   boolean  'Angular velocity is defined in local coordinates'
+ObjectActuator.local_force -> use_local_force:   boolean  'Force is defined in local coordinates'
+ObjectActuator.local_linear_velocity -> use_local_linear_velocity:   boolean  'Velocity is defined in local coordinates'
+ObjectActuator.local_location -> use_local_location:   boolean  'Location is defined in local coordinates'
+ObjectActuator.local_rotation -> use_local_rotation:   boolean  'Rotation is defined in local coordinates'
+ObjectActuator.local_torque -> use_local_torque:   boolean  'Torque is defined in local coordinates'
+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.servo_limit_x -> use_servo_limit_x:   boolean  'Set limit to force along the X axis'
+ObjectActuator.servo_limit_y -> use_servo_limit_y:   boolean  'Set limit to force along the Y axis'
+ObjectActuator.servo_limit_z -> use_servo_limit_z:   boolean  'Set limit to force along the Z axis'
+ObjectActuator.torque -> torque:   float  'Sets the torque'
+ObjectBase.layers -> layers:   boolean  'Layers the object base is on'
+ObjectBase.object -> object:   pointer,  '(read-only)    Object this base links to'
+ObjectBase.select -> select:   boolean  'Object base selection state'
+ObjectConstraints.active -> active:   pointer  'Active Object constraint'
+ObstacleFluidSettings.active -> use:   boolean  'Object contributes to the fluid simulation'
+ObstacleFluidSettings.export_animated_mesh -> use_animated_mesh:   boolean  'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
+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  'NO DESCRIPTION'
+ObstacleFluidSettings.volume_initialization -> volume_initialization:   enum  'Volume initialization type'
+Operator.bl_description -> bl_description:   string  'NO DESCRIPTION'
+Operator.bl_idname -> bl_idname:   string  'NO DESCRIPTION'
+Operator.bl_label -> bl_label:   string  'NO DESCRIPTION'
+Operator.bl_options -> bl_options:   enum  'Options for this operator type'
+Operator.has_reports -> has_reports:   boolean,  '(read-only)    Operator has a set of reports (warnings and errors) from last execution'
+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  'NO DESCRIPTION'
+OperatorStrokeElement.mouse -> mouse:   float  'NO DESCRIPTION'
+OperatorStrokeElement.pen_flip -> pen_flip:   boolean  'NO DESCRIPTION'
+OperatorStrokeElement.pressure -> pressure:   float  'Tablet pressure'
+OperatorStrokeElement.time -> time:   float  'NO DESCRIPTION'
+OperatorTypeMacro.properties -> properties:   pointer,  '(read-only)'
+OutflowFluidSettings.active -> use:   boolean  'Object contributes to the fluid simulation'
+OutflowFluidSettings.export_animated_mesh -> use_animated_mesh:   boolean  'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
+OutflowFluidSettings.volume_initialization -> volume_initialization:   enum  'Volume initialization type'
+PackedFile.size -> size:   int,  '(read-only)    Size of packed file in bytes'
+Paint.brush -> brush:   pointer  'Active paint brush'
+Paint.fast_navigate -> show_low_resolution:   boolean  'For multires, show low resolution while navigating the view'
+Paint.show_brush -> show_brush:   boolean  'NO DESCRIPTION'
+Paint.show_brush_on_surface -> show_brush_on_surface:   boolean  'NO DESCRIPTION'
+Panel.bl_context -> bl_context:   string  'NO DESCRIPTION'
+Panel.bl_default_closed -> bl_use_closed:   boolean  'NO DESCRIPTION'
+Panel.bl_idname -> bl_idname:   string  'NO DESCRIPTION'
+Panel.bl_label -> bl_label:   string  'NO DESCRIPTION'
+Panel.bl_region_type -> bl_region_type:   enum  'NO DESCRIPTION'
+Panel.bl_show_header -> bl_show_header:   boolean  'NO DESCRIPTION'
+Panel.bl_space_type -> bl_space_type:   enum  'NO DESCRIPTION'
+Panel.layout -> layout:   pointer,  '(read-only)'
+Panel.text -> text:   string  'NO DESCRIPTION'
+ParentActuator.compound -> use_compound:   boolean  'Add this object shape to the parent shape (only if the parent shape is already compound)'
+ParentActuator.ghost -> use_ghost:   boolean  'Make this object ghost while parented (only if not compound)'
+ParentActuator.mode -> mode:   enum  'NO DESCRIPTION'
+ParentActuator.object -> object:   pointer  'Set this object as parent'
+Particle.alive_state -> alive_state:   enum  'NO DESCRIPTION'
+Particle.angular_velocity -> angular_velocity:   float  'NO DESCRIPTION'
+Particle.birthtime -> birthtime:   float  'NO DESCRIPTION'
+Particle.die_time -> die_time:   float  'NO DESCRIPTION'
+Particle.hair -> hair:   collection,  '(read-only)'
+Particle.is_existing -> is_existing:   boolean,  '(read-only)'
+Particle.is_visible -> is_visible:   boolean,  '(read-only)'
+Particle.keys -> keys:   collection,  '(read-only)'
+Particle.lifetime -> lifetime:   float  'NO DESCRIPTION'
+Particle.location -> location:   float  'NO DESCRIPTION'
+Particle.prev_angular_velocity -> prev_angular_velocity:   float  'NO DESCRIPTION'
+Particle.prev_location -> prev_location:   float  'NO DESCRIPTION'
+Particle.prev_rotation -> prev_rotation:   float  'NO DESCRIPTION'
+Particle.prev_velocity -> prev_velocity:   float  'NO DESCRIPTION'
+Particle.rotation -> rotation:   float  'NO DESCRIPTION'
+Particle.size -> size:   float  'NO DESCRIPTION'
+Particle.velocity -> velocity:   float  'NO DESCRIPTION'
+ParticleBrush.count -> count:   int  'Particle count'
+ParticleBrush.curve -> curve:   pointer,  '(read-only)'
+ParticleBrush.length_mode -> length_mode:   enum  'NO DESCRIPTION'
+ParticleBrush.puff_mode -> puff_mode:   enum  'NO DESCRIPTION'
+ParticleBrush.size -> size:   int  'Brush size'
+ParticleBrush.steps -> steps:   int  'Brush steps'
+ParticleBrush.strength -> strength:   float  'Brush strength'
+ParticleBrush.use_puff_volume -> use_puff_volume:   boolean  'Apply puff to unselected end-points, (helps maintain hair volume when puffing root)'
+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_interpolate -> use_add_interpolate:   boolean  'Interpolate new particles from the existing ones'
+ParticleEdit.add_keys -> add_keys:   int  'How many keys to make new particles with'
+ParticleEdit.auto_velocity -> use_auto_velocity:   boolean  'Calculate point velocities automatically'
+ParticleEdit.brush -> brush:   pointer,  '(read-only)'
+ParticleEdit.draw_particles -> show_particles:   boolean  'Draw actual particles'
+ParticleEdit.draw_step -> draw_step:   int  'How many steps to draw the path with'
+ParticleEdit.editable -> is_editable:   boolean,  '(read-only)    A valid edit mode exists'
+ParticleEdit.emitter_deflect -> use_emitter_deflect:   boolean  'Keep paths from intersecting the emitter'
+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.fade_time -> use_fade_time:   boolean  'Fade paths and keys further away from current frame'
+ParticleEdit.hair -> is_hair:   boolean,  '(read-only)    Editing hair'
+ParticleEdit.keep_lengths -> use_preserve_lengths:   boolean  'Keep path lengths constant'
+ParticleEdit.keep_root -> use_preserve_root:   boolean  'Keep root keys unmodified'
+ParticleEdit.object -> object:   pointer,  '(read-only)    The edited object'
+ParticleEdit.selection_mode -> selection_mode:   enum  'Particle select and display mode'
+ParticleEdit.tool -> tool:   enum  'NO DESCRIPTION'
+ParticleEdit.type -> type:   enum  'NO DESCRIPTION'
+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.drops -> use_drops:   boolean  'Show drop particles'
+ParticleFluidSettings.floats -> use_floats:   boolean  'Show floating foam particles'
+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'
+ParticleFluidSettings.tracer -> use_tracer:   boolean  'Show tracer particles'
+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.alive -> use_alive:   boolean  'Show instances when particles are alive'
+ParticleInstanceModifier.axis -> axis:   enum  'Pole axis for rotation'
+ParticleInstanceModifier.children -> use_children:   boolean  'Create instances from child particles'
+ParticleInstanceModifier.dead -> use_dead:   boolean  'Show instances when particles are dead'
+ParticleInstanceModifier.keep_shape -> use_preserve_shape:   boolean  "Don't stretch the object"
+ParticleInstanceModifier.normal -> use_normal:   boolean  'Create instances from normal particles'
+ParticleInstanceModifier.object -> object:   pointer  'Object that has the particle system'
+ParticleInstanceModifier.particle_system_number -> particle_system_number:   int  'NO DESCRIPTION'
+ParticleInstanceModifier.position -> position:   float  'Position along path'
+ParticleInstanceModifier.random_position -> random_position:   float  'Randomize position along path'
+ParticleInstanceModifier.size -> use_size:   boolean  'Use particle size to scale the instances'
+ParticleInstanceModifier.unborn -> use_unborn:   boolean  'Show instances when particles are unborn'
+ParticleInstanceModifier.use_path -> use_path:   boolean  'Create instances along particle paths'
+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.abs_path_time -> use_absolute_path_time:   boolean  'Path timing is in absolute frames'
+ParticleSettings.active_dupliweight -> active_dupliweight:   pointer,  '(read-only)'
+ParticleSettings.active_dupliweight_index -> active_dupliweight_index:   int  'NO DESCRIPTION'
+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.animate_branching -> use_animate_branching:   boolean  'Animate branching'
+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_lock -> lock_billboard:   boolean  'Lock the billboards align axis'
+ParticleSettings.billboard_object -> billboard_object:   pointer  'Billboards face this object (default is active camera)'
+ParticleSettings.billboard_offset -> billboard_offset:   float  'NO DESCRIPTION'
+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.boids_2d -> lock_boids_to_surface:   boolean  'Constrain boids to a surface'
+ParticleSettings.branch_threshold -> branch_threshold:   float  'Threshold of branching'
+ParticleSettings.branching -> use_branching:   boolean  'Branch child paths from each other'
+ParticleSettings.brownian_factor -> brownian_factor:   float  'Specify the amount of Brownian motion'
+ParticleSettings.child_effector -> apply_effector_to_children:   boolean  'Apply effectors to children'
+ParticleSettings.child_guide -> apply_guide_to_children:   boolean  'NO DESCRIPTION'
+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.die_on_collision -> use_die_on_collision:   boolean  'Particles die when they collide with a deflector object'
+ParticleSettings.died -> use_died:   boolean  'Show particles after they have died'
+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_health -> show_health:   boolean  'Draw boid health'
+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.emitter -> use_render_emitter:   boolean  'Render emitter Object also'
+ParticleSettings.enable_simplify -> use_simplify:   boolean  'Remove child strands as the object becomes smaller on the screen'
+ParticleSettings.even_distribution -> use_even_distribution:   boolean  'Use even distribution from faces based on face areas or edge lengths'
+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_invert -> invert_grid:   boolean  'Invert what is considered object and what is not'
+ParticleSettings.grid_resolution -> grid_resolution:   int  'The resolution of the particle grid'
+ParticleSettings.hair_bspline -> use_hair_bspline:   boolean  'Interpolate hair using B-Splines'
+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  'NO DESCRIPTION'
+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.material_color -> show_material_color:   boolean  "Draw particles using material's diffuse color"
+ParticleSettings.normal_factor -> normal_factor:   float  'Let the surface normal give the particle a starting speed'
+ParticleSettings.num -> show_number:   boolean  'Show particle number'
+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.parent -> use_parents:   boolean  'Render parent particles'
+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.rand_group -> use_group_pick_random:   boolean  'Pick objects from group randomly'
+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.react_multiple -> use_react_multiple:   boolean  'React multiple times'
+ParticleSettings.react_start_end -> use_react_start_end:   boolean  'Give birth to unreacted particles eventually'
+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_adaptive -> use_render_adaptive:   boolean  'Use adapative rendering for paths'
+ParticleSettings.render_step -> render_step:   int  'How many steps paths are rendered with (power of 2)'
+ParticleSettings.render_strand -> use_strand_primitive:   boolean  'Use the strand primitive for rendering'
+ParticleSettings.rendered_child_nbr -> rendered_child_nbr:   int  'Amount of children/parent for rendering'
+ParticleSettings.rotate_from -> rotate_from:   enum  'NO DESCRIPTION'
+ParticleSettings.rotation_dynamic -> use_dynamic_rotation:   boolean  'Sets rotation to dynamic/constant'
+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.self_effect -> use_self_effect:   boolean  'Particle effectors effect themselves'
+ParticleSettings.show_size -> show_size:   boolean  'Show particle size'
+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.size_deflect -> use_size_deflect:   boolean  "Use particle's size in deflection"
+ParticleSettings.sizemass -> use_multiply_size_mass:   boolean  'Multiply mass by particle size'
+ParticleSettings.subframes -> subframes:   int  'Subframes to simulate for improved stability and finer granularity simulations'
+ParticleSettings.symmetric_branching -> use_symmetric_branching:   boolean  'Start and end points are the same'
+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.trand -> use_emit_random:   boolean  'Emit in random order of elements'
+ParticleSettings.type -> type:   enum  'NO DESCRIPTION'
+ParticleSettings.unborn -> use_unborn:   boolean  'Show particles before they are emitted'
+ParticleSettings.use_global_dupli -> use_global_dupli:   boolean  "Use object's global coordinates for duplication"
+ParticleSettings.use_group_count -> use_group_count:   boolean  'Use object multiple times in the same group'
+ParticleSettings.userjit -> userjit:   int  'Emission locations / face (0 = automatic)'
+ParticleSettings.velocity -> show_velocity:   boolean  'Show particle velocity'
+ParticleSettings.velocity_length -> use_velocity_length:   boolean  'Multiply line length by particle speed'
+ParticleSettings.viewport -> use_simplify_viewport:   boolean  'NO DESCRIPTION'
+ParticleSettings.virtual_parents -> virtual_parents:   float  'Relative amount of virtual parents'
+ParticleSettings.whole_group -> use_whole_group:   boolean  'Use whole group at once'
+ParticleSystem.active_particle_target -> active_particle_target:   pointer,  '(read-only)'
+ParticleSystem.active_particle_target_index -> active_particle_target_index:   int  'NO DESCRIPTION'
+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.editable -> is_editable:   boolean,  '(read-only)    Particle system can be edited in particle mode'
+ParticleSystem.edited -> is_edited:   boolean,  '(read-only)    Particle system has been edited in particle mode'
+ParticleSystem.global_hair -> is_global_hair:   boolean,  '(read-only)    Hair keys are in global coordinate space'
+ParticleSystem.hair_dynamics -> use_hair_dynamics:   boolean  'Enable hair dynamics using cloth simulation'
+ParticleSystem.keyed_timing -> use_keyed_timing:   boolean  'Use key times'
+ParticleSystem.multiple_caches -> has_multiple_caches:   boolean,  '(read-only)    Particle system has multiple point caches'
+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_clump_negate -> invert_vertex_group_clump:   boolean  'Negate the effect of the clump vertex group'
+ParticleSystem.vertex_group_density -> vertex_group_density:   string  'Vertex group to control density'
+ParticleSystem.vertex_group_density_negate -> invert_vertex_group_density:   boolean  'Negate the effect of the density vertex group'
+ParticleSystem.vertex_group_field -> vertex_group_field:   string  'Vertex group to control field'
+ParticleSystem.vertex_group_field_negate -> invert_vertex_group_field:   boolean  'Negate the effect of the field vertex group'
+ParticleSystem.vertex_group_kink -> vertex_group_kink:   string  'Vertex group to control kink'
+ParticleSystem.vertex_group_kink_negate -> invert_vertex_group_kink:   boolean  'Negate the effect of the kink vertex group'
+ParticleSystem.vertex_group_length -> vertex_group_length:   string  'Vertex group to control length'
+ParticleSystem.vertex_group_length_negate -> invert_vertex_group_length:   boolean  'Negate the effect of the length vertex group'
+ParticleSystem.vertex_group_rotation -> vertex_group_rotation:   string  'Vertex group to control rotation'
+ParticleSystem.vertex_group_rotation_negate -> invert_vertex_group_rotation:   boolean  'Negate the effect of the rotation vertex group'
+ParticleSystem.vertex_group_roughness1 -> vertex_group_rough1:   string  'Vertex group to control roughness 1'
+ParticleSystem.vertex_group_roughness1_negate -> invert_vertex_group_roughness1:   boolean  'Negate the effect of the roughness 1 vertex group'
+ParticleSystem.vertex_group_roughness2 -> vertex_group_rough2:   string  'Vertex group to control roughness 2'
+ParticleSystem.vertex_group_roughness2_negate -> invert_vertex_group_roughness2:   boolean  'Negate the effect of the roughness 2 vertex group'
+ParticleSystem.vertex_group_roughness_end -> vertex_group_rough_end:   string  'Vertex group to control roughness end'
+ParticleSystem.vertex_group_roughness_end_negate -> invert_vertex_group_roughness_end:   boolean  'Negate the effect of the roughness end vertex group'
+ParticleSystem.vertex_group_size -> vertex_group_size:   string  'Vertex group to control size'
+ParticleSystem.vertex_group_size_negate -> invert_vertex_group_size:   boolean  'Negate the effect of the size vertex group'
+ParticleSystem.vertex_group_tangent -> vertex_group_tangent:   string  'Vertex group to control tangent'
+ParticleSystem.vertex_group_tangent_negate -> invert_vertex_group_tangent:   boolean  'Negate the effect of the tangent vertex group'
+ParticleSystem.vertex_group_velocity -> vertex_group_velocity:   string  'Vertex group to control velocity'
+ParticleSystem.vertex_group_velocity_negate -> invert_vertex_group_velocity:   boolean  'Negate the effect of the velocity vertex group'
+ParticleSystemModifier.particle_system -> particle_system:   pointer,  '(read-only)    Particle System that this modifier controls'
+ParticleTarget.duration -> duration:   float  'NO DESCRIPTION'
+ParticleTarget.mode -> mode:   enum  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+ParticleTarget.valid -> is_valid:   boolean  'Keyed particles target is valid'
+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  'NO DESCRIPTION'
+PivotConstraint.target -> target:   pointer  'Target Object, defining the position of the pivot when defined'
+PivotConstraint.use_relative_position -> use_relative_location:   boolean  'Offset will be an absolute point in space instead of relative to the target'
+PluginSequence.filename -> filename:   string,  '(read-only)'
+PointCache.active_point_cache_index -> active_point_cache_index:   int  'NO DESCRIPTION'
+PointCache.baked -> is_baked:   boolean,  '(read-only)'
+PointCache.baking -> is_baking:   boolean,  '(read-only)'
+PointCache.disk_cache -> use_disk_cache:   boolean  'Save cache files to disk (.blend file must be saved first)'
+PointCache.external -> use_external:   boolean  'Read cache from an external location'
+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.frames_skipped -> frames_skipped:   boolean,  '(read-only)'
+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.outdated -> is_outdated:   boolean,  '(read-only)'
+PointCache.point_cache_list -> point_cache_list:   collection,  '(read-only)    Point cache list'
+PointCache.quick_cache -> use_quick_cache:   boolean  'Update simulation with cache steps'
+PointCache.step -> step:   int  'Number of frames between cached frames'
+PointCache.use_library_path -> use_library_path:   boolean  'Use this files path when library linked into another file.'
+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_soft:   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 -> use_turbulence:   boolean  'Add directed noise to the density at render-time'
+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  'NO DESCRIPTION'
+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.only_shadow -> use_only_shadow:   boolean  'Causes light to cast shadows only without illuminating objects'
+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_layer -> use_shadow_layer:   boolean  'Causes only objects on the same layer to cast shadows'
+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_sample_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)'
+PointLamp.sphere -> use_sphere:   boolean  'Sets light intensity to zero beyond lamp distance'
+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.has_ik -> is_in_ik_chain:   boolean,  '(read-only)    Is part of an IK chain'
+PoseBone.head -> head:   float,  "(read-only)    Location of head of the channel's bone"
+NEGATE * PoseBone.ik_dof_x -> lock_ik_x:   boolean  'Allow movement around the X axis'
+NEGATE * PoseBone.ik_dof_y -> lock_ik_y:   boolean  'Allow movement around the Y axis'
+NEGATE * PoseBone.ik_dof_z -> lock_ik_z:   boolean  'Allow movement around the Z axis'
+PoseBone.ik_limit_x -> lock_ik_x:   boolean  'Limit movement around the X axis'
+PoseBone.ik_limit_y -> lock_ik_y:   boolean  'Limit movement around the Y axis'
+PoseBone.ik_limit_z -> lock_ik_z:   boolean  'Limit movement around the Z axis'
+PoseBone.ik_lin_control -> use_ik_lin_control:   boolean  'Apply channel size as IK constraint if stretching is enabled'
+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_control -> use_ik_rot_control:   boolean  'Apply channel rotation as IK constraint'
+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  'NO DESCRIPTION'
+PoseBone.lock_location -> lock_location:   boolean  'Lock editing of location in the interface'
+PoseBone.lock_rotation -> lock_rotation:   boolean  'Lock editing of rotation in the interface'
+PoseBone.lock_rotation_w -> lock_rotation_w:   boolean  "Lock editing of 'angle' component of four-component rotations in the interface"
+PoseBone.lock_rotations_4d -> lock_rotations_4d:   boolean  'Lock editing of four component rotations by components (instead of as Eulers)'
+PoseBone.lock_scale -> lock_scale:   boolean  'Lock editing of scale in the interface'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+PoseBone.rotation_quaternion -> rotation_quaternion:   float  'Rotation in Quaternions'
+PoseBone.scale -> scale:   float  'NO DESCRIPTION'
+PoseBone.select -> select:   boolean  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+PoseTemplateSettings.active_template_index -> active_template_index:   int  'NO DESCRIPTION'
+PoseTemplateSettings.generate_def_rig -> use_generate_deform_rig:   boolean  'Create a copy of the metarig, constrainted by the generated rig'
+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.is_never_none -> is_never_none:   boolean,  "(read-only)    True when this value can't be set to None"
+Property.is_readonly -> is_readonly:   boolean,  '(read-only)    Property is editable through RNA'
+Property.is_required -> is_required:   boolean,  '(read-only)    False when this property is an optional argument in an RNA function'
+Property.name -> name:   string,  '(read-only)    Human readable name'
+Property.registered -> is_registered:   boolean,  '(read-only)    Property is registered as part of type registration'
+Property.registered_optional -> is_registered_optional:   boolean,  '(read-only)    Property is optionally registered as part of type registration'
+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'
+Property.use_output -> is_output:   boolean,  '(read-only)    True when this property is an output value from an RNA function'
+PropertyActuator.mode -> mode:   enum  'NO DESCRIPTION'
+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 -> value_max:   string  'Specify maximum value in Interval type'
+PropertySensor.min_value -> value_min:   string  'Specify minimum value in Interval type'
+PropertySensor.property -> property:   string  'NO DESCRIPTION'
+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.script_error -> has_script_error:   boolean,  '(read-only)    The linked Python script has thrown an error'
+PythonConstraint.targets -> targets:   collection,  '(read-only)    Target Objects'
+PythonConstraint.text -> text:   pointer  'The text object that contains the Python script'
+PythonConstraint.use_targets -> use_targets:   boolean  'Use the targets indicated in the constraint panel'
+PythonController.debug -> use_debug:   boolean  'Continuously reload the module from disk for editing external modules without restarting'
+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.always_true -> use_always_true:   boolean  'Always false or always true'
+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'
+RaySensor.x_ray_mode -> use_x_ray:   boolean  "See through objects that don't have the 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.box_clip -> use_box_clip:   boolean  "Clip objects based on what's visible in other side views"
+RegionView3D.box_preview -> show_synced_view:   boolean  'Sync view position between side views'
+RegionView3D.lock_rotation -> lock_rotation:   boolean  'Lock view rotation in side views'
+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  'NO DESCRIPTION'
+RenderEngine.bl_label -> bl_label:   string  'NO DESCRIPTION'
+RenderEngine.bl_postprocess -> bl_use_postprocess:   boolean  'NO DESCRIPTION'
+RenderEngine.bl_preview -> bl_use_preview:   boolean  'NO DESCRIPTION'
+RenderLayer.all_z -> use_all_z:   boolean,  '(read-only)    Fill in Z values for solid faces in invisible layers, for masking'
+RenderLayer.edge -> use_edge_enhance:   boolean,  '(read-only)    Render Edge-enhance in this Layer (only works for Solid faces)'
+RenderLayer.enabled -> use:   boolean,  '(read-only)    Disable or enable the render layer'
+RenderLayer.halo -> use_halo:   boolean,  '(read-only)    Render Halos in this Layer (on top of Solid)'
+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.pass_ao -> use_pass_ambient_occlusion:   boolean,  '(read-only)    Deliver AO pass'
+RenderLayer.pass_ao_exclude -> exclude_ambient_occlusion:   boolean,  '(read-only)    Exclude AO pass from combined'
+RenderLayer.pass_color -> use_pass_color:   boolean,  '(read-only)    Deliver shade-less color pass'
+RenderLayer.pass_combined -> use_pass_combined:   boolean,  '(read-only)    Deliver full combined RGBA buffer'
+RenderLayer.pass_diffuse -> use_pass_diffuse:   boolean,  '(read-only)    Deliver diffuse pass'
+RenderLayer.pass_emit -> use_pass_emit:   boolean,  '(read-only)    Deliver emission pass'
+RenderLayer.pass_emit_exclude -> exclude_emit:   boolean,  '(read-only)    Exclude emission pass from combined'
+RenderLayer.pass_environment -> use_pass_environment:   boolean,  '(read-only)    Deliver environment lighting pass'
+RenderLayer.pass_environment_exclude -> exclude_environment:   boolean,  '(read-only)    Exclude environment pass from combined'
+RenderLayer.pass_indirect -> use_pass_indirect:   boolean,  '(read-only)    Deliver indirect lighting pass'
+RenderLayer.pass_indirect_exclude -> exclude_indirect:   boolean,  '(read-only)    Exclude indirect pass from combined'
+RenderLayer.pass_mist -> use_pass_mist:   boolean,  '(read-only)    Deliver mist factor pass (0.0-1.0)'
+RenderLayer.pass_normal -> use_pass_normal:   boolean,  '(read-only)    Deliver normal pass'
+RenderLayer.pass_object_index -> use_pass_object_index:   boolean,  '(read-only)    Deliver object index pass'
+RenderLayer.pass_reflection -> use_pass_reflection:   boolean,  '(read-only)    Deliver raytraced reflection pass'
+RenderLayer.pass_reflection_exclude -> exclude_reflection:   boolean,  '(read-only)    Exclude raytraced reflection pass from combined'
+RenderLayer.pass_refraction -> use_pass_refraction:   boolean,  '(read-only)    Deliver raytraced refraction pass'
+RenderLayer.pass_refraction_exclude -> exclude_refraction:   boolean,  '(read-only)    Exclude raytraced refraction pass from combined'
+RenderLayer.pass_shadow -> use_pass_shadow:   boolean,  '(read-only)    Deliver shadow pass'
+RenderLayer.pass_shadow_exclude -> exclude_shadow:   boolean,  '(read-only)    Exclude shadow pass from combined'
+RenderLayer.pass_specular -> use_pass_specular:   boolean,  '(read-only)    Deliver specular pass'
+RenderLayer.pass_specular_exclude -> exclude_specular:   boolean,  '(read-only)    Exclude specular pass from combined'
+RenderLayer.pass_uv -> use_pass_uv:   boolean,  '(read-only)    Deliver texture UV pass'
+RenderLayer.pass_vector -> use_pass_vector:   boolean,  '(read-only)    Deliver speed vector pass'
+RenderLayer.pass_z -> use_pass_z:   boolean,  '(read-only)    Deliver Z values pass'
+RenderLayer.passes -> passes:   collection,  '(read-only)'
+RenderLayer.rect -> rect:   float  'NO DESCRIPTION'
+RenderLayer.sky -> use_sky:   boolean,  '(read-only)    Render Sky in this Layer'
+RenderLayer.solid -> use_solid:   boolean,  '(read-only)    Render Solid faces in this Layer'
+RenderLayer.strand -> use_strand:   boolean,  '(read-only)    Render Strands in this Layer'
+RenderLayer.visible_layers -> layers:   boolean,  '(read-only)    Scene layers included in this render layer'
+RenderLayer.zmask -> use_zmask:   boolean,  "(read-only)    Only render what's in front of the solid z values"
+RenderLayer.zmask_layers -> layers_zmask:   boolean,  '(read-only)    Zmask scene layers'
+RenderLayer.zmask_negate -> invert_zmask:   boolean,  '(read-only)    For Zmask, only render what is behind solid z values instead of in front'
+RenderLayer.ztransp -> use_ztransp:   boolean,  '(read-only)    Render Z-Transparent faces in this Layer (On top of Solid and Halos)'
+RenderPass.channel_id -> channel_id:   string,  '(read-only)'
+RenderPass.channels -> channels:   int,  '(read-only)'
+RenderPass.name -> name:   string,  '(read-only)'
+RenderPass.rect -> rect:   float  'NO DESCRIPTION'
+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.backbuf -> use_backbuf:   boolean  'Render backbuffer image'
+RenderSettings.bake_aa_mode -> bake_aa_mode:   enum  'NO DESCRIPTION'
+RenderSettings.bake_active -> use_bake_active_to_selected:   boolean  'Bake shading on the surface of selected objects to the active object'
+RenderSettings.bake_bias -> bake_bias:   float  'Bias towards faces further away from the object (in blender units)'
+RenderSettings.bake_clear -> use_bake_clear:   boolean  'Clear Images before baking'
+RenderSettings.bake_distance -> bake_distance:   float  'Maximum distance from active object to other object (in blender units'
+RenderSettings.bake_enable_aa -> use_bake_antialiasing:   boolean  'Enables Anti-aliasing'
+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_normalized -> use_bake_normalized:   boolean  'With displacement normalize to the distance, with ambient occlusion normalize without using material settings'
+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_log -> use_cineon_log:   boolean  'Convert to logarithmic color space'
+RenderSettings.cineon_white -> cineon_white:   int  'Log conversion reference whitepoint'
+RenderSettings.color_management -> use_color_management:   boolean  'Use color profiles and gamma corrected imaging pipeline'
+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.crop_to_border -> use_crop_to_border:   boolean  'Crop the rendered frame to the defined border size'
+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 -> use_edge_enhance:   boolean  'use_Create a toon outline around the edges of geometry'
+RenderSettings.edge_color -> edge_color:   float  'NO DESCRIPTION'
+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.fields -> use_fields:   boolean  'Render image to two fields per frame, for interlaced TV output'
+RenderSettings.fields_still -> use_fields_still:   boolean  'Disable the time difference between fields'
+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.free_image_textures -> use_free_image_textures:   boolean  'Free all image texture from memory after render, to save memory before compositing'
+RenderSettings.free_unused_nodes -> use_free_unused_nodes:   boolean  'Free Nodes that are not used while compositing, to save memory'
+RenderSettings.full_sample -> use_full_sample:   boolean  'Save for every anti-aliasing sample the entire RenderLayer results. This solves anti-aliasing issues with compositing'
+RenderSettings.is_movie_format -> is_movie_format:   boolean,  '(read-only)    When true the format is a movie'
+RenderSettings.layers -> layers:   collection,  '(read-only)'
+RenderSettings.motion_blur -> use_motion_blur:   boolean  'Use multi-sampled 3D scene motion blur'
+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.multiple_engines -> has_multiple_engines:   boolean,  '(read-only)    More than one rendering engine is available'
+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.render_antialiasing -> use_antialiasing:   boolean  'Render and combine multiple samples per pixel to prevent jagged edges'
+RenderSettings.render_stamp -> use_stamp:   boolean  'Render the stamp info text in the rendered image'
+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.save_buffers -> use_save_buffers:   boolean  'Save tiles for all RenderLayers and SceneNodes to files in the temp directory (saves memory, required for Full Sample)'
+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.simplify_triangulate -> use_simplify_triangulate:   boolean  'Disables non-planer quads being triangulated'
+RenderSettings.single_layer -> use_single_layer:   boolean  'Only render the active layer'
+RenderSettings.stamp_background -> stamp_background:   float  'Color to use behind stamp text'
+RenderSettings.stamp_camera -> use_stamp_camera:   boolean  'Include the name of the active camera in image metadata'
+RenderSettings.stamp_date -> use_stamp_date:   boolean  'Include the current date in image metadata'
+RenderSettings.stamp_filename -> use_stamp_filename:   boolean  'Include the filename of the .blend file in image metadata'
+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_frame -> use_stamp_frame:   boolean  'Include the frame number in image metadata'
+RenderSettings.stamp_marker -> use_stamp_marker:   boolean  'Include the name of the last marker in image metadata'
+RenderSettings.stamp_note -> use_stamp_note:   boolean  'Include a custom note in image metadata'
+RenderSettings.stamp_note_text -> stamp_note_text:   string  'Custom text to appear in the stamp note'
+RenderSettings.stamp_render_time -> use_stamp_render_time:   boolean  'Include the render time in the stamp image'
+RenderSettings.stamp_scene -> use_stamp_scene:   boolean  'Include the name of the active scene in image metadata'
+RenderSettings.stamp_sequencer_strip -> use_stamp_sequencer_strip:   boolean  'Include the name of the foreground sequence strip in image metadata'
+RenderSettings.stamp_time -> use_stamp_time:   boolean  'Include the render frame as HH:MM:SS.FF in image metadata'
+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'
+RenderSettings.tiff_bit -> use_tiff_16bit:   boolean  'Save TIFF with 16 bits per channel'
+RenderSettings.use_border -> use_border:   boolean  'Render a user-defined border region, within the frame size. Note, this disables save_buffers and full_sample'
+RenderSettings.use_compositing -> use_compositing:   boolean  'Process the render result through the compositing pipeline, if compositing nodes are enabled'
+RenderSettings.use_envmaps -> use_envmaps:   boolean  'Calculate environment maps while rendering'
+RenderSettings.use_file_extension -> use_file_extension:   boolean  'Add the file format extensions to the rendered file name (eg: filename + .jpg)'
+RenderSettings.use_game_engine -> use_game_engine:   boolean,  '(read-only)    Current rendering engine is a game engine'
+RenderSettings.use_instances -> use_instances:   boolean  'Instance support leads to effective memory reduction when using duplicates'
+RenderSettings.use_local_coords -> use_local_coords:   boolean  'Vertex coordinates are stored localy on each primitive. Increases memory usage, but may have impact on speed'
+RenderSettings.use_overwrite -> use_overwrite:   boolean  'Overwrite existing files while rendering'
+RenderSettings.use_placeholder -> use_placeholder:   boolean  "Create empty placeholder files while rendering frames (similar to Unix 'touch')"
+RenderSettings.use_radiosity -> use_radiosity:   boolean  'Calculate radiosity in a pre-process before rendering'
+RenderSettings.use_raytracing -> use_raytrace:   boolean  'Pre-calculate the raytrace accelerator and render raytracing effects'
+RenderSettings.use_sequencer -> use_sequencer:   boolean  'Process the render (and composited) result through the video sequence editor pipeline, if sequencer strips exist'
+RenderSettings.use_sequencer_gl_preview -> use_sequencer_gl_preview:   boolean  'NO DESCRIPTION'
+RenderSettings.use_sequencer_gl_render -> use_sequencer_gl_render:   boolean  'NO DESCRIPTION'
+RenderSettings.use_shadows -> use_shadows:   boolean  'Calculate shadows while rendering'
+RenderSettings.use_simplify -> use_simplify:   boolean  'Enable simplification of scene for quicker preview renders'
+RenderSettings.use_sss -> use_sss:   boolean  'Calculate sub-surface scattering in materials rendering'
+RenderSettings.use_textures -> use_textures:   boolean  'Use textures to affect material properties'
+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'
+NEGATE * RigidBodyJointConstraint.disable_linked_collision -> use_linked_collision:   boolean  'Disable collision between linked bodies'
+RigidBodyJointConstraint.draw_pivot -> show_pivot:   boolean  'Display the pivot point and rotation in 3D view'
+RigidBodyJointConstraint.pivot_type -> pivot_type:   enum  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+Scene.frame_drop -> use_frame_drop:   boolean  'Play back dropping frames if frame display is too slow'
+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.layers -> layers:   boolean  'Layers visible when rendering the scene'
+Scene.mute_audio -> mute_audio:   boolean  'Play back of audio from Sequence Editor will be muted'
+Scene.network_render -> network_render:   pointer,  '(read-only)    Network Render Settings'
+Scene.nla_tweakmode_on -> use_nla_tweakmode:   boolean,  '(read-only)    Indicates whether there is any action referenced by NLA being edited. Strictly read-only'
+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.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.scrub_audio -> use_audio_scrub:   boolean  'Play audio from Sequence Editor while scrubbing'
+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_audio -> use_audio_sync:   boolean  'Play back and sync with audio clock, dropping frames if frame display is too slow'
+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.use_gravity -> use_gravity:   boolean  'Use global gravity for all dynamics'
+Scene.use_nodes -> use_nodes:   boolean  'Enable the compositing node tree'
+Scene.use_preview_range -> use_preview_range:   boolean  'Use an alternative start/end frame for UI playback, rather than the scene start/end frame'
+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  'NO DESCRIPTION'
+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 -> use_activity_culling:   boolean  'Activity culling is enabled'
+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.auto_start -> use_auto_start:   boolean  'Automatically start game at load time'
+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 -> frame_color:   float  'Set colour of the bars'
+SceneGameData.framing_type -> frame_type:   enum  'Select the type of Framing you want'
+SceneGameData.frequency -> frequency:   int  'Displays clock frequency of fullscreen display'
+SceneGameData.fullscreen -> show_fullscreen:   boolean  'Starts player in a new fullscreen display'
+SceneGameData.glsl_extra_textures -> use_glsl_extra_textures:   boolean  'Use extra textures like normal or specular maps for GLSL rendering'
+SceneGameData.glsl_lights -> use_glsl_lights:   boolean  'Use lights for GLSL rendering'
+SceneGameData.glsl_nodes -> use_glsl_nodes:   boolean  'Use nodes for GLSL rendering'
+SceneGameData.glsl_ramps -> use_glsl_ramps:   boolean  'Use ramps for GLSL rendering'
+SceneGameData.glsl_shaders -> use_glsl_shaders:   boolean  'Use shaders for GLSL rendering'
+SceneGameData.glsl_shadows -> use_glsl_shadows:   boolean  'Use shadows for GLSL rendering'
+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.show_debug_properties -> show_debug_properties:   boolean  'Show properties marked for debugging while the game runs'
+SceneGameData.show_framerate_profile -> show_framerate_profile:   boolean  'Show framerate and profiling information while the game runs'
+SceneGameData.show_physics_visualization -> show_physics_visualization:   boolean  'Show a visualization of physics bounds and interactions'
+SceneGameData.stereo -> stereo:   enum  'NO DESCRIPTION'
+SceneGameData.stereo_mode -> stereo_mode:   enum  'Stereographic techniques'
+SceneGameData.use_animation_record -> use_animation_record:   boolean  'Record animation to fcurves'
+SceneGameData.use_deprecation_warnings -> use_deprecation_warnings:   boolean  'Print warnings when using deprecated features in the python API'
+SceneGameData.use_display_lists -> use_display_lists:   boolean  'Use display lists to speed up rendering by keeping geometry on the GPU'
+SceneGameData.use_frame_rate -> use_frame_rate:   boolean  'Respect the frame rate rather than rendering as many frames as possible'
+SceneGameData.use_occlusion_culling -> use_occlusion_culling:   boolean  'Use optimized Bullet DBVT tree for view frustum and occlusion culling'
+SceneObjects.active -> active:   pointer  'Active object for this scene'
+SceneRenderLayer.all_z -> use_all_z:   boolean  'Fill in Z values for solid faces in invisible layers, for masking'
+SceneRenderLayer.edge -> use_edge_enhance:   boolean  'Render Edge-enhance in this Layer (only works for Solid faces)'
+SceneRenderLayer.enabled -> use:   boolean  'Disable or enable the render layer'
+SceneRenderLayer.halo -> use_halo:   boolean  'Render Halos in this Layer (on top of Solid)'
+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'
+SceneRenderLayer.pass_ao -> use_pass_ambient_occlusion:   boolean  'Deliver AO pass'
+SceneRenderLayer.pass_ao_exclude -> exclude_ambient_occlusion:   boolean  'Exclude AO pass from combined'
+SceneRenderLayer.pass_color -> use_pass_color:   boolean  'Deliver shade-less color pass'
+SceneRenderLayer.pass_combined -> use_pass_combined:   boolean  'Deliver full combined RGBA buffer'
+SceneRenderLayer.pass_diffuse -> use_pass_diffuse:   boolean  'Deliver diffuse pass'
+SceneRenderLayer.pass_emit -> use_pass_emit:   boolean  'Deliver emission pass'
+SceneRenderLayer.pass_emit_exclude -> exclude_emit:   boolean  'Exclude emission pass from combined'
+SceneRenderLayer.pass_environment -> use_pass_environment:   boolean  'Deliver environment lighting pass'
+SceneRenderLayer.pass_environment_exclude -> exclude_environment:   boolean  'Exclude environment pass from combined'
+SceneRenderLayer.pass_indirect -> use_pass_indirect:   boolean  'Deliver indirect lighting pass'
+SceneRenderLayer.pass_indirect_exclude -> exclude_indirect:   boolean  'Exclude indirect pass from combined'
+SceneRenderLayer.pass_mist -> use_pass_mist:   boolean  'Deliver mist factor pass (0.0-1.0)'
+SceneRenderLayer.pass_normal -> use_pass_normal:   boolean  'Deliver normal pass'
+SceneRenderLayer.pass_object_index -> use_pass_object_index:   boolean  'Deliver object index pass'
+SceneRenderLayer.pass_reflection -> use_pass_reflection:   boolean  'Deliver raytraced reflection pass'
+SceneRenderLayer.pass_reflection_exclude -> exclude_reflection:   boolean  'Exclude raytraced reflection pass from combined'
+SceneRenderLayer.pass_refraction -> use_pass_refraction:   boolean  'Deliver raytraced refraction pass'
+SceneRenderLayer.pass_refraction_exclude -> exclude_refraction:   boolean  'Exclude raytraced refraction pass from combined'
+SceneRenderLayer.pass_shadow -> use_pass_shadow:   boolean  'Deliver shadow pass'
+SceneRenderLayer.pass_shadow_exclude -> exclude_shadow:   boolean  'Exclude shadow pass from combined'
+SceneRenderLayer.pass_specular -> use_pass_specular:   boolean  'Deliver specular pass'
+SceneRenderLayer.pass_specular_exclude -> exclude_specular:   boolean  'Exclude specular pass from combined'
+SceneRenderLayer.pass_uv -> use_pass_uv:   boolean  'Deliver texture UV pass'
+SceneRenderLayer.pass_vector -> use_pass_vector:   boolean  'Deliver speed vector pass'
+SceneRenderLayer.pass_z -> use_pass_z:   boolean  'Deliver Z values pass'
+SceneRenderLayer.sky -> use_sky:   boolean  'Render Sky in this Layer'
+SceneRenderLayer.solid -> use_solid:   boolean  'Render Solid faces in this Layer'
+SceneRenderLayer.strand -> use_strand:   boolean  'Render Strands in this Layer'
+SceneRenderLayer.visible_layers -> layers:   boolean  'Scene layers included in this render layer'
+SceneRenderLayer.zmask -> use_zmask:   boolean  "Only render what's in front of the solid z values"
+SceneRenderLayer.zmask_layers -> layers_zmask:   boolean  'Zmask scene layers'
+SceneRenderLayer.zmask_negate -> invert_zmask:   boolean  'For Zmask, only render what is behind solid z values instead of in front'
+SceneRenderLayer.ztransp -> use_ztransp:   boolean  'Render Z-Transparent faces in this Layer (On top of Solid and Halos)'
+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.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
+SceneSequence.convert_float -> use_float:   boolean  'Convert input to float data'
+SceneSequence.crop -> crop:   pointer,  '(read-only)'
+SceneSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
+SceneSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
+SceneSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
+SceneSequence.multiply_colors -> multiply_colors:   float  'NO DESCRIPTION'
+SceneSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
+SceneSequence.proxy -> proxy:   pointer,  '(read-only)'
+SceneSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
+SceneSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
+SceneSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
+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)'
+SceneSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
+SceneSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
+SceneSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
+SceneSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
+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.use_full_resolution -> use_full_resolution:   boolean  'Sample every pixel of the image'
+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  'NO DESCRIPTION'
+Screen.animation_playing -> is_animation_playing:   boolean,  '(read-only)    Animation playback is active'
+Screen.areas -> areas:   collection,  '(read-only)    Areas the screen is subdivided into'
+Screen.fullscreen -> is_fullscreen:   boolean,  '(read-only)    An area is maximised, filling this screen'
+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'
+ScrewModifier.use_normal_calculate -> use_normal_calculate:   boolean  'Calculate the order of edges (needed for meshes, but not curves)'
+ScrewModifier.use_normal_flip -> use_normal_flip:   boolean  'Flip normals of lathed faces'
+ScrewModifier.use_object_screw_offset -> use_object_screw_offset:   boolean  'Use the distance between the objects to make a screw'
+Sculpt.lock_x -> lock_x:   boolean  'Disallow changes to the X axis of vertices'
+Sculpt.lock_y -> lock_y:   boolean  'Disallow changes to the Y axis of vertices'
+Sculpt.lock_z -> lock_z:   boolean  'Disallow changes to the Z axis of vertices'
+Sculpt.radial_symm -> radial_symm:   int  'Number of times to copy strokes across the surface'
+Sculpt.symmetry_x -> use_symmetry_x:   boolean  'Mirror brush across the X axis'
+Sculpt.symmetry_y -> use_symmetry_y:   boolean  'Mirror brush across the Y axis'
+Sculpt.symmetry_z -> use_symmetry_z:   boolean  'Mirror brush across the Z axis'
+Sculpt.use_openmp -> use_openmp:   boolean  'Take advantage of multiple CPU cores to improve sculpting performance'
+Sculpt.use_symmetry_feather -> use_symmetry_feather:   boolean  'Reduce the strength of the brush where it overlaps symmetrical daubs'
+Sensor.expanded -> show_expanded:   boolean  'Set sensor expanded in the user interface'
+Sensor.frequency -> frequency:   int  'Delay between repeated pulses(in logic tics, 0=no delay)'
+Sensor.invert -> invert:   boolean  'Invert the level(output) of this sensor'
+Sensor.level -> use_level:   boolean  'Level detector, trigger controllers of new states (only applicable upon logic state transition)'
+Sensor.name -> name:   string  'Sensor name'
+Sensor.pinned -> pinned:   boolean  'Display when not linked to a visible states controller'
+Sensor.pulse_false_level -> use_pulse_false_level:   boolean  'Activate FALSE level triggering (pulse mode)'
+Sensor.pulse_true_level -> use_pulse_true_level:   boolean  'Activate TRUE level triggering (pulse mode)'
+Sensor.tap -> use_tap:   boolean  'Trigger controllers only for an instant, even while the sensor remains true'
+Sensor.type -> type:   enum  'NO DESCRIPTION'
+Sequence.blend_mode -> blend_type:   enum  'NO DESCRIPTION'
+Sequence.blend_opacity -> blend_opacity:   float  'NO DESCRIPTION'
+Sequence.channel -> channel:   int  'Y position of the sequence strip'
+Sequence.effect_fader -> effect_fader:   float  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+Sequence.frame_still_end -> frame_still_end:   int,  '(read-only)'
+Sequence.frame_still_start -> frame_still_start:   int,  '(read-only)'
+Sequence.lock -> lock:   boolean  "Lock strip so that it can't be transformed"
+Sequence.mute -> mute:   boolean  'NO DESCRIPTION'
+Sequence.name -> name:   string  'NO DESCRIPTION'
+Sequence.select -> select:   boolean  'NO DESCRIPTION'
+Sequence.select_left_handle -> select_left_handle:   boolean  'NO DESCRIPTION'
+Sequence.select_right_handle -> select_right_handle:   boolean  'NO DESCRIPTION'
+Sequence.speed_fader -> speed_fader:   float  'NO DESCRIPTION'
+Sequence.type -> type:   enum,  '(read-only)'
+Sequence.use_effect_default_fade -> use_default_fade:   boolean  'Fade effect using the built-in default (usually make transition as long as effect strip)'
+SequenceColorBalance.gain -> gain:   float  'Color balance gain (highlights)'
+SequenceColorBalance.gamma -> gamma:   float  'Color balance gamma (midtones)'
+SequenceColorBalance.inverse_gain -> invert_gain:   boolean  'NO DESCRIPTION'
+SequenceColorBalance.inverse_gamma -> invert_gamma:   boolean  'NO DESCRIPTION'
+SequenceColorBalance.inverse_lift -> invert_lift:   boolean  'NO DESCRIPTION'
+SequenceColorBalance.lift -> lift:   float  'Color balance lift (shadows)'
+SequenceCrop.bottom -> bottom:   int  'NO DESCRIPTION'
+SequenceCrop.left -> left:   int  'NO DESCRIPTION'
+SequenceCrop.right -> right:   int  'NO DESCRIPTION'
+SequenceCrop.top -> top:   int  'NO DESCRIPTION'
+SequenceEditor.active_strip -> active_strip:   pointer  'NO DESCRIPTION'
+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.overlay_lock -> overlay_lock:   boolean  'NO DESCRIPTION'
+SequenceEditor.sequences -> sequences:   collection,  '(read-only)'
+SequenceEditor.sequences_all -> sequences_all:   collection,  '(read-only)'
+SequenceEditor.show_overlay -> show_overlay:   boolean  'Partial overlay ontop of the sequencer'
+SequenceElement.filename -> filename:   string  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+SequenceTransform.offset_y -> offset_y:   int  'NO DESCRIPTION'
+ShaderNode.type -> type:   enum,  '(read-only)'
+ShaderNodeExtendedMaterial.diffuse -> use_diffuse:   boolean  'Material Node outputs Diffuse'
+ShaderNodeExtendedMaterial.invert_normal -> invert_normal:   boolean  'Material Node uses inverted normal'
+ShaderNodeExtendedMaterial.material -> material:   pointer  'NO DESCRIPTION'
+ShaderNodeExtendedMaterial.specular -> use_specular:   boolean  'Material Node outputs Specular'
+ShaderNodeGeometry.color_layer -> color_layer:   string  'NO DESCRIPTION'
+ShaderNodeGeometry.uv_layer -> uv_layer:   string  'NO DESCRIPTION'
+ShaderNodeMapping.clamp_maximum -> use_max:   boolean  'Clamp the output coordinate to a maximum value'
+ShaderNodeMapping.clamp_minimum -> use_min:   boolean  'Clamp the output coordinate to a minimum value'
+ShaderNodeMapping.location -> location:   float  'Location offset for the input coordinate'
+ShaderNodeMapping.maximum -> max:   float  'Maximum value to clamp coordinate to'
+ShaderNodeMapping.minimum -> min:   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.diffuse -> use_diffuse:   boolean  'Material Node outputs Diffuse'
+ShaderNodeMaterial.invert_normal -> invert_normal:   boolean  'Material Node uses inverted normal'
+ShaderNodeMaterial.material -> material:   pointer  'NO DESCRIPTION'
+ShaderNodeMaterial.specular -> use_specular:   boolean  'Material Node outputs Specular'
+ShaderNodeMath.operation -> operation:   enum  'NO DESCRIPTION'
+ShaderNodeMixRGB.alpha -> use_alpha:   boolean  'Include alpha of second input in this operation'
+ShaderNodeMixRGB.blend_type -> blend_type:   enum  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+ShaderNodeValToRGB.color_ramp -> color_ramp:   pointer,  '(read-only)'
+ShaderNodeVectorCurve.mapping -> mapping:   pointer,  '(read-only)'
+ShaderNodeVectorMath.operation -> operation:   enum  'NO DESCRIPTION'
+ShapeActionActuator.action -> action:   pointer  'NO DESCRIPTION'
+ShapeActionActuator.blendin -> blendin:   int  'Number of frames of motion blending'
+ShapeActionActuator.continue_last_frame -> use_continue_last_frame:   boolean  'Restore last frame when switching on/off, otherwise play from the start each time'
+ShapeActionActuator.frame_end -> frame_end:   int  'NO DESCRIPTION'
+ShapeActionActuator.frame_property -> frame_property:   string  "Assign the action's current frame number to this property"
+ShapeActionActuator.frame_start -> frame_start:   int  'NO DESCRIPTION'
+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.mute -> mute:   boolean  'Mute this shape key'
+ShapeKey.name -> name:   string  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+ShapeKeyBezierPoint.handle_1_co -> handle_1_co:   float  'NO DESCRIPTION'
+ShapeKeyBezierPoint.handle_2_co -> handle_2_co:   float  'NO DESCRIPTION'
+ShapeKeyCurvePoint.co -> co:   float  'NO DESCRIPTION'
+ShapeKeyCurvePoint.tilt -> tilt:   float  'NO DESCRIPTION'
+ShapeKeyPoint.co -> co:   float  'NO DESCRIPTION'
+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'
+ShrinkwrapConstraint.use_x -> use_x:   boolean  'Projection over X Axis'
+ShrinkwrapConstraint.use_y -> use_y:   boolean  'Projection over Y Axis'
+ShrinkwrapConstraint.use_z -> use_z:   boolean  'Projection over Z Axis'
+ShrinkwrapModifier.auxiliary_target -> auxiliary_target:   pointer  'Additional mesh target to shrink to'
+ShrinkwrapModifier.cull_back_faces -> use_cull_back_faces:   boolean  'Stop vertices from projecting to a back face on the target'
+ShrinkwrapModifier.cull_front_faces -> use_cull_front_faces:   boolean  'Stop vertices from projecting to a front face on the target'
+ShrinkwrapModifier.keep_above_surface -> use_keep_above_surface:   boolean  'NO DESCRIPTION'
+ShrinkwrapModifier.mode -> mode:   enum  'NO DESCRIPTION'
+ShrinkwrapModifier.negative -> use_negative_direction:   boolean  'Allow vertices to move in the negative direction of axis'
+ShrinkwrapModifier.offset -> offset:   float  'Distance to keep from the target'
+ShrinkwrapModifier.positive -> use_positive_direction:   boolean  'Allow vertices to move in the positive direction of axis'
+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'
+ShrinkwrapModifier.x -> use_project_x:   boolean  'NO DESCRIPTION'
+ShrinkwrapModifier.y -> use_project_y:   boolean  'NO DESCRIPTION'
+ShrinkwrapModifier.z -> use_project_z:   boolean  'NO DESCRIPTION'
+SimpleDeformModifier.factor -> factor:   float  'NO DESCRIPTION'
+SimpleDeformModifier.limits -> limits:   float  'Lower/Upper limits for deform'
+SimpleDeformModifier.lock_x_axis -> lock_x:   boolean  'NO DESCRIPTION'
+SimpleDeformModifier.lock_y_axis -> lock_y:   boolean  'NO DESCRIPTION'
+SimpleDeformModifier.mode -> mode:   enum  'NO DESCRIPTION'
+SimpleDeformModifier.origin -> origin:   pointer  'Origin of modifier space coordinates'
+SimpleDeformModifier.relative -> use_relative:   boolean  'Sets the origin of deform space to be relative to the object'
+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_smoke -> use_dissolve_smoke:   boolean  'Enable smoke to disappear over time'
+SmokeDomainSettings.dissolve_smoke_log -> use_dissolve_smoke_log:   boolean  'Using 1/x'
+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.highres -> use_high_resolution:   boolean  'Enable high resolution (using amplification)'
+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.smoke_domain_colli -> smoke_domain_colli:   enum  'Selects which domain border will be treated as collision object.'
+SmokeDomainSettings.smoothemitter -> smoothemitter:   boolean  'Smoothens emitted smoke to avoid blockiness.'
+SmokeDomainSettings.strength -> strength:   float  'Strength of wavelet noise'
+SmokeDomainSettings.time_scale -> time_scale:   float  'Adjust simulation speed.'
+SmokeDomainSettings.viewhighres -> show_high_resolution:   boolean  'Show high resolution (using amplification)'
+SmokeDomainSettings.vorticity -> vorticity:   float  'Amount of turbulence/rotation in fluid.'
+SmokeFlowSettings.absolute -> absolute:   boolean  'Only allows given density value in emitter area.'
+SmokeFlowSettings.density -> density:   float  'NO DESCRIPTION'
+SmokeFlowSettings.initial_velocity -> initial_velocity:   boolean  "Smoke inherits it's velocity from the emitter particle"
+NEGATE * SmokeFlowSettings.outflow -> use_outflow:   boolean  'Deletes smoke from simulation'
+SmokeFlowSettings.psys -> psys:   pointer  'Particle systems emitted from the object'
+SmokeFlowSettings.temperature -> temperature:   float  'Temperature difference to ambient temperature'
+SmokeFlowSettings.velocity_multiplier -> velocity_multiplier:   float  'Multiplier to adjust velocity passed to smoke'
+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  'NO DESCRIPTION'
+SmoothModifier.factor -> factor:   float  'NO DESCRIPTION'
+SmoothModifier.repeat -> repeat:   int  'NO DESCRIPTION'
+SmoothModifier.vertex_group -> vertex_group:   string  'Vertex group name'
+SmoothModifier.x -> use_x:   boolean  'NO DESCRIPTION'
+SmoothModifier.y -> use_y:   boolean  'NO DESCRIPTION'
+SmoothModifier.z -> use_z:   boolean  'NO DESCRIPTION'
+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.auto_step -> use_auto_step:   boolean  'Use velocities for automagic step sizes'
+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 -> bend:   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.diagnose -> use_diagnose:   boolean  'Turn on SB diagnose console prints'
+SoftBodySettings.edge_collision -> use_edge_collision:   boolean  'Edges collide too'
+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.estimate_matrix -> use_estimate_matrix:   boolean  'estimate matrix .. split to COM , ROT ,SCALE'
+SoftBodySettings.face_collision -> use_face_collision:   boolean  'Faces collide too, SLOOOOOW warning'
+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 -> step_max:   int  'Maximal # solver steps/frame'
+SoftBodySettings.minstep -> step_min:   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.self_collision -> use_self_collision:   boolean  'Enable naive vertex ball self collision'
+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'
+SoftBodySettings.stiff_quads -> use_stiff_quads:   boolean  'Adds diagonal springs on 4-gons'
+SoftBodySettings.use_edges -> use_edges:   boolean  'Use Edges as springs'
+SoftBodySettings.use_goal -> use_goal:   boolean  'Define forces for vertices to stick to animated position'
+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.invert -> invert_vertex_group:   boolean  'Invert the vertex group influence'
+SolidifyModifier.offset -> offset:   float  'NO DESCRIPTION'
+SolidifyModifier.thickness -> thickness:   float  'Thickness of the shell'
+SolidifyModifier.use_even_offset -> use_even_offset:   boolean  'Maintain thickness by adjusting for sharp corners (slow, disable when not needed)'
+SolidifyModifier.use_quality_normals -> use_quality_normals:   boolean  'Calculate normals which result in more even thickness (slow, disable when not needed)'
+SolidifyModifier.use_rim -> use_rim:   boolean  'Create edge loops between the inner and outer surfaces on face edges (slow, disable when not needed)'
+SolidifyModifier.use_rim_material -> use_rim_material:   boolean  'Use in the next material for rim faces'
+SolidifyModifier.vertex_group -> vertex_group:   string  'Vertex group name'
+Sound.caching -> use_ram_cache:   boolean  'The sound file is decoded and loaded into RAM'
+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.enable_sound_3d -> use_3d_sound:   boolean  'Enable/Disable 3D Sound'
+SoundActuator.max_distance_3d -> distance_3d_max:   float  'The maximum distance at which you can hear the sound'
+SoundActuator.maximum_gain_3d -> gain_3d_max:   float  'The maximum gain of the sound, no matter how near it is'
+SoundActuator.minimum_gain_3d -> gain_3d_min:   float  'The minimum gain of the sound, no matter how far it is away'
+SoundActuator.mode -> mode:   enum  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+SpaceConsole.selection_start -> selection_start:   int  'NO DESCRIPTION'
+SpaceConsole.show_report_debug -> show_report_debug:   boolean  'Display debug reporting info'
+SpaceConsole.show_report_error -> show_report_error:   boolean  'Display error text'
+SpaceConsole.show_report_info -> show_report_info:   boolean  'Display general information'
+SpaceConsole.show_report_operator -> show_report_operator:   boolean  'Display the operator log'
+SpaceConsole.show_report_warn -> show_report_warning:   boolean  'Display warnings'
+SpaceDopeSheetEditor.action -> action:   pointer  'Action displayed and edited in this space'
+SpaceDopeSheetEditor.automerge_keyframes -> use_automerge_keyframes:   boolean  'Automatically merge nearby keyframes'
+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'
+SpaceDopeSheetEditor.realtime_updates -> use_realtime_updates:   boolean  'When transforming keyframes, changes to the animation data are flushed to other views'
+SpaceDopeSheetEditor.show_cframe_indicator -> show_frame_indicator:   boolean  'Show frame number beside the current frame indicator line'
+SpaceDopeSheetEditor.show_seconds -> show_seconds:   boolean,  '(read-only)    Show timing in seconds not frames'
+SpaceDopeSheetEditor.show_sliders -> show_sliders:   boolean  'Show sliders beside F-Curve channels'
+SpaceDopeSheetEditor.use_marker_sync -> use_marker_sync:   boolean  'Sync Markers with keyframe edits'
+SpaceFileBrowser.params -> params:   pointer,  '(read-only)    Parameters and Settings for the Filebrowser'
+SpaceGraphEditor.automerge_keyframes -> use_automerge_keyframes:   boolean  'Automatically merge nearby keyframes'
+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.has_ghost_curves -> has_ghost_curves:   boolean  'Graph Editor instance has some ghost curves stored'
+SpaceGraphEditor.mode -> mode:   enum  'Editing context being displayed'
+SpaceGraphEditor.only_selected_curves_handles -> use_only_selected_curves_handles:   boolean  'Only keyframes of selected F-Curves are visible and editable'
+SpaceGraphEditor.only_selected_keyframe_handles -> use_only_selected_keyframe_handles:   boolean  'Only show and edit handles of selected keyframes'
+SpaceGraphEditor.pivot_point -> pivot_point:   enum  'Pivot center for rotation/scaling'
+SpaceGraphEditor.realtime_updates -> use_realtime_updates:   boolean  'When transforming keyframes, changes to the animation data are flushed to other views'
+SpaceGraphEditor.show_cframe_indicator -> show_frame_indicator:   boolean  'Show frame number beside the current frame indicator line'
+SpaceGraphEditor.show_cursor -> show_cursor:   boolean  'Show 2D cursor'
+SpaceGraphEditor.show_handles -> show_handles:   boolean  'Show handles of Bezier control points'
+SpaceGraphEditor.show_seconds -> show_seconds:   boolean,  '(read-only)    Show timing in seconds not frames'
+SpaceGraphEditor.show_sliders -> show_sliders:   boolean  'Show sliders beside F-Curve channels'
+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.draw_repeated -> show_repeated:   boolean  'Draw the image repeated outside of the main view'
+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_painting -> use_image_paint:   boolean  'Enable image painting mode'
+SpaceImageEditor.image_pin -> use_image_pin:   boolean  'Display current image regardless of object selection'
+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.show_paint -> show_paint:   boolean,  '(read-only)    Show paint related properties'
+SpaceImageEditor.show_render -> show_render:   boolean,  '(read-only)    Show render related properties'
+SpaceImageEditor.show_uvedit -> show_uvedit:   boolean,  '(read-only)    Show UV editing related properties'
+SpaceImageEditor.update_automatically -> use_realtime_updates:   boolean  'Update other affected window spaces automatically to reflect changes during interactive operations such as transform'
+SpaceImageEditor.use_grease_pencil -> use_grease_pencil:   boolean  'Display and edit the grease pencil freehand annotations overlay'
+SpaceImageEditor.uv_editor -> uv_editor:   pointer,  '(read-only)    UV editor settings'
+SpaceLogicEditor.actuators_show_active_objects -> show_actuators_active_objects:   boolean  'Show actuators of active object'
+SpaceLogicEditor.actuators_show_active_states -> show_actuators_active_states:   boolean  'Show only actuators connected to active states'
+SpaceLogicEditor.actuators_show_linked_controller -> show_actuators_linked_controller:   boolean  'Show linked objects to the actuator'
+SpaceLogicEditor.actuators_show_selected_objects -> show_actuators_selected_objects:   boolean  'Show actuators of all selected objects'
+SpaceLogicEditor.controllers_show_active_objects -> show_controllers_active_objects:   boolean  'Show controllers of active object'
+SpaceLogicEditor.controllers_show_linked_controller -> show_controllers_linked_controller:   boolean  'Show linked objects to sensor/actuator'
+SpaceLogicEditor.controllers_show_selected_objects -> show_controllers_selected_objects:   boolean  'Show controllers of all selected objects'
+SpaceLogicEditor.sensors_show_active_objects -> show_sensors_active_objects:   boolean  'Show sensors of active object'
+SpaceLogicEditor.sensors_show_active_states -> show_sensors_active_states:   boolean  'Show only sensors connected to active states'
+SpaceLogicEditor.sensors_show_linked_controller -> show_sensors_linked_controller:   boolean  'Show linked objects to the controller'
+SpaceLogicEditor.sensors_show_selected_objects -> show_sensors_selected_objects:   boolean  'Show sensors of all selected objects'
+SpaceNLA.autosnap -> autosnap:   enum  'Automatic time snapping settings for transformations'
+SpaceNLA.dopesheet -> dopesheet:   pointer,  '(read-only)    Settings for filtering animation data'
+SpaceNLA.realtime_updates -> use_realtime_updates:   boolean  'When transforming strips, changes to the animation data are flushed to other views'
+SpaceNLA.show_cframe_indicator -> show_frame_indicator:   boolean  'Show frame number beside the current frame indicator line'
+SpaceNLA.show_seconds -> show_seconds:   boolean,  '(read-only)    Show timing in seconds not frames'
+SpaceNLA.show_strip_curves -> show_strip_curves:   boolean  'Show influence curves on strips'
+SpaceNodeEditor.backdrop -> show_backdrop:   boolean  'Use active Viewer Node output as backdrop for compositing nodes'
+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'
+SpaceOutliner.match_case_sensitive -> use_match_case_sensitive:   boolean  'Only use case sensitive matches of search string'
+SpaceOutliner.match_complete -> use_match_complete:   boolean  'Only use complete matches of search string'
+SpaceOutliner.show_restriction_columns -> show_restriction_columns:   boolean  'Show column'
+SpaceProperties.align -> align:   enum  'Arrangement of the panels'
+SpaceProperties.brush_texture -> show_brush_texture:   boolean  'Show brush textures'
+SpaceProperties.context -> context:   enum  'Type of active data to display and edit'
+SpaceProperties.pin_id -> pin_id:   pointer  'NO DESCRIPTION'
+SpaceProperties.use_pin_id -> use_pin_id:   boolean  'Use the pinned context'
+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_frames -> show_frames:   boolean  'Draw frames rather than seconds'
+SpaceSequenceEditor.draw_overexposed -> draw_overexposed:   int  'Show overexposed areas with zebra stripes'
+SpaceSequenceEditor.draw_safe_margin -> show_safe_margin:   boolean  'Draw title safe margins in preview'
+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.separate_color_preview -> show_separate_color:   boolean  'Separate color channels in preview'
+SpaceSequenceEditor.show_cframe_indicator -> show_frame_indicator:   boolean  'Show frame number beside the current frame indicator line'
+SpaceSequenceEditor.use_grease_pencil -> use_grease_pencil:   boolean  'Display and edit the grease pencil freehand annotations overlay'
+SpaceSequenceEditor.use_marker_sync -> use_marker_sync:   boolean  'Transform markers as well as strips'
+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_all -> use_find_all:   boolean  'Search in all text datablocks, instead of only the active one'
+SpaceTextEditor.find_text -> find_text:   string  'Text to search for with the find tool'
+SpaceTextEditor.find_wrap -> use_find_wrap:   boolean  'Search again from the start of the file when reaching the end'
+SpaceTextEditor.font_size -> font_size:   int  'Font size to use for displaying the text'
+SpaceTextEditor.line_numbers -> show_line_numbers:   boolean  'Show line numbers next to the text'
+SpaceTextEditor.live_edit -> use_live_edit:   boolean  'Run python while editing'
+SpaceTextEditor.overwrite -> use_overwrite:   boolean  'Overwrite characters when typing rather than inserting them'
+SpaceTextEditor.replace_text -> replace_text:   string  'Text to replace selected text with using the replace tool'
+SpaceTextEditor.syntax_highlight -> show_syntax_highlight:   boolean  'Syntax highlight for scripting'
+SpaceTextEditor.tab_width -> tab_width:   int  'Number of spaces to display tabs with'
+SpaceTextEditor.text -> text:   pointer  'Text displayed and edited in this space'
+SpaceTextEditor.word_wrap -> use_word_wrap:   boolean  'Wrap words if there is not enough horizontal space'
+SpaceTimeline.cache_cloth -> cache_cloth:   boolean  "Show the active object's cloth point cache"
+SpaceTimeline.cache_particles -> cache_particles:   boolean  "Show the active object's particle point cache"
+SpaceTimeline.cache_smoke -> cache_smoke:   boolean  "Show the active object's smoke cache"
+SpaceTimeline.cache_softbody -> cache_softbody:   boolean  "Show the active object's softbody point cache"
+SpaceTimeline.only_selected -> show_only_selected:   boolean  'Show keyframes for active Object and/or its selected channels only'
+SpaceTimeline.play_all_3d -> use_play_3d_editors:   boolean  'NO DESCRIPTION'
+SpaceTimeline.play_anim -> use_play_animation_editors:   boolean  'NO DESCRIPTION'
+SpaceTimeline.play_buttons -> use_play_properties_editors:   boolean  'NO DESCRIPTION'
+SpaceTimeline.play_image -> use_play_image_editors:   boolean  'NO DESCRIPTION'
+SpaceTimeline.play_nodes -> use_play_node_editors:   boolean  'NO DESCRIPTION'
+SpaceTimeline.play_sequencer -> use_play_sequence_editors:   boolean  'NO DESCRIPTION'
+SpaceTimeline.play_top_left -> use_play_top_left_3d_editor:   boolean  'NO DESCRIPTION'
+SpaceTimeline.show_cache -> show_cache:   boolean  'Show the status of cached frames in the timeline'
+SpaceTimeline.show_cframe_indicator -> show_frame_indicator:   boolean  'Show frame number beside the current frame indicator line'
+SpaceUVEditor.constrain_to_image_bounds -> use_constrain_to_image_bounds:   boolean  'Constraint to stay within the image bounds while editing'
+SpaceUVEditor.cursor_location -> cursor_location:   float  '2D cursor location for this view'
+SpaceUVEditor.draw_modified_edges -> show_modified_edges:   boolean  'Draw edges after modifiers are applied'
+SpaceUVEditor.draw_other_objects -> show_other_objects:   boolean  'Draw other selected objects that share the same image'
+SpaceUVEditor.draw_smooth_edges -> show_smooth_edges:   boolean  'Draw UV edges anti-aliased'
+SpaceUVEditor.draw_stretch -> show_stretch:   boolean  'Draw faces colored according to the difference in shape between UVs and their 3D coordinates (blue for low distortion, red for high distortion)'
+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.live_unwrap -> use_live_unwrap:   boolean  'Continuously unwrap the selected UV island while transforming pinned vertices'
+SpaceUVEditor.normalized_coordinates -> show_normalized_coordinates:   boolean  'Display UV coordinates from 0.0 to 1.0 rather than in pixels'
+SpaceUVEditor.pivot -> pivot:   enum  'Rotation/Scaling Pivot'
+SpaceUVEditor.snap_to_pixels -> use_snap_to_pixels:   boolean  'Snap UVs to pixel locations while editing'
+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.all_object_origins -> show_all_objects_origin:   boolean  'Show the object origin center dot for all (selected and unselected) objects'
+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.display_background_images -> show_background_images:   boolean  'Display reference images behind objects in the 3D View'
+SpaceView3D.display_floor -> show_floor:   boolean  'Show the ground plane grid in perspective view'
+SpaceView3D.display_render_override -> show_only_render:   boolean  'Display only objects which will be rendered'
+SpaceView3D.display_x_axis -> show_axis_x:   boolean  'Show the X axis line in perspective view'
+SpaceView3D.display_y_axis -> show_axis_y:   boolean  'Show the Y axis line in perspective view'
+SpaceView3D.display_z_axis -> show_axis_z:   boolean  'Show the Z axis line in perspective view'
+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.layers -> layers:   boolean  'Layers visible in this 3D View'
+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_camera_and_layers -> lock_camera_and_layers:   boolean  "Use the scene's active camera and layers in this view, rather than local layers"
+SpaceView3D.lock_object -> lock_object:   pointer  "3D View center is locked to this object's position"
+SpaceView3D.manipulator -> use_manipulator:   boolean  'Use a 3D manipulator widget for controlling transforms'
+SpaceView3D.manipulator_rotate -> use_manipulator_rotate:   boolean  'Use the manipulator for rotation transformations'
+SpaceView3D.manipulator_scale -> use_manipulator_scale:   boolean  'Use the manipulator for scale transformations'
+SpaceView3D.manipulator_translate -> use_manipulator_translate:   boolean  'Use the manipulator for movement transformations'
+SpaceView3D.occlude_geometry -> use_occlude_geometry:   boolean  'Limit selection to visible (clipped with depth buffer)'
+SpaceView3D.outline_selected -> show_outline_selected:   boolean  'Show an outline highlight around selected objects in non-wireframe views'
+SpaceView3D.pivot_point -> pivot_point:   enum  'Pivot center for rotation/scaling'
+SpaceView3D.pivot_point_align -> use_pivot_point_align:   boolean  'Manipulate object centers only'
+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.relationship_lines -> show_relationship_lines:   boolean  'Show dashed lines indicating parent or constraint relationships'
+SpaceView3D.textured_solid -> show_textured_solid:   boolean  'Display face-assigned textures in solid view'
+SpaceView3D.transform_orientation -> transform_orientation:   enum  'Transformation orientation'
+SpaceView3D.used_layers -> layers_used:   boolean,  '(read-only)    Layers that contain something'
+SpaceView3D.viewport_shading -> viewport_shade:   enum  'Method to display/shade objects in the 3D View'
+SpeedControlSequence.curve_compress_y -> use_curve_compress_y:   boolean  'Scale F-Curve value to get the target frame number, F-Curve value runs from 0.0 to 1.0'
+SpeedControlSequence.curve_velocity -> use_curve_velocity:   boolean  'Interpret the F-Curve value as a velocity instead of a frame number'
+SpeedControlSequence.frame_blending -> use_frame_blend:   boolean  'Blend two frames into the target for a smoother result'
+SpeedControlSequence.global_speed -> global_speed:   float  'NO DESCRIPTION'
+Spline.bezier_points -> bezier_points:   collection,  '(read-only)    Collection of points for bezier curves only'
+Spline.bezier_u -> use_bezier_u:   boolean  'Make this nurbs curve or surface act like a bezier spline in the U direction (Order U must be 3 or 4, Cyclic U must be disabled)'
+Spline.bezier_v -> use_bezier_v:   boolean  'Make this nurbs surface act like a bezier spline in the V direction (Order V must be 3 or 4, Cyclic V must be disabled)'
+Spline.character_index -> character_index:   int,  '(read-only)    Location of this character in the text data (only for text curves)'
+Spline.cyclic_u -> use_cyclic_u:   boolean  'Make this curve or surface a closed loop in the U direction'
+Spline.cyclic_v -> use_cyclic_v:   boolean  'Make this surface a closed loop in the V direction'
+Spline.endpoint_u -> use_endpoint_u:   boolean  'Make this nurbs curve or surface meet the endpoints in the U direction (Cyclic U must be disabled)'
+Spline.endpoint_v -> use_endpoint_v:   boolean  'Make this nurbs surface meet the endpoints in the V direction (Cyclic V must be disabled)'
+Spline.hide -> hide:   boolean  'Hide this curve in editmode'
+Spline.material_index -> material_index:   int  'NO DESCRIPTION'
+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.smooth -> use_smooth:   boolean  'Smooth the normals of the surface or beveled curve'
+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.chain_offset -> use_chain_offset:   boolean  'Offset the entire chain relative to the root joint'
+SplineIKConstraint.even_divisions -> use_even_divisions:   boolean  'Ignore the relative lengths of the bones when fitting to the curve'
+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.use_curve_radius -> use_curve_radius:   boolean  'Average radius of the endpoints is used to tweak the X and Z Scaling of the bones, on top of XZ Scale mode'
+SplineIKConstraint.xz_scaling_mode -> xz_scale_mode:   enum  'Method used for determining the scaling of the X and Z axes of the bones'
+SplineIKConstraint.y_stretch -> use_y_stretch:   boolean  'Stretch the Y axis of the bones to fit the curve'
+SplinePoint.co -> co:   float  'Point coordinates'
+SplinePoint.hide -> hide:   boolean  'Visibility status'
+SplinePoint.radius -> radius:   float,  '(read-only)    Radius for bevelling'
+SplinePoint.select -> select:   boolean  'Selection status'
+SplinePoint.tilt -> tilt:   float  'Tilt in 3D View'
+SplinePoint.weight -> weight:   float  'Nurbs weight'
+SplinePoint.weight_softbody -> weight_softbody:   float  'Softbody goal weight'
+SpotLamp.auto_clip_end -> use_auto_clip_end:   boolean  'Automatic calculation of clipping-end, based on visible vertices'
+SpotLamp.auto_clip_start -> use_auto_clip_start:   boolean  'Automatic calculation of clipping-start, based on visible vertices'
+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 -> use_halo:   boolean  'Renders spotlight with a volumetric halo (Buffer Shadows)'
+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.only_shadow -> use_only_shadow:   boolean  'Causes light to cast shadows only without illuminating objects'
+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_layer -> use_shadow_layer:   boolean  'Causes only objects on the same layer to cast 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_sample_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.show_cone -> show_cone:   boolean  'Draw transparent cone in 3D view to visualize which objects are contained in it'
+SpotLamp.sphere -> use_sphere:   boolean  'Sets light intensity to zero beyond lamp distance'
+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'
+SpotLamp.square -> use_square:   boolean  'Casts a square spot light shape'
+StateActuator.operation -> operation:   enum  'Select the bit operation on object state mask'
+StateActuator.state -> states:   boolean  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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 -> length_max:   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  'NO DESCRIPTION'
+StucciTexture.stype -> stype:   enum  'NO DESCRIPTION'
+StucciTexture.turbulence -> turbulence:   float  'Sets the turbulence of the bandnoise and ringnoise types'
+SubsurfModifier.levels -> levels:   int  'Number of subdivisions to perform'
+SubsurfModifier.optimal_display -> show_only_control_edges:   boolean  'Skip drawing/rendering of interior subdivided edges'
+SubsurfModifier.render_levels -> render_levels:   int  'Number of subdivisions to perform when rendering'
+SubsurfModifier.subdivision_type -> subdivision_type:   enum  'Selects type of subdivision algorithm'
+SubsurfModifier.subsurf_uv -> use_subsurf_uv:   boolean  'Use subsurf to subdivide UVs'
+SunLamp.only_shadow -> use_only_shadow:   boolean  'Causes light to cast shadows only without illuminating objects'
+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_layer -> use_shadow_layer:   boolean  'Causes only objects on the same layer to cast shadows'
+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'
+SurfaceCurve.map_along_length -> use_map_along_length:   boolean  'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'
+TexMapping.has_maximum -> use_max:   boolean  'Whether to use maximum clipping value'
+TexMapping.has_minimum -> use_min:   boolean  'Whether to use minimum clipping value'
+TexMapping.location -> location:   float  'NO DESCRIPTION'
+TexMapping.maximum -> max:   float  'Maximum value for clipping'
+TexMapping.minimum -> min:   float  'Minimum value for clipping'
+TexMapping.rotation -> rotation:   float  'NO DESCRIPTION'
+TexMapping.scale -> scale:   float  'NO DESCRIPTION'
+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.dirty -> is_dirty:   boolean,  '(read-only)    Text file has been edited since last save'
+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.memory -> is_in_memory:   boolean,  '(read-only)    Text file is in memory, without a corresponding file on disk'
+Text.modified -> is_modified:   boolean,  '(read-only)    Text file on disk is different than the one in memory'
+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'
+Text.tabs_as_spaces -> use_tabs_as_spaces:   boolean  'Automatically converts all new tabs into spaces'
+Text.use_module -> use_module:   boolean  "Register this text as a module on loading, Text name must end with '.py'"
+TextBox.height -> height:   float  'NO DESCRIPTION'
+TextBox.width -> width:   float  'NO DESCRIPTION'
+TextBox.x -> x:   float  'NO DESCRIPTION'
+TextBox.y -> y:   float  'NO DESCRIPTION'
+TextCharacterFormat.bold -> use_bold:   boolean  'NO DESCRIPTION'
+TextCharacterFormat.italic -> use_italic:   boolean  'NO DESCRIPTION'
+TextCharacterFormat.underline -> use_underline:   boolean  'NO DESCRIPTION'
+TextCharacterFormat.use_small_caps -> use_small_caps:   boolean  'NO DESCRIPTION'
+TextCurve.active_textbox -> active_textbox:   int  'NO DESCRIPTION'
+TextCurve.body -> body:   string  'contents of this text object'
+TextCurve.body_format -> body_format:   collection,  '(read-only)    Stores the style of each character'
+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.fast -> use_fast_editing:   boolean  "Don't fill polygons while editing"
+TextCurve.font -> font:   pointer  'NO DESCRIPTION'
+TextCurve.line_dist -> line_distance:   float  'NO DESCRIPTION'
+TextCurve.map_along_length -> use_map_along_length:   boolean  'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'
+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.small_caps_scale -> small_caps_scale:   float  'Scale of small capitals'
+TextCurve.spacemode -> spacemode:   enum  'Text align from the object center'
+TextCurve.spacing -> spacing:   float  'NO DESCRIPTION'
+TextCurve.text_on_curve -> text_on_curve:   pointer  'Curve deforming text object'
+TextCurve.text_size -> text_size:   float  'NO DESCRIPTION'
+TextCurve.textboxes -> textboxes:   collection,  '(read-only)'
+TextCurve.ul_height -> ul_height:   float  'NO DESCRIPTION'
+TextCurve.ul_position -> ul_position:   float  'Vertical position of underline'
+TextCurve.word_spacing -> word_spacing:   float  'NO DESCRIPTION'
+TextLine.line -> line:   string  'Text in the line'
+TextMarker.color -> color:   float  'Color to display the marker with'
+TextMarker.edit_all -> use_edit_all:   boolean,  '(read-only)    Edit all markers of the same group as one'
+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'
+TextMarker.temporary -> is_temporary:   boolean,  '(read-only)    Marker is temporary'
+Texture.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
+Texture.brightness -> intensity:   float  'NO DESCRIPTION'
+Texture.color_ramp -> color_ramp:   pointer,  '(read-only)'
+Texture.contrast -> contrast:   float  'NO DESCRIPTION'
+Texture.factor_blue -> factor_blue:   float  'NO DESCRIPTION'
+Texture.factor_green -> factor_green:   float  'NO DESCRIPTION'
+Texture.factor_red -> factor_red:   float  'NO DESCRIPTION'
+Texture.node_tree -> node_tree:   pointer,  '(read-only)    Node tree for node-based textures'
+Texture.saturation -> saturation:   float  'NO DESCRIPTION'
+Texture.type -> type:   enum  'NO DESCRIPTION'
+Texture.use_color_ramp -> use_color_ramp:   boolean  'Toggle color ramp operations'
+Texture.use_nodes -> use_nodes:   boolean  'Make this a node-based texture'
+Texture.use_preview_alpha -> use_preview_alpha:   boolean  'Show Alpha in Preview Render'
+TextureNode.type -> type:   enum,  '(read-only)'
+TextureNodeBricks.offset -> offset:   float  'NO DESCRIPTION'
+TextureNodeBricks.offset_frequency -> offset_frequency:   int  'Offset every N rows'
+TextureNodeBricks.squash -> squash:   float  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+TextureNodeCurveTime.start -> start:   int  'NO DESCRIPTION'
+TextureNodeImage.image -> image:   pointer  'NO DESCRIPTION'
+TextureNodeMath.operation -> operation:   enum  'NO DESCRIPTION'
+TextureNodeMixRGB.alpha -> use_alpha:   boolean  'Include alpha of second input in this operation'
+TextureNodeMixRGB.blend_type -> blend_type:   enum  'NO DESCRIPTION'
+TextureNodeOutput.output_name -> output_name:   string  'NO DESCRIPTION'
+TextureNodeTexture.node_output -> node_output:   int  'For node-based textures, which output node to use'
+TextureNodeTexture.texture -> texture:   pointer  'NO DESCRIPTION'
+TextureNodeValToRGB.color_ramp -> color_ramp:   pointer,  '(read-only)'
+TextureSlot.blend_type -> blend_type:   enum  'NO DESCRIPTION'
+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.negate -> invert:   boolean  'Inverts the values of the texture to reverse its effect'
+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.rgb_to_intensity -> use_rgb_to_intensity:   boolean  'Converts texture RGB values to intensity (gray) values'
+TextureSlot.size -> size:   float  "Sets scaling for the texture's X, Y and Z sizes"
+TextureSlot.stencil -> use_stencil:   boolean  'Use this texture as a blending value on the next texture'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+ThemeAudioWindow.button -> button:   float  'NO DESCRIPTION'
+ThemeAudioWindow.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeAudioWindow.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeAudioWindow.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeAudioWindow.frame_current -> frame_current:   float  'NO DESCRIPTION'
+ThemeAudioWindow.grid -> grid:   float  'NO DESCRIPTION'
+ThemeAudioWindow.header -> header:   float  'NO DESCRIPTION'
+ThemeAudioWindow.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeAudioWindow.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeAudioWindow.text -> text:   float  'NO DESCRIPTION'
+ThemeAudioWindow.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeAudioWindow.title -> title:   float  'NO DESCRIPTION'
+ThemeAudioWindow.window_sliders -> window_sliders:   float  'NO DESCRIPTION'
+ThemeBoneColorSet.active -> active:   float  'Color used for active bones'
+ThemeBoneColorSet.colored_constraints -> show_colored_constraints:   boolean  'Allow the use of colors indicating constraints/keyed status'
+ThemeBoneColorSet.normal -> normal:   float  'Color used for the surface of bones'
+ThemeBoneColorSet.select -> select:   float  'Color used for selected bones'
+ThemeConsole.back -> back:   float  'NO DESCRIPTION'
+ThemeConsole.button -> button:   float  'NO DESCRIPTION'
+ThemeConsole.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeConsole.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeConsole.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeConsole.cursor -> cursor:   float  'NO DESCRIPTION'
+ThemeConsole.header -> header:   float  'NO DESCRIPTION'
+ThemeConsole.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeConsole.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeConsole.line_error -> line_error:   float  'NO DESCRIPTION'
+ThemeConsole.line_info -> line_info:   float  'NO DESCRIPTION'
+ThemeConsole.line_input -> line_input:   float  'NO DESCRIPTION'
+ThemeConsole.line_output -> line_output:   float  'NO DESCRIPTION'
+ThemeConsole.text -> text:   float  'NO DESCRIPTION'
+ThemeConsole.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeConsole.title -> title:   float  'NO DESCRIPTION'
+ThemeDopeSheet.active_channels_group -> active_channels_group:   float  'NO DESCRIPTION'
+ThemeDopeSheet.back -> back:   float  'NO DESCRIPTION'
+ThemeDopeSheet.button -> button:   float  'NO DESCRIPTION'
+ThemeDopeSheet.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeDopeSheet.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeDopeSheet.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeDopeSheet.channel_group -> channel_group:   float  'NO DESCRIPTION'
+ThemeDopeSheet.channels -> channels:   float  'NO DESCRIPTION'
+ThemeDopeSheet.channels_selected -> channels_selected:   float  'NO DESCRIPTION'
+ThemeDopeSheet.dopesheet_channel -> dopesheet_channel:   float  'NO DESCRIPTION'
+ThemeDopeSheet.dopesheet_subchannel -> dopesheet_subchannel:   float  'NO DESCRIPTION'
+ThemeDopeSheet.frame_current -> frame_current:   float  'NO DESCRIPTION'
+ThemeDopeSheet.grid -> grid:   float  'NO DESCRIPTION'
+ThemeDopeSheet.header -> header:   float  'NO DESCRIPTION'
+ThemeDopeSheet.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeDopeSheet.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeDopeSheet.list -> list:   float  'NO DESCRIPTION'
+ThemeDopeSheet.list_text -> list_text:   float  'NO DESCRIPTION'
+ThemeDopeSheet.list_text_hi -> list_text_hi:   float  'NO DESCRIPTION'
+ThemeDopeSheet.list_title -> list_title:   float  'NO DESCRIPTION'
+ThemeDopeSheet.long_key -> long_key:   float  'NO DESCRIPTION'
+ThemeDopeSheet.long_key_selected -> long_key_selected:   float  'NO DESCRIPTION'
+ThemeDopeSheet.text -> text:   float  'NO DESCRIPTION'
+ThemeDopeSheet.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeDopeSheet.title -> title:   float  'NO DESCRIPTION'
+ThemeDopeSheet.value_sliders -> value_sliders:   float  'NO DESCRIPTION'
+ThemeDopeSheet.view_sliders -> view_sliders:   float  'NO DESCRIPTION'
+ThemeFileBrowser.active_file -> active_file:   float  'NO DESCRIPTION'
+ThemeFileBrowser.active_file_text -> active_file_text:   float  'NO DESCRIPTION'
+ThemeFileBrowser.back -> back:   float  'NO DESCRIPTION'
+ThemeFileBrowser.button -> button:   float  'NO DESCRIPTION'
+ThemeFileBrowser.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeFileBrowser.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeFileBrowser.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeFileBrowser.header -> header:   float  'NO DESCRIPTION'
+ThemeFileBrowser.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeFileBrowser.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeFileBrowser.list -> list:   float  'NO DESCRIPTION'
+ThemeFileBrowser.list_text -> list_text:   float  'NO DESCRIPTION'
+ThemeFileBrowser.list_text_hi -> list_text_hi:   float  'NO DESCRIPTION'
+ThemeFileBrowser.list_title -> list_title:   float  'NO DESCRIPTION'
+ThemeFileBrowser.scroll_handle -> scroll_handle:   float  'NO DESCRIPTION'
+ThemeFileBrowser.scrollbar -> scrollbar:   float  'NO DESCRIPTION'
+ThemeFileBrowser.selected_file -> selected_file:   float  'NO DESCRIPTION'
+ThemeFileBrowser.text -> text:   float  'NO DESCRIPTION'
+ThemeFileBrowser.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeFileBrowser.tiles -> tiles:   float  'NO DESCRIPTION'
+ThemeFileBrowser.title -> title:   float  'NO DESCRIPTION'
+ThemeFontStyle.font_kerning_style -> font_kerning_style:   enum  'Which style to use for font kerning'
+ThemeFontStyle.points -> points:   int  'NO DESCRIPTION'
+ThemeFontStyle.shadow -> shadow:   int  'Shadow size in pixels (0, 3 and 5 supported)'
+ThemeFontStyle.shadowalpha -> shadowalpha:   float  'NO DESCRIPTION'
+ThemeFontStyle.shadowcolor -> shadowcolor:   float  'Shadow color in grey value'
+ThemeFontStyle.shadx -> shadow_offset_x:   int  'Shadow offset in pixels'
+ThemeFontStyle.shady -> shadow_offset_y:   int  'Shadow offset in pixels'
+ThemeGraphEditor.active_channels_group -> active_channels_group:   float  'NO DESCRIPTION'
+ThemeGraphEditor.back -> back:   float  'NO DESCRIPTION'
+ThemeGraphEditor.button -> button:   float  'NO DESCRIPTION'
+ThemeGraphEditor.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeGraphEditor.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeGraphEditor.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeGraphEditor.channel_group -> channel_group:   float  'NO DESCRIPTION'
+ThemeGraphEditor.channels_region -> channels_region:   float  'NO DESCRIPTION'
+ThemeGraphEditor.dopesheet_channel -> dopesheet_channel:   float  'NO DESCRIPTION'
+ThemeGraphEditor.dopesheet_subchannel -> dopesheet_subchannel:   float  'NO DESCRIPTION'
+ThemeGraphEditor.frame_current -> frame_current:   float  'NO DESCRIPTION'
+ThemeGraphEditor.grid -> grid:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_align -> handle_align:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_auto -> handle_auto:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_free -> handle_free:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_sel_align -> handle_sel_align:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_sel_auto -> handle_sel_auto:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_sel_free -> handle_sel_free:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_sel_vect -> handle_sel_vect:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_vect -> handle_vect:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_vertex -> handle_vertex:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_vertex_select -> handle_vertex_select:   float  'NO DESCRIPTION'
+ThemeGraphEditor.handle_vertex_size -> handle_vertex_size:   int  'NO DESCRIPTION'
+ThemeGraphEditor.header -> header:   float  'NO DESCRIPTION'
+ThemeGraphEditor.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeGraphEditor.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeGraphEditor.lastsel_point -> lastsel_point:   float  'NO DESCRIPTION'
+ThemeGraphEditor.list -> list:   float  'NO DESCRIPTION'
+ThemeGraphEditor.list_text -> list_text:   float  'NO DESCRIPTION'
+ThemeGraphEditor.list_text_hi -> list_text_hi:   float  'NO DESCRIPTION'
+ThemeGraphEditor.list_title -> list_title:   float  'NO DESCRIPTION'
+ThemeGraphEditor.panel -> panel:   float  'NO DESCRIPTION'
+ThemeGraphEditor.text -> text:   float  'NO DESCRIPTION'
+ThemeGraphEditor.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeGraphEditor.title -> title:   float  'NO DESCRIPTION'
+ThemeGraphEditor.vertex -> vertex:   float  'NO DESCRIPTION'
+ThemeGraphEditor.vertex_select -> vertex_select:   float  'NO DESCRIPTION'
+ThemeGraphEditor.vertex_size -> vertex_size:   int  'NO DESCRIPTION'
+ThemeGraphEditor.window_sliders -> window_sliders:   float  'NO DESCRIPTION'
+ThemeImageEditor.back -> back:   float  'NO DESCRIPTION'
+ThemeImageEditor.button -> button:   float  'NO DESCRIPTION'
+ThemeImageEditor.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeImageEditor.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeImageEditor.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeImageEditor.editmesh_active -> editmesh_active:   float  'NO DESCRIPTION'
+ThemeImageEditor.face -> face:   float  'NO DESCRIPTION'
+ThemeImageEditor.face_dot -> face_dot:   float  'NO DESCRIPTION'
+ThemeImageEditor.face_select -> face_select:   float  'NO DESCRIPTION'
+ThemeImageEditor.facedot_size -> facedot_size:   int  'NO DESCRIPTION'
+ThemeImageEditor.header -> header:   float  'NO DESCRIPTION'
+ThemeImageEditor.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeImageEditor.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeImageEditor.scope_back -> scope_back:   float  'NO DESCRIPTION'
+ThemeImageEditor.text -> text:   float  'NO DESCRIPTION'
+ThemeImageEditor.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeImageEditor.title -> title:   float  'NO DESCRIPTION'
+ThemeImageEditor.vertex -> vertex:   float  'NO DESCRIPTION'
+ThemeImageEditor.vertex_select -> vertex_select:   float  'NO DESCRIPTION'
+ThemeImageEditor.vertex_size -> vertex_size:   int  'NO DESCRIPTION'
+ThemeInfo.back -> back:   float  'NO DESCRIPTION'
+ThemeInfo.button -> button:   float  'NO DESCRIPTION'
+ThemeInfo.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeInfo.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeInfo.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeInfo.header -> header:   float  'NO DESCRIPTION'
+ThemeInfo.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeInfo.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeInfo.text -> text:   float  'NO DESCRIPTION'
+ThemeInfo.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeInfo.title -> title:   float  'NO DESCRIPTION'
+ThemeLogicEditor.back -> back:   float  'NO DESCRIPTION'
+ThemeLogicEditor.button -> button:   float  'NO DESCRIPTION'
+ThemeLogicEditor.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeLogicEditor.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeLogicEditor.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeLogicEditor.header -> header:   float  'NO DESCRIPTION'
+ThemeLogicEditor.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeLogicEditor.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeLogicEditor.panel -> panel:   float  'NO DESCRIPTION'
+ThemeLogicEditor.text -> text:   float  'NO DESCRIPTION'
+ThemeLogicEditor.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeLogicEditor.title -> title:   float  'NO DESCRIPTION'
+ThemeNLAEditor.back -> back:   float  'NO DESCRIPTION'
+ThemeNLAEditor.bars -> bars:   float  'NO DESCRIPTION'
+ThemeNLAEditor.bars_selected -> bars_selected:   float  'NO DESCRIPTION'
+ThemeNLAEditor.button -> button:   float  'NO DESCRIPTION'
+ThemeNLAEditor.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeNLAEditor.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeNLAEditor.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeNLAEditor.frame_current -> frame_current:   float  'NO DESCRIPTION'
+ThemeNLAEditor.grid -> grid:   float  'NO DESCRIPTION'
+ThemeNLAEditor.header -> header:   float  'NO DESCRIPTION'
+ThemeNLAEditor.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeNLAEditor.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeNLAEditor.list -> list:   float  'NO DESCRIPTION'
+ThemeNLAEditor.list_text -> list_text:   float  'NO DESCRIPTION'
+ThemeNLAEditor.list_text_hi -> list_text_hi:   float  'NO DESCRIPTION'
+ThemeNLAEditor.list_title -> list_title:   float  'NO DESCRIPTION'
+ThemeNLAEditor.strips -> strips:   float  'NO DESCRIPTION'
+ThemeNLAEditor.strips_selected -> strips_selected:   float  'NO DESCRIPTION'
+ThemeNLAEditor.text -> text:   float  'NO DESCRIPTION'
+ThemeNLAEditor.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeNLAEditor.title -> title:   float  'NO DESCRIPTION'
+ThemeNLAEditor.view_sliders -> view_sliders:   float  'NO DESCRIPTION'
+ThemeNodeEditor.back -> back:   float  'NO DESCRIPTION'
+ThemeNodeEditor.button -> button:   float  'NO DESCRIPTION'
+ThemeNodeEditor.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeNodeEditor.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeNodeEditor.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeNodeEditor.converter_node -> converter_node:   float  'NO DESCRIPTION'
+ThemeNodeEditor.group_node -> group_node:   float  'NO DESCRIPTION'
+ThemeNodeEditor.header -> header:   float  'NO DESCRIPTION'
+ThemeNodeEditor.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeNodeEditor.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeNodeEditor.in_out_node -> in_out_node:   float  'NO DESCRIPTION'
+ThemeNodeEditor.list -> list:   float  'NO DESCRIPTION'
+ThemeNodeEditor.list_text -> list_text:   float  'NO DESCRIPTION'
+ThemeNodeEditor.list_text_hi -> list_text_hi:   float  'NO DESCRIPTION'
+ThemeNodeEditor.list_title -> list_title:   float  'NO DESCRIPTION'
+ThemeNodeEditor.node_backdrop -> node_backdrop:   float  'NO DESCRIPTION'
+ThemeNodeEditor.operator_node -> operator_node:   float  'NO DESCRIPTION'
+ThemeNodeEditor.selected_text -> selected_text:   float  'NO DESCRIPTION'
+ThemeNodeEditor.text -> text:   float  'NO DESCRIPTION'
+ThemeNodeEditor.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeNodeEditor.title -> title:   float  'NO DESCRIPTION'
+ThemeNodeEditor.wire_select -> wire_select:   float  'NO DESCRIPTION'
+ThemeNodeEditor.wires -> wires:   float  'NO DESCRIPTION'
+ThemeOutliner.back -> back:   float  'NO DESCRIPTION'
+ThemeOutliner.button -> button:   float  'NO DESCRIPTION'
+ThemeOutliner.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeOutliner.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeOutliner.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeOutliner.header -> header:   float  'NO DESCRIPTION'
+ThemeOutliner.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeOutliner.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeOutliner.text -> text:   float  'NO DESCRIPTION'
+ThemeOutliner.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeOutliner.title -> title:   float  'NO DESCRIPTION'
+ThemeProperties.back -> back:   float  'NO DESCRIPTION'
+ThemeProperties.button -> button:   float  'NO DESCRIPTION'
+ThemeProperties.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeProperties.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeProperties.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeProperties.header -> header:   float  'NO DESCRIPTION'
+ThemeProperties.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeProperties.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeProperties.panel -> panel:   float  'NO DESCRIPTION'
+ThemeProperties.text -> text:   float  'NO DESCRIPTION'
+ThemeProperties.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeProperties.title -> title:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.audio_strip -> audio_strip:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.back -> back:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.button -> button:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.draw_action -> draw_action:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.effect_strip -> effect_strip:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.frame_current -> frame_current:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.grid -> grid:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.header -> header:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.image_strip -> image_strip:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.keyframe -> keyframe:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.meta_strip -> meta_strip:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.movie_strip -> movie_strip:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.plugin_strip -> plugin_strip:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.scene_strip -> scene_strip:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.text -> text:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.title -> title:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.transition_strip -> transition_strip:   float  'NO DESCRIPTION'
+ThemeSequenceEditor.window_sliders -> window_sliders:   float  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+ThemeTextEditor.button -> button:   float  'NO DESCRIPTION'
+ThemeTextEditor.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeTextEditor.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeTextEditor.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeTextEditor.cursor -> cursor:   float  'NO DESCRIPTION'
+ThemeTextEditor.header -> header:   float  'NO DESCRIPTION'
+ThemeTextEditor.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeTextEditor.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeTextEditor.line_numbers_background -> line_numbers_background:   float  'NO DESCRIPTION'
+ThemeTextEditor.scroll_bar -> scroll_bar:   float  'NO DESCRIPTION'
+ThemeTextEditor.selected_text -> selected_text:   float  'NO DESCRIPTION'
+ThemeTextEditor.syntax_builtin -> syntax_builtin:   float  'NO DESCRIPTION'
+ThemeTextEditor.syntax_comment -> syntax_comment:   float  'NO DESCRIPTION'
+ThemeTextEditor.syntax_numbers -> syntax_numbers:   float  'NO DESCRIPTION'
+ThemeTextEditor.syntax_special -> syntax_special:   float  'NO DESCRIPTION'
+ThemeTextEditor.syntax_string -> syntax_string:   float  'NO DESCRIPTION'
+ThemeTextEditor.text -> text:   float  'NO DESCRIPTION'
+ThemeTextEditor.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeTextEditor.title -> title:   float  'NO DESCRIPTION'
+ThemeTimeline.back -> back:   float  'NO DESCRIPTION'
+ThemeTimeline.button -> button:   float  'NO DESCRIPTION'
+ThemeTimeline.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeTimeline.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeTimeline.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeTimeline.frame_current -> frame_current:   float  'NO DESCRIPTION'
+ThemeTimeline.grid -> grid:   float  'NO DESCRIPTION'
+ThemeTimeline.header -> header:   float  'NO DESCRIPTION'
+ThemeTimeline.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeTimeline.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeTimeline.text -> text:   float  'NO DESCRIPTION'
+ThemeTimeline.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeTimeline.title -> title:   float  'NO DESCRIPTION'
+ThemeUserInterface.icon_file -> icon_file:   string  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+ThemeUserPreferences.button -> button:   float  'NO DESCRIPTION'
+ThemeUserPreferences.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeUserPreferences.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeUserPreferences.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeUserPreferences.header -> header:   float  'NO DESCRIPTION'
+ThemeUserPreferences.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeUserPreferences.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeUserPreferences.text -> text:   float  'NO DESCRIPTION'
+ThemeUserPreferences.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeUserPreferences.title -> title:   float  'NO DESCRIPTION'
+ThemeView3D.act_spline -> act_spline:   float  'NO DESCRIPTION'
+ThemeView3D.back -> back:   float  'NO DESCRIPTION'
+ThemeView3D.bone_pose -> bone_pose:   float  'NO DESCRIPTION'
+ThemeView3D.bone_solid -> bone_solid:   float  'NO DESCRIPTION'
+ThemeView3D.button -> button:   float  'NO DESCRIPTION'
+ThemeView3D.button_text -> button_text:   float  'NO DESCRIPTION'
+ThemeView3D.button_text_hi -> button_text_hi:   float  'NO DESCRIPTION'
+ThemeView3D.button_title -> button_title:   float  'NO DESCRIPTION'
+ThemeView3D.edge_crease -> edge_crease:   float  'NO DESCRIPTION'
+ThemeView3D.edge_facesel -> edge_facesel:   float  'NO DESCRIPTION'
+ThemeView3D.edge_seam -> edge_seam:   float  'NO DESCRIPTION'
+ThemeView3D.edge_select -> edge_select:   float  'NO DESCRIPTION'
+ThemeView3D.edge_sharp -> edge_sharp:   float  'NO DESCRIPTION'
+ThemeView3D.editmesh_active -> editmesh_active:   float  'NO DESCRIPTION'
+ThemeView3D.face -> face:   float  'NO DESCRIPTION'
+ThemeView3D.face_dot -> face_dot:   float  'NO DESCRIPTION'
+ThemeView3D.face_select -> face_select:   float  'NO DESCRIPTION'
+ThemeView3D.facedot_size -> facedot_size:   int  'NO DESCRIPTION'
+ThemeView3D.frame_current -> frame_current:   float  'NO DESCRIPTION'
+ThemeView3D.grid -> grid:   float  'NO DESCRIPTION'
+ThemeView3D.handle_align -> handle_align:   float  'NO DESCRIPTION'
+ThemeView3D.handle_auto -> handle_auto:   float  'NO DESCRIPTION'
+ThemeView3D.handle_free -> handle_free:   float  'NO DESCRIPTION'
+ThemeView3D.handle_sel_align -> handle_sel_align:   float  'NO DESCRIPTION'
+ThemeView3D.handle_sel_auto -> handle_sel_auto:   float  'NO DESCRIPTION'
+ThemeView3D.handle_sel_free -> handle_sel_free:   float  'NO DESCRIPTION'
+ThemeView3D.handle_sel_vect -> handle_sel_vect:   float  'NO DESCRIPTION'
+ThemeView3D.handle_vect -> handle_vect:   float  'NO DESCRIPTION'
+ThemeView3D.header -> header:   float  'NO DESCRIPTION'
+ThemeView3D.header_text -> header_text:   float  'NO DESCRIPTION'
+ThemeView3D.header_text_hi -> header_text_hi:   float  'NO DESCRIPTION'
+ThemeView3D.lamp -> lamp:   float  'NO DESCRIPTION'
+ThemeView3D.lastsel_point -> lastsel_point:   float  'NO DESCRIPTION'
+ThemeView3D.normal -> normal:   float  'NO DESCRIPTION'
+ThemeView3D.nurb_sel_uline -> nurb_sel_uline:   float  'NO DESCRIPTION'
+ThemeView3D.nurb_sel_vline -> nurb_sel_vline:   float  'NO DESCRIPTION'
+ThemeView3D.nurb_uline -> nurb_uline:   float  'NO DESCRIPTION'
+ThemeView3D.nurb_vline -> nurb_vline:   float  'NO DESCRIPTION'
+ThemeView3D.object_active -> object_active:   float  'NO DESCRIPTION'
+ThemeView3D.object_grouped -> object_grouped:   float  'NO DESCRIPTION'
+ThemeView3D.object_grouped_active -> object_grouped_active:   float  'NO DESCRIPTION'
+ThemeView3D.object_selected -> object_selected:   float  'NO DESCRIPTION'
+ThemeView3D.panel -> panel:   float  'NO DESCRIPTION'
+ThemeView3D.text -> text:   float  'NO DESCRIPTION'
+ThemeView3D.text_hi -> text_hi:   float  'NO DESCRIPTION'
+ThemeView3D.title -> title:   float  'NO DESCRIPTION'
+ThemeView3D.transform -> transform:   float  'NO DESCRIPTION'
+ThemeView3D.vertex -> vertex:   float  'NO DESCRIPTION'
+ThemeView3D.vertex_normal -> vertex_normal:   float  'NO DESCRIPTION'
+ThemeView3D.vertex_select -> vertex_select:   float  'NO DESCRIPTION'
+ThemeView3D.vertex_size -> vertex_size:   int  'NO DESCRIPTION'
+ThemeView3D.wire -> wire:   float  'NO DESCRIPTION'
+ThemeWidgetColors.inner -> inner:   float  'NO DESCRIPTION'
+ThemeWidgetColors.inner_sel -> inner_sel:   float  'NO DESCRIPTION'
+ThemeWidgetColors.item -> item:   float  'NO DESCRIPTION'
+ThemeWidgetColors.outline -> outline:   float  'NO DESCRIPTION'
+ThemeWidgetColors.shaded -> show_shaded:   boolean  'NO DESCRIPTION'
+ThemeWidgetColors.shadedown -> shadedown:   int  'NO DESCRIPTION'
+ThemeWidgetColors.shadetop -> shadetop:   int  'NO DESCRIPTION'
+ThemeWidgetColors.text -> text:   float  'NO DESCRIPTION'
+ThemeWidgetColors.text_sel -> text_sel:   float  'NO DESCRIPTION'
+ThemeWidgetStateColors.blend -> blend:   float  'NO DESCRIPTION'
+ThemeWidgetStateColors.inner_anim -> inner_anim:   float  'NO DESCRIPTION'
+ThemeWidgetStateColors.inner_anim_sel -> inner_anim_sel:   float  'NO DESCRIPTION'
+ThemeWidgetStateColors.inner_driven -> inner_driven:   float  'NO DESCRIPTION'
+ThemeWidgetStateColors.inner_driven_sel -> inner_driven_sel:   float  'NO DESCRIPTION'
+ThemeWidgetStateColors.inner_key -> inner_key:   float  'NO DESCRIPTION'
+ThemeWidgetStateColors.inner_key_sel -> inner_key_sel:   float  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+TimelineMarker.select -> select:   boolean  'Marker selection state'
+ToolSettings.auto_normalize -> use_auto_normalize:   boolean  'Ensure all bone-deforming vertex groups add up to 1.0 while weight painting'
+ToolSettings.autokey_mode -> autokey_mode:   enum  'Mode of automatic keyframe insertion for Objects and Bones'
+ToolSettings.automerge_editing -> use_automerge_editing:   boolean  'Automatically merge vertices moved to the same location'
+ToolSettings.bone_sketching -> use_bone_sketching:   boolean  'DOC BROKEN'
+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_autoname -> use_etch_autoname:   boolean  'DOC BROKEN'
+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_overdraw -> use_etch_overdraw:   boolean  'DOC BROKEN'
+ToolSettings.etch_quick -> use_etch_quick:   boolean  '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.mesh_selection_mode -> mesh_selection_mode:   boolean  'Which mesh elements selection works on'
+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_edit:   enum  'Proportional editing mode'
+ToolSettings.proportional_editing_falloff -> proportional_edit_falloff:   enum  'Falloff type for proportional editing mode'
+ToolSettings.proportional_editing_objects -> proportional_editing_objects:   boolean  'Proportional editing object mode'
+ToolSettings.record_with_nla -> use_record_with_nla:   boolean  'Add a new NLA Track + Strip for every loop/pass made over the animation to allow non-destructive tweaking'
+ToolSettings.sculpt -> sculpt:   pointer,  '(read-only)'
+ToolSettings.sculpt_paint_use_unified_size -> sculpt_paint_use_unified_size:   boolean  'Instead of per brush radius, the radius is shared across brushes'
+ToolSettings.sculpt_paint_use_unified_strength -> sculpt_paint_use_unified_strength:   boolean  'Instead of per brush strength, the strength is shared across brushes'
+ToolSettings.snap -> use_snap:   boolean  'Snap during transform'
+ToolSettings.snap_align_rotation -> use_snap_align_rotation:   boolean  'Align rotation with the snapping target'
+ToolSettings.snap_element -> snap_element:   enum  'Type of element to snap to'
+ToolSettings.snap_peel_object -> use_snap_peel_object:   boolean  'Consider objects as whole when finding volume center'
+ToolSettings.snap_project -> use_snap_project:   boolean  'Project vertices on the surface of other objects'
+ToolSettings.snap_target -> snap_target:   enum  'Which part to snap onto the target'
+ToolSettings.use_auto_keying -> use_keyframe_insert_auto:   boolean  'Automatic keyframe insertion for Objects and Bones'
+ToolSettings.uv_local_view -> show_local_view:   boolean  'Draw only faces with the currently displayed image assigned'
+ToolSettings.uv_selection_mode -> uv_selection_mode:   enum  'UV selection and display mode'
+ToolSettings.uv_sync_selection -> use_uv_sync_selection:   boolean  'Keep UV and edit mode mesh selection in sync'
+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  'NO DESCRIPTION'
+TrackToConstraint.target -> target:   pointer  'Target Object'
+TrackToConstraint.target_z -> use_target_z:   boolean  "Target's Z axis, not World Z axis, will constraint the Up direction"
+TrackToConstraint.track -> track:   enum  'Axis that points to the target object'
+TrackToConstraint.up -> up:   enum  'Axis that points upward'
+TransformConstraint.extrapolate_motion -> use_motion_extrapolate:   boolean  'Extrapolate ranges'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+TransformOrientation.name -> name:   string  'NO DESCRIPTION'
+TransformSequence.interpolation -> interpolation:   enum  'NO DESCRIPTION'
+TransformSequence.rotation_start -> rotation_start:   float  'NO DESCRIPTION'
+TransformSequence.scale_start_x -> scale_start_x:   float  'NO DESCRIPTION'
+TransformSequence.scale_start_y -> scale_start_y:   float  'NO DESCRIPTION'
+TransformSequence.translate_start_x -> translate_start_x:   float  'NO DESCRIPTION'
+TransformSequence.translate_start_y -> translate_start_y:   float  'NO DESCRIPTION'
+TransformSequence.translation_unit -> translation_unit:   enum  'NO DESCRIPTION'
+TransformSequence.uniform_scale -> use_uniform_scale:   boolean  'Scale uniformly, preserving aspect ratio'
+UILayout.active -> show_active:   boolean  'NO DESCRIPTION'
+UILayout.alignment -> alignment:   enum  'NO DESCRIPTION'
+UILayout.enabled -> show_enabled:   boolean  'NO DESCRIPTION'
+UILayout.operator_context -> operator_context:   enum  'NO DESCRIPTION'
+UILayout.scale_x -> scale_x:   float  'NO DESCRIPTION'
+UILayout.scale_y -> scale_y:   float  'NO DESCRIPTION'
+UVProjectModifier.aspect_x -> aspect_x:   float  'NO DESCRIPTION'
+UVProjectModifier.aspect_y -> aspect_y:   float  'NO DESCRIPTION'
+UVProjectModifier.image -> image:   pointer  'NO DESCRIPTION'
+UVProjectModifier.num_projectors -> num_projectors:   int  'Number of projectors to use'
+UVProjectModifier.override_image -> use_image_override:   boolean  "Override faces' current images with the given image"
+UVProjectModifier.projectors -> projectors:   collection,  '(read-only)'
+UVProjectModifier.scale_x -> scale_x:   float  'NO DESCRIPTION'
+UVProjectModifier.scale_y -> scale_y:   float  'NO DESCRIPTION'
+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'
+UnitSettings.use_separate -> use_separate:   boolean  'Display units in pairs'
+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_keyframe_insert_available -> use_keyframe_insert_available:   boolean  'Automatic keyframe insertion in available curves'
+UserPreferencesEdit.auto_keyframe_insert_keyingset -> use_keyframe_insert_keyingset:   boolean  'Automatic keyframe insertion using active Keying Set'
+UserPreferencesEdit.auto_keying_mode -> auto_keying_mode:   enum  'Mode of automatic keyframe insertion for Objects and Bones'
+UserPreferencesEdit.drag_immediately -> use_drag_immediately:   boolean  'Moving things with a mouse drag confirms when releasing the button'
+UserPreferencesEdit.duplicate_action -> use_duplicate_action:   boolean  'Causes actions to be duplicated with the object'
+UserPreferencesEdit.duplicate_armature -> use_duplicate_armature:   boolean  'Causes armature data to be duplicated with the object'
+UserPreferencesEdit.duplicate_curve -> use_duplicate_curve:   boolean  'Causes curve data to be duplicated with the object'
+UserPreferencesEdit.duplicate_fcurve -> use_duplicate_fcurve:   boolean  'Causes F-curve data to be duplicated with the object'
+UserPreferencesEdit.duplicate_lamp -> use_duplicate_lamp:   boolean  'Causes lamp data to be duplicated with the object'
+UserPreferencesEdit.duplicate_material -> use_duplicate_material:   boolean  'Causes material data to be duplicated with the object'
+UserPreferencesEdit.duplicate_mesh -> use_duplicate_mesh:   boolean  'Causes mesh data to be duplicated with the object'
+UserPreferencesEdit.duplicate_metaball -> use_duplicate_metaball:   boolean  'Causes metaball data to be duplicated with the object'
+UserPreferencesEdit.duplicate_particle -> use_duplicate_particle:   boolean  'Causes particle systems to be duplicated with the object'
+UserPreferencesEdit.duplicate_surface -> use_duplicate_surface:   boolean  'Causes surface data to be duplicated with the object'
+UserPreferencesEdit.duplicate_text -> use_duplicate_text:   boolean  'Causes text data to be duplicated with the object'
+UserPreferencesEdit.duplicate_texture -> use_duplicate_texture:   boolean  'Causes texture data to be duplicated with the object'
+UserPreferencesEdit.enter_edit_mode -> use_enter_edit_mode:   boolean  'Enter Edit Mode automatically after adding a new object'
+UserPreferencesEdit.global_undo -> use_global_undo:   boolean  'Global undo works by keeping a full copy of the file itself in memory, so takes extra memory'
+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.grease_pencil_simplify_stroke -> use_grease_pencil_simplify_stroke:   boolean  'Simplify the final stroke'
+UserPreferencesEdit.grease_pencil_smooth_stroke -> use_grease_pencil_smooth_stroke:   boolean  'Smooth the final stroke'
+UserPreferencesEdit.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:   boolean  'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
+UserPreferencesEdit.keyframe_insert_needed -> use_keyframe_insert_needed:   boolean  'Keyframe insertion only when keyframe needed'
+UserPreferencesEdit.keyframe_new_handle_type -> keyframe_new_handle_type:   enum  'NO DESCRIPTION'
+UserPreferencesEdit.keyframe_new_interpolation_type -> keyframe_new_interpolation_type:   enum  'NO DESCRIPTION'
+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.sculpt_paint_overlay_col -> sculpt_paint_overlay_col:   float  'Color of texture overlay'
+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)'
+UserPreferencesEdit.use_auto_keying -> use_auto_keying:   boolean  'Automatic keyframe insertion for Objects and Bones'
+UserPreferencesEdit.use_negative_frames -> use_negative_frames:   boolean  'Current frame number can be manually set to a negative value'
+UserPreferencesEdit.use_visual_keying -> use_visual_keying:   boolean  'Use Visual keying automatically for constrained objects'
+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_temporary_files -> use_auto_save_temporary_files:   boolean  'Automatic saving of temporary files'
+UserPreferencesFilePaths.auto_save_time -> auto_save_time:   int  'The time (in minutes) to wait between automatic temporary saves'
+UserPreferencesFilePaths.compress_file -> use_file_compression:   boolean  'Enable file compression when saving .blend files'
+UserPreferencesFilePaths.filter_file_extensions -> use_filter_files:   boolean  'Display only files with extensions in the image select window'
+UserPreferencesFilePaths.fonts_directory -> fonts_directory:   string  'The default directory to search for loading fonts'
+UserPreferencesFilePaths.hide_dot_files_datablocks -> show_hidden_files_datablocks:   boolean  'Hide files/datablocks that start with a dot(.*)'
+UserPreferencesFilePaths.image_editor -> image_editor:   string  'Path to an image editor'
+UserPreferencesFilePaths.load_ui -> use_load_ui:   boolean  'Load user interface setup when loading .blend files'
+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_preview_images -> use_save_preview_images:   boolean  'Enables automatic saving of preview images in the .blend file'
+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'
+UserPreferencesFilePaths.use_relative_paths -> use_relative_paths:   boolean  'Default relative path option for the file selector'
+UserPreferencesInput.continuous_mouse -> use_continuous_mouse:   boolean  'Allow moving the mouse outside the view on some manipulations (transform, ui control drag)'
+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.emulate_3_button_mouse -> use_emulate_3_button_mouse:   boolean  "Emulates Middle Mouse with Alt+LeftMouse (doesn't work with Left Mouse Select option)"
+UserPreferencesInput.emulate_numpad -> use_emulate_numpad:   boolean  'Causes the 1 to 0 keys to act as the numpad (useful for laptops)'
+UserPreferencesInput.invert_zoom_direction -> invert_mouse_wheel_zoom:   boolean  'Invert the axis of mouse movement for zooming'
+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.use_middle_mouse_paste -> use_mouse_mmb_paste:   boolean  'In text window, paste with middle mouse button instead of panning'
+UserPreferencesInput.view_rotation -> view_rotation:   enum  'Rotation style in the viewport'
+UserPreferencesInput.wheel_invert_zoom -> wheel_invert_zoom:   boolean  'Swap the Mouse Wheel zoom direction'
+UserPreferencesInput.wheel_scroll_lines -> wheel_scroll_lines:   int  'The number of lines scrolled at a time with the mouse wheel'
+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.auto_execute_scripts -> use_scripts_auto_execute:   boolean  'Allow any .blend file to run scripts automatically (unsafe with blend files from an untrusted source)'
+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.enable_all_codecs -> use_preview_images:   boolean  'Enables automatic saving of preview images in the .blend file (Windows only)'
+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.international_fonts -> use_international_fonts:   boolean  'Use international fonts'
+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.tabs_as_spaces -> use_tabs_as_spaces:   boolean  'Automatically converts all new tabs into spaces for new and loaded text files'
+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.translate_buttons -> use_translate_buttons:   boolean  'Translate button labels'
+UserPreferencesSystem.translate_toolbox -> use_translate_toolbox:   boolean  'Translate toolbox menu'
+UserPreferencesSystem.translate_tooltips -> use_translate_tooltips:   boolean  'Translate Tooltips'
+UserPreferencesSystem.use_antialiasing -> use_antialiasing:   boolean  'Use anti-aliasing for the 3D view (may impact redraw performance)'
+UserPreferencesSystem.use_mipmaps -> use_mipmaps:   boolean  'Scale textures for the 3D View (looks nicer but uses more memory and slows image reloading)'
+UserPreferencesSystem.use_textured_fonts -> use_textured_fonts:   boolean  'Use textures for drawing international fonts'
+UserPreferencesSystem.use_vbos -> use_vertex_buffer_objects:   boolean  'Use Vertex Buffer Objects (or Vertex Arrays, if unsupported) for viewport rendering'
+UserPreferencesSystem.use_weight_color_range -> use_weight_color_range:   boolean  'Enable color range used for weight visualization in weight painting mode'
+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.auto_depth -> use_mouse_auto_depth:   boolean  'Use the depth under the mouse to improve view pan/rotate/zoom functionality'
+UserPreferencesView.auto_perspective -> use_auto_perspective:   boolean  'Automatically switch between orthographic and perspective when changing from top/front/side views'
+UserPreferencesView.directional_menus -> use_directional_menus:   boolean  'Otherwise menus, etc will always be top to bottom, left to right, no matter opening direction'
+UserPreferencesView.display_object_info -> show_object_info:   boolean  'Display objects name and frame number in 3D view'
+UserPreferencesView.global_pivot -> use_global_pivot:   boolean  'Lock the same rotation/scaling pivot in all 3D Views'
+UserPreferencesView.global_scene -> use_global_scene:   boolean  'Forces the current Scene to be displayed in all Screens'
+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_mouse_over -> use_mouse_over_open:   boolean  'Open menu buttons and pulldowns automatically when the mouse is hovering'
+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.rotate_around_selection -> use_rotate_around_selection:   boolean  'Use selection as the pivot point'
+UserPreferencesView.rotation_angle -> rotation_angle:   int  'The rotation step for numerical pad keys (2 4 6 8)'
+UserPreferencesView.show_mini_axis -> show_mini_axis:   boolean  'Show a small rotating 3D axis in the bottom left corner of the 3D View'
+UserPreferencesView.show_playback_fps -> show_playback_fps:   boolean  'Show the frames per second screen refresh rate, while animation is played back'
+UserPreferencesView.show_splash -> show_splash:   boolean  'Display splash screen on startup'
+UserPreferencesView.show_view_name -> show_view_name:   boolean  "Show the name of the view's direction in each 3D View"
+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.tooltips -> show_tooltips:   boolean  'Display tooltips'
+UserPreferencesView.use_column_layout -> show_column_layout:   boolean  'Use a column layout for toolbox'
+UserPreferencesView.use_large_cursors -> show_large_cursors:   boolean  'Use large mouse cursors when available'
+UserPreferencesView.use_manipulator -> show_manipulator:   boolean  'Use 3D transform manipulator'
+UserPreferencesView.view2d_grid_minimum_spacing -> view2d_grid_spacing_min:   int  'Minimum number of pixels between each gridline in 2D Viewports'
+UserPreferencesView.zoom_to_mouse -> use_zoom_to_mouse:   boolean  "Zoom in towards the mouse pointer's position in the 3D view, rather than the 2D window center"
+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.enabled -> use:   boolean  'Enable this OpenGL light in solid draw mode'
+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'
+VertexPaint.all_faces -> use_all_faces:   boolean  'Paint on all faces inside brush'
+VertexPaint.normals -> use_normal:   boolean  'Applies the vertex normal before painting'
+VertexPaint.spray -> use_spray:   boolean  'Keep applying paint effect while holding mouse'
+VisibilityActuator.children -> apply_to_children:   boolean  'Set all the children of this object to the same visibility/occlusion recursively'
+VisibilityActuator.occlusion -> use_occlusion:   boolean  'Set the object to occlude objects behind it. Initialized from the object type in physics button'
+VisibilityActuator.visible -> use_visible:   boolean  'Set the objects visible. Initialized from the objects render restriction toggle (access in the outliner)'
+VoronoiTexture.coloring -> color_mode:   enum  'NO DESCRIPTION'
+VoronoiTexture.distance_metric -> distance_metric:   enum  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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 -> use_still_frame:   boolean  'Always render a still frame from the voxel data sequence'
+VoxelData.still_frame_number -> still_frame_number:   int  'The frame number to always use'
+VoxelDataTexture.image -> image:   pointer  'NO DESCRIPTION'
+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.cyclic -> use_cyclic:   boolean  'Cyclic wave effect'
+WaveModifier.damping_time -> damping_time:   float  'NO DESCRIPTION'
+WaveModifier.falloff_radius -> falloff_radius:   float  'NO DESCRIPTION'
+WaveModifier.height -> height:   float  'NO DESCRIPTION'
+WaveModifier.lifetime -> lifetime:   float  'NO DESCRIPTION'
+WaveModifier.narrowness -> narrowness:   float  'NO DESCRIPTION'
+WaveModifier.normals -> use_normal:   boolean  'Displace along normal'
+WaveModifier.speed -> speed:   float  'NO DESCRIPTION'
+WaveModifier.start_position_object -> start_position_object:   pointer  'NO DESCRIPTION'
+WaveModifier.start_position_x -> start_position_x:   float  'NO DESCRIPTION'
+WaveModifier.start_position_y -> start_position_y:   float  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+WaveModifier.x -> use_x:   boolean  'X axis motion'
+WaveModifier.x_normal -> use_normal_x:   boolean  'Enable displacement along the X normal'
+WaveModifier.y -> use_y:   boolean  'Y axis motion'
+WaveModifier.y_normal -> use_normal_y:   boolean  'Enable displacement along the Y normal'
+WaveModifier.z_normal -> use_normal_z:   boolean  'Enable displacement along the Z normal'
+Window.screen -> screen:   pointer  'Active screen showing in the window'
+WindowManager.active_keyconfig -> active_keyconfig:   pointer  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+WoodTexture.noisebasis2 -> noisebasis2:   enum  'NO DESCRIPTION'
+WoodTexture.stype -> stype:   enum  'NO DESCRIPTION'
+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  'NO DESCRIPTION'
+World.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
+World.blend_sky -> use_sky_blend:   boolean  'Render background with natural progression from horizon to zenith'
+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.paper_sky -> use_sky_paper:   boolean  'Flatten blend or texture coordinates'
+World.range -> range:   float  'The color range that will be mapped to 0-1'
+World.real_sky -> use_sky_real:   boolean  'Render background with a real horizon, relative to the camera angle'
+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_type:   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 -> use_falloff:   boolean  'NO DESCRIPTION'
+WorldLighting.falloff_strength -> falloff_strength:   float  "Distance attenuation factor, the higher, the 'shorter' the shadows"
+WorldLighting.gather_method -> gather_method:   enum  'NO DESCRIPTION'
+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.pixel_cache -> use_cache:   boolean  'Cache AO results in pixels and interpolate over neighbouring pixels for speedup (for Approximate)'
+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)'
+WorldLighting.use_ambient_occlusion -> use_ambient_occlusian:   boolean  'Use Ambient Occlusion to add shadowing based on distance between objects'
+WorldLighting.use_environment_lighting -> use_environment_lighting:   boolean  'Add light coming from the environment'
+WorldLighting.use_indirect_lighting -> use_indirect_lighting:   boolean  'Add indirect light bouncing of surrounding objects'
+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'
+WorldMistSettings.use_mist -> use_mist:   boolean  'Occlude objects with the environment color as they are further away'
+WorldStarsSettings.average_separation -> average_separation:   float  'Average distance between any two stars'
+WorldStarsSettings.color_randomization -> color_randomization:   float  'Randomize star colors'
+WorldStarsSettings.min_distance -> distance_min:   float  'Minimum distance to the camera for stars'
+WorldStarsSettings.size -> size:   float  'Average screen dimension of stars'
+WorldStarsSettings.use_stars -> use_stars:   boolean  'Enable starfield generation'
+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.map_blend -> use_map_blend:   boolean  'Affect the color progression of the background'
+WorldTextureSlot.map_horizon -> use_map_horizon:   boolean  'Affect the color of the horizon'
+WorldTextureSlot.map_zenith_down -> use_map_zenith_down:   boolean  'Affect the color of the zenith below'
+WorldTextureSlot.map_zenith_up -> use_map_zenith_up:   boolean  'Affect the color of the zenith above'
+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'